From 167fdaf8b41d19f119df8484f004d968e9fc68fd Mon Sep 17 00:00:00 2001 From: Nic Gaffney Date: Mon, 13 Oct 2025 02:49:48 -0500 Subject: Update to zig 0.15.1 complete, along with further optimization --- src/imgui.zig | 4 ++-- src/main.zig | 50 +++++++++++++++++++++++++++++--------------------- src/particle.zig | 34 ++++++++++++++++------------------ src/quad.zig | 24 +++++++++++++----------- src/rules.zig | 42 ++++++++++++++++++++++-------------------- 5 files changed, 82 insertions(+), 72 deletions(-) (limited to 'src') diff --git a/src/imgui.zig b/src/imgui.zig index 688e935..f086f2a 100644 --- a/src/imgui.zig +++ b/src/imgui.zig @@ -30,13 +30,13 @@ pub fn update(alloc: std.mem.Allocator, buf: [:0]u8) !void { } if (z.collapsingHeader("Radius", .{ .default_open = true })) { for (&cfg.radius, 0..) |*r, i| { - const str = rul.colorToStringZ(i); + const str = rul.colorToStringZ(i, "", " Radius"); _ = z.sliderInt(str, .{ .v = r, .min = cfg.minDistance, .max = 500 }); } } if (z.collapsingHeader("Speed", .{ .default_open = true })) { for (&cfg.speed, 0..) |*s, i| { - const str = rul.colorToStringZ(i); + const str = rul.colorToStringZ(i, "", " Speed"); _ = z.sliderInt(str, .{ .v = s, .min = 1, .max = 1000 }); } } diff --git a/src/main.zig b/src/main.zig index f7ec0a0..4d21dae 100644 --- a/src/main.zig +++ b/src/main.zig @@ -17,18 +17,18 @@ pub fn main() !void { cfg.rules = rules.ruleMatrix(true, true); rules.printRules(cfg.rules); - var gpa = std.heap.GeneralPurposeAllocator(.{ - // .safety = true, - // .thread_safe = true, - // .verbose_log = false, - }){}; - defer { - const leaked = gpa.deinit(); - if (leaked == .leak) { - std.debug.print("LEAKY PROGRAM\n", .{}); - } - } - const allocator = gpa.allocator(); + const allocator = std.heap.smp_allocator; + // defer { + // const leaked = smp.deinit(); + // if (leaked == .leak) { + // std.debug.print("LEAKY PROGRAM\n", .{}); + // } + // } + // gpa.setRequestedMemoryLimit(8000000); + // const allocator = smp.allocator(); + // var buffer: [80000000]u8 = undefined; + // var fbuffer = std.heap.FixedBufferAllocator.init(&buffer); + // const allocator = fbuffer.threadSafeAllocator(); rl.initWindow(cfg.screenWidth, cfg.screenHeight, "Particle Simulator"); defer rl.closeWindow(); @@ -49,18 +49,20 @@ pub fn main() !void { var particles = try part.initParticles(allocator, cfg.initialParticles); defer particles.deinit(); var quadTree: quad.Quad(part.particle, cfg.quadSplitLimit) = undefined; + // defer quadTree.deinit(); const buf = try allocator.allocSentinel(u8, 128, 0); std.mem.copyForwards(u8, buf, "Absolute File Path" ++ .{0}); defer allocator.free(buf); const pool = try allocator.alloc(std.Thread, cfg.numThreads); + var particleArrs: [cfg.numThreads]std.ArrayList(part.particle) = undefined; + for (0..cfg.numThreads) |i| + particleArrs[i] = try std.ArrayList(part.particle).initCapacity(allocator, comptime @divFloor(cfg.particleMax, cfg.numThreads) + cfg.numThreads); defer allocator.free(pool); - var frameCounter: u32 = 0; while (!rl.windowShouldClose()) { if (particles.items.len < cfg.particleCount) { for (0..@intCast(cfg.particleCount - @as(i32, @intCast(particles.items.len)))) |_| { - //std.debug.print("without this print statement it breaks on arm idk why {d}\n", .{cfg.particleCount}); _ = cfg.particleCount; try particles.append(part.createParticle()); } @@ -70,22 +72,28 @@ pub fn main() !void { particles.shrinkRetainingCapacity(@intCast(cfg.particleCount)); } - quadTree = quad.Quad(part.particle, cfg.quadSplitLimit).init(allocator, - .{ .x = 0, .y = 0 }, .{ .x = rl.getScreenWidth(), .y = rl.getScreenHeight()}); - defer quadTree.deinit(); + + quadTree = try quad.Quad(part.particle, cfg.quadSplitLimit).init(allocator, + .{ .x = 0, .y = 0 }, + .{ .x = rl.getScreenWidth(), .y = rl.getScreenHeight()}); + // defer quadTree.deinit(); for (particles.items) |p| try quadTree.insert(.{ .pos = p.pos, .data = p}); rl.beginDrawing(); defer rl.endDrawing(); - if (rl.isKeyPressed(rl.KeyboardKey.key_q)) break; + if (rl.isKeyPressed(rl.KeyboardKey.q)) { + quadTree.deinit(); + break; + } rl.clearBackground(rl.getColor(0x1E1E2EFF)); - for (pool, 0..) |*thread, i| - thread.* = try std.Thread.spawn(.{}, part.updateVelocities, .{ particles, quadTree, i }); + for (pool, 0..) |*thread, i| { + thread.* = try std.Thread.spawn(.{}, part.updateVelocities, .{ particles, quadTree, i, &particleArrs[i] }); + } for (pool) |thread| thread.join(); - frameCounter += 1; + quadTree.deinit(); part.updatePosition(&particles); diff --git a/src/particle.zig b/src/particle.zig index d33e7ce..14748dc 100644 --- a/src/particle.zig +++ b/src/particle.zig @@ -9,9 +9,10 @@ pub const particle = struct { xvel: f32, yvel: f32, }; -/// Initialize a MultiArrayList of size amnt with particles created by createParticle -pub fn initParticles(allocator: std.mem.Allocator, amnt: u32) !std.ArrayList(particle) { - var particles = std.ArrayList(particle).init(allocator); + +/// Initialize an array_list.Managed of size amnt with particles created by createParticle +pub fn initParticles(allocator: std.mem.Allocator, amnt: u32) !std.array_list.Managed(particle) { + var particles = std.array_list.Managed(particle).init(allocator); try particles.ensureTotalCapacity(cfg.particleMax); for (0..amnt) |_| try particles.append(createParticle()); @@ -21,38 +22,38 @@ pub fn initParticles(allocator: std.mem.Allocator, amnt: u32) !std.ArrayList(par /// Applies forces from the ruleset to each particle pub fn updateVelocities( - particles: std.ArrayList(particle), + particles: std.array_list.Managed(particle), qtree: quad.Quad(particle, cfg.quadSplitLimit), threadidx: u64, + particlesInRange: *std.ArrayList(particle), ) !void { const rules = cfg.rules; - var particlesInRange = std.ArrayList(particle).init(qtree.allocator); - defer particlesInRange.deinit(); var i = threadidx; while (i < particles.items.len) : (i += cfg.numThreads) { var p: *particle = &(particles.items[i]); defer particlesInRange.clearRetainingCapacity(); const radius = cfg.radius[p.colorId]; - try qtree.radiusSearchWrapping(p.pos, @intCast(radius), &particlesInRange, rl.getScreenWidth(), rl.getScreenHeight()); + try qtree.radiusSearchWrapping(p.pos, @intCast(radius), particlesInRange, rl.getScreenWidth(), rl.getScreenHeight()); var forceX: f32 = 0.0; var forceY: f32 = 0.0; const floatRadius = @as(f32, @floatFromInt(radius)); const floattMinDistance = @as(f32, @floatFromInt(cfg.minDistance)); for (particlesInRange.items) |p2| { if (p.pos.x == p2.pos.x and p.pos.y == p2.pos.y) continue; + // distance calculations const distance_x: f32 = @floatFromInt(p.pos.x - p2.pos.x); const distance_y: f32 = @floatFromInt(p.pos.y - p2.pos.y); var distance = @sqrt(distance_x * distance_x + distance_y * distance_y); if (distance == 0) distance = 0.01; + // force calculations const f = -force(distance, floatRadius, rules[p.colorId][p2.colorId]); forceX += (distance_x / distance) * f; forceY += (distance_y / distance) * f; } + // update velocity forceX = forceX * floattMinDistance / floatRadius; - // forceX = std.math.clamp(forceX, -10.0, 10.0); forceY = forceY * floattMinDistance / floatRadius; - // forceY = std.math.clamp(forceY, -10.0, 10.0); - p.xvel *= cfg.friction ; + p.xvel *= cfg.friction; p.xvel += forceX; p.yvel *= cfg.friction; p.yvel += forceY; @@ -60,18 +61,15 @@ pub fn updateVelocities( } /// Applies the particles velocity and updates position -pub fn updatePosition(particles: *std.ArrayList(particle)) void { +pub fn updatePosition(particles: *std.array_list.Managed(particle)) void { for (particles.items) |*p| { - const maxVel: f32 = 4096.0; - const posYplusVel: f32 = @as(f32, @floatFromInt(p.pos.y)) + std.math.clamp(p.yvel, -maxVel, maxVel); - const posXplusVel: f32 = @as(f32, @floatFromInt(p.pos.x)) + std.math.clamp(p.xvel, -maxVel, maxVel); - p.pos.y = @mod(@as(i32, @intFromFloat(posYplusVel)), rl.getScreenHeight()); - p.pos.x = @mod(@as(i32, @intFromFloat(posXplusVel)), rl.getScreenWidth()); + p.pos.y = @mod(@as(i32, @intFromFloat(@round(@as(f32, @floatFromInt(p.pos.y)) + (@as(f32, @floatFromInt(cfg.speed[p.colorId])) / 1000.0) * p.yvel))), rl.getScreenHeight()); + p.pos.x = @mod(@as(i32, @intFromFloat(@round(@as(f32, @floatFromInt(p.pos.x)) + (@as(f32, @floatFromInt(cfg.speed[p.colorId])) / 1000.0) * p.xvel))), rl.getScreenWidth()); } } /// Draw the particles onto the screen using raylib -pub fn draw(particles: std.ArrayList(particle)) void { +pub fn draw(particles: std.array_list.Managed(particle)) void { for (particles.items) |p| rl.drawRectangle(p.pos.x, p.pos.y, 5, 5, cfg.colors[p.colorId]); } @@ -88,7 +86,7 @@ fn force(distance: f32, radius: f32, attraction: f32) f32 { pub fn createParticle() particle { const seed = @as(u64, @truncate(@as(u128, @bitCast(std.time.nanoTimestamp())))); - var prng = std.rand.DefaultPrng.init(seed); + var prng = std.Random.DefaultPrng.init(seed); const x = prng.random().uintLessThan(u32, @intCast(rl.getScreenWidth())); const y = prng.random().uintLessThan(u32, @intCast(rl.getScreenHeight())); const color = prng.random().uintLessThan(u32, cfg.colorAmnt); diff --git a/src/quad.zig b/src/quad.zig index 0d4174e..db24589 100644 --- a/src/quad.zig +++ b/src/quad.zig @@ -16,17 +16,17 @@ pub fn Node(T: type) type { pub fn Quad(T: type, comptime splitLimit: usize) type { return struct { allocator: std.mem.Allocator, - nodes: ?std.BoundedArray(Node(T), splitLimit), + nodes: ?std.ArrayList(Node(T)), topLeft: Point, bottomRight: Point, children: [4]?*Quad(T, splitLimit), const Self = @This(); - pub fn init(allocator: std.mem.Allocator, tl: Point, br: Point) Quad(T, splitLimit) { + pub fn init(allocator: std.mem.Allocator, tl: Point, br: Point) !Self { return Quad(T, splitLimit){ .allocator = allocator, - .nodes = std.BoundedArray(Node(T), splitLimit).init(0) catch unreachable, + .nodes = try std.ArrayList(Node(T)).initCapacity(allocator, splitLimit), .topLeft = tl, .bottomRight = br, .children = [4]?*Quad(T, splitLimit){ null, null, null, null }, @@ -89,8 +89,8 @@ pub fn Quad(T: type, comptime splitLimit: usize) type { 3 => self.bottomRight, else => unreachable, }; - self.children[quadrant] = try self.allocator.create(Quad(T, splitLimit)); - self.children[quadrant].?.* = Quad(T, splitLimit).init(self.allocator, tl, br); + self.children[quadrant] = try self.allocator.create(Self); + self.children[quadrant].?.* = try Self.init(self.allocator, tl, br); } fn split(self: *Quad(T, splitLimit)) !void { @@ -98,7 +98,7 @@ pub fn Quad(T: type, comptime splitLimit: usize) type { for (0..4) |i| if (self.children[i] == null) try self.createChild(i); - const nodesToRedistribute = self.nodes.?.slice(); + const nodesToRedistribute = self.nodes.?.items; for (nodesToRedistribute) |node| { const quadrant = self.getQuadrant(node.pos); try self.children[quadrant].?.insert(node); @@ -116,7 +116,7 @@ pub fn Quad(T: type, comptime splitLimit: usize) type { return; } if (self.nodes) |*nodes| { - nodes.append(node) catch { + nodes.appendBounded(node) catch { try self.split(); const quadrant = self.getQuadrant(node.pos); try self.children[quadrant].?.insert(node); @@ -128,7 +128,7 @@ pub fn Quad(T: type, comptime splitLimit: usize) type { if (!self.inBoundry(p)) return null; if (self.nodes) |nodes| { - for (nodes.slice()) |node| + for (nodes.items) |node| if (node.pos.x == p.x and node.pos.y == p.y) return node; return null; @@ -144,9 +144,9 @@ pub fn Quad(T: type, comptime splitLimit: usize) type { if (!self.intersectsCircle(center, radius)) return; if (self.nodes) |nodes| { - for (nodes.slice()) |node| + for (nodes.items) |node| if (locationInRadius(center, node.pos, radius)) { - try results.append(node.data); + try results.appendBounded(node.data); }; return; } @@ -245,7 +245,9 @@ pub fn Quad(T: type, comptime splitLimit: usize) type { return self.inRadius(center, radius) or self.inBoundry(center); } - pub fn deinit(self: *Quad(T, splitLimit)) void { + pub fn deinit(self: *Self) void { + if (self.nodes) |*n| + n.deinit(self.allocator); for (self.children) |child| { if (child) |c| { c.deinit(); diff --git a/src/rules.zig b/src/rules.zig index 4e513eb..fac1999 100644 --- a/src/rules.zig +++ b/src/rules.zig @@ -4,7 +4,7 @@ const std = @import("std"); /// Generate the set of rules the particles will abide by pub fn ruleMatrix(radius: bool, speed: bool) [cfg.colorAmnt][cfg.colorAmnt]f32 { const seed = @as(u64, @truncate(@as(u128, @bitCast(std.time.nanoTimestamp())))); - var prng = std.rand.DefaultPrng.init(seed); + var prng = std.Random.DefaultPrng.init(seed); var rules: [cfg.colorAmnt][cfg.colorAmnt]f32 = undefined; for (0..cfg.colorAmnt) |i| { for (0..cfg.colorAmnt) |j| { @@ -39,36 +39,37 @@ pub fn printRules(rules: [cfg.colorAmnt][cfg.colorAmnt]f32) void { /// Loads rules from a csv pub fn loadRules(allocator: std.mem.Allocator, absolutePath: [:0]u8) !void { + var buffer: [256]u8 = undefined; const file = try std.fs.openFileAbsoluteZ(absolutePath, .{ .mode = .read_only }); defer file.close(); - var reader = file.reader(); + var reader = file.reader(&buffer).interface; for (&cfg.rules) |*row| { for (row) |*col| { - const buf = try reader.readUntilDelimiterAlloc(allocator, ',', 16); + const buf = try reader.takeDelimiterExclusive(','); defer allocator.free(buf); col.* = try std.fmt.parseFloat(f32, buf); } - try reader.skipBytes(1, .{}); + reader.toss(1); } for (&cfg.speed) |*s| { - const buf = try reader.readUntilDelimiterAlloc(allocator, ',', 16); + const buf = try reader.takeDelimiterExclusive(','); defer allocator.free(buf); s.* = try std.fmt.parseInt(i32, buf, 10); } - try reader.skipBytes(1, .{}); + reader.toss(1); for (&cfg.radius) |*r| { - const buf = try reader.readUntilDelimiterAlloc(allocator, ',', 16); + const buf = try reader.takeDelimiterExclusive(','); defer allocator.free(buf); r.* = try std.fmt.parseInt(i32, buf, 10); } - try reader.skipBytes(1, .{}); + reader.toss(1); { - const buf = try reader.readUntilDelimiterAlloc(allocator, ',', 16); + const buf = try reader.takeDelimiterExclusive(','); defer allocator.free(buf); cfg.minDistance = try std.fmt.parseInt(i32, buf, 10); } { - const buf = try reader.readUntilDelimiterAlloc(allocator, ',', 16); + const buf = try reader.takeDelimiterExclusive(','); defer allocator.free(buf); cfg.friction = try std.fmt.parseFloat(f32, buf); } @@ -76,9 +77,10 @@ pub fn loadRules(allocator: std.mem.Allocator, absolutePath: [:0]u8) !void { /// Save rules to a csv pub fn saveRules(absolutePath: [:0]u8) !void { + var buffer: [256]u8 = undefined; const file = try std.fs.createFileAbsoluteZ(absolutePath, .{ .read = true }); defer file.close(); - var writer = file.writer(); + var writer = file.writer(&buffer).interface; for (cfg.rules) |row| { for (row) |col| { try writer.print("{d:.3},", .{col}); @@ -112,16 +114,16 @@ pub inline fn colorToString(c: usize) []const u8 { }; } -pub inline fn colorToStringZ(c: usize) [:0]const u8 { +pub inline fn colorToStringZ(c: usize, comptime prepend: []const u8, comptime append: []const u8) [:0]const u8 { return switch (c) { - 0 => "Red", - 1 => "Green", - 2 => "Blue", - 3 => "Yellow", - 4 => "Magenta", - 5 => "Brown", - 6 => "Orange", - 7 => "Gray", + 0 => prepend ++ "Red" ++ append, + 1 => prepend ++ "Green" ++ append, + 2 => prepend ++ "Blue" ++ append, + 3 => prepend ++ "Yellow" ++ append, + 4 => prepend ++ "Magenta" ++ append, + 5 => prepend ++ "Brown" ++ append, + 6 => prepend ++ "Orange" ++ append, + 7 => prepend ++ "Gray" ++ append, else => " ", }; } -- cgit v1.2.3