rework part of particles and utils

src/main.zig

@@ -2,221 +2,14 @@ const std = @import("std");
 const rl = @import("raylib");
 const rg = @import("raygui");
 const pr = @import("primitives.zig");
+const particles = @import("particles.zig");
 const plot = @import("plot.zig");
 
 const allocator = std.heap.page_allocator;
-var prng = std.rand.DefaultPrng.init(124346234556);
-const rand = prng.random();
 
 const screenWidth = 1200;
 const screenHeight = 800;
 
-
-fn randMinMaxFloat(min: f32, max: f32) f32 {
-    var r1 = rand.float(f32);
-    r1 = 2 * (r1 - 0.5); //-0.5..0.5
-    return (@abs(min) + @abs(max)) / 2 * r1;
-}
-
-const Particle = struct {
-    const Self = @This();
-    position: pr.Vec = .{ .a = .{ .x = 0, .y = 0, .z = 0 } },
-    velocity: pr.Vec = .{ .a = .{ .x = 0, .y = 0, .z = 0 } },
-    acceleration: pr.Vec = .{ .a = .{ .x = 0, .y = 0, .z = 0 } },
-    lifespan: u8 = 0,
-    show: u8 = 0,
-    size: f32 = 0,
-    pub fn new(self: Self) void {
-        _ = self;
-    }
-    pub fn update(self: *Self) void {
-        self.velocity.add(self.acceleration);
-        self.position.add(self.velocity);
-        if (self.position.a.y > screenHeight) {
-            self.velocity.a.y *= -0.9;
-            // self.acceleration.a.y *= -0.5;
-        }
-
-        if (self.lifespan > 0) {
-            self.lifespan -= 1;
-        } else {
-            self.show = 0;
-        }
-        self.acceleration.a.x = 0;
-        self.acceleration.a.y = 0;
-        self.acceleration.a.z = 0;
-    }
-    pub fn spawn(self: *Self, xaccel: f32, yaccel: f32) void {
-        const xrnr = randMinMaxFloat(-xaccel, xaccel);
-        const yrnr = randMinMaxFloat(-yaccel, yaccel);
-
-        self.size = randMinMaxFloat(-2,2);
-        self.lifespan = rand.intRangeAtMost(u8, 75, 255);
-        self.acceleration.a.x = xrnr;
-        self.acceleration.a.y = yrnr;
-        self.position.a.x = @floatFromInt(rl.getMouseX() - screenWidth / 2);
-        self.position.a.y = @floatFromInt(rl.getMouseY() - screenHeight / 2);
-        self.velocity.a.x = 0;
-        self.velocity.a.y = 0;
-        self.position.a.color.r = rand.intRangeAtMost(u8, 0, 30);
-        self.position.a.color.g = rand.intRangeAtMost(u8, 0, 255);
-        self.position.a.color.b = rand.intRangeAtMost(u8, 0, 255);
-        self.show = 1;
-    }
-    pub fn applyGravity(self: *Self, val: f32) void {
-        self.velocity.a.y += val;
-    }
-    pub fn applyForce(self: *Self, vec: pr.Vec) void {
-        self.acceleration.a.x += vec.a.x * 0.8;
-        self.acceleration.a.y += vec.a.y * 0.8;
-        self.acceleration.a.z = vec.a.z;
-        self.velocity.a.x *= 0.995;
-        self.velocity.a.y *= 0.995;
-    }
-};
-
-const Emitter = struct {
-    particleCount: u32 = 0,
-    particles: []Particle = undefined,
-
-    pub fn init(self: *Emitter) !void {
-        var xrnr = randMinMaxFloat(-1, 1);
-        var yrnr = randMinMaxFloat(-0.5, 0.5);
-        self.particles = try allocator.alloc(Particle, 500000);
-        for (self.particles) |*p| {
-            xrnr = randMinMaxFloat(-2, 2);
-            yrnr = randMinMaxFloat(-2, 2);
-            p.* = Particle{ .velocity = .{ .a = .{ .x = 0, .y = 0 } }, .acceleration = .{ .a = .{ .x = xrnr, .y = yrnr } } };
-        }
-    }
-    pub fn emit(self: *Emitter, count: u32, xaccel: f32, yaccel: f32) void {
-        var i: u32 = 0;
-        for (self.particles) |*p| {
-            if (p.show == 0) {
-                i += 1;
-                p.spawn(xaccel, yaccel);
-            }
-            if (i >= count) {
-                break;
-            }
-        }
-    }
-    pub fn update(self: *Emitter,att : []Attractor, texture: rl.Texture2D, color : rl.Color) void {
-        var posx: i32 = 0;
-        var posy: i32 = 0;
-
-        var vec2 : rl.Vector2=undefined;
-
-        if (rl.isMouseButtonPressed(rl.MouseButton.mouse_button_right)) {
-            for (att) |*at|
-            {
-                if(at.init_done != 1)
-                {
-                    at.init(.{.a=.{.x=@floatFromInt(rl.getMouseX() - screenWidth / 2),.y=@floatFromInt(rl.getMouseY() - screenHeight / 2),.z=0}});
-                    at.mode = 1;
-                    break;
-                }
-            }
-        }
-        if (rl.isMouseButtonPressed(rl.MouseButton.mouse_button_middle)) {
-            for (att) |*at|
-            {
-                if(at.init_done != 1)
-                {
-                    at.init(.{.a=.{.x=@floatFromInt(rl.getMouseX() - screenWidth / 2),.y=@floatFromInt(rl.getMouseY() - screenHeight / 2),.z=0}});
-                    at.mode = 0;
-                    break;
-                }
-            }
-        }
-
-        for (att) |at|
-        {
-            at.draw();
-        }
-        for (self.particles) |*p| {
-            if (p.show == 1) {
-                //p.applyGravity(2);
-                for (att) |at|
-                {
-                    if(at.mode == 0)
-                    {
-                        p.applyForce(at.attract(p.*));
-                    }
-                    else
-                    {
-                        p.applyForce(at.repel(p.*));
-                    }
-                }
-                p.update();
-
-                if(p.position.a.x < 10000 and p.position.a.x > -10000)
-                {
-                    posx = @intFromFloat(screenWidth / 2 + p.position.a.x);
-                }
-                if(p.position.a.y < 10000 and p.position.a.y > -10000)
-                {
-                    posy = @intFromFloat(screenHeight / 2 + p.position.a.y);
-                }
-                //rl.drawRectangle(posx,posy,2,2,rl.Color{.r=p.position.a.color.r,.g=p.position.a.color.g,.b=p.position.a.color.b,.a=255});
-                vec2 = .{.x = (screenWidth/2+p.position.a.x),.y = (screenHeight/2+p.position.a.y)};
-                rl.drawTextureEx(texture, vec2,0.5,p.size, color);
-            }
-        }
-    }
-};
-const Attractor = struct {
-    vec: pr.Vec,
-    init_done : u8 = 0,
-    mode : u8 = 0,
-    pub fn init(self : *Attractor, vec : pr.Vec) void
-    {
-        self.vec = vec;
-        self.init_done = 1;
-    }
-    pub fn attract(self: Attractor, particle: Particle) pr.Vec {
-        if(self.init_done == 1)
-        {
-            const distance = self.vec.sub(particle.position);
-            var force: pr.Vec = undefined;
-            if (distance.a.x != 0 and distance.a.y != 0) {
-                force.a.x = distance.a.x  * @abs(1/distance.a.x);
-                force.a.y = distance.a.y  * @abs(1/distance.a.y);
-                force.a.z = 0;
-            }
-            return force;
-        }
-        else
-        {
-            return .{.a=.{.x=0,.y=0,.z=0}};
-        }
-    }
-    pub fn repel(self: Attractor, particle: Particle) pr.Vec {
-        if(self.init_done == 1)
-        {
-            const distance = self.vec.sub(particle.position);
-            var force: pr.Vec = undefined;
-            if (distance.a.x != 0 and distance.a.y != 0) {
-                force.a.x = -distance.a.x  * @abs(1/distance.a.x);
-                force.a.y = -distance.a.y  * @abs(1/distance.a.y);
-                force.a.z = 0;
-            }
-            return force;
-        }
-        else
-        {
-            return .{.a=.{.x=0,.y=0,.z=0}};
-        }
-    }
-    pub fn draw(self: Attractor) void {
-        const posx: i32 = @intFromFloat(screenWidth / 2 + self.vec.a.x);
-        const posy: i32 = @intFromFloat(screenHeight / 2 + self.vec.a.y);
-        if (self.init_done == 1)
-        {
-            rl.drawRectangle(posx, posy, 10, 10, rl.Color{ .r = 10, .g = 10, .b = 120, .a = 255 });
-        }
-    }
-};
 fn ItoF(x: i32) f32 {
     return @as(f32, @floatFromInt(x));
 }
@@ -225,20 +18,13 @@ fn rectangle(x: u16, y: u16, width: u16, height: u16) rl.Rectangle {
 }
 
 pub fn main() anyerror!void {
-
-
-    var seed: u64 = undefined;
-    try std.posix.getrandom(std.mem.asBytes(&seed));
-
-    prng = std.rand.DefaultPrng.init(seed);
-
     var value: f32 = 0;
     var value2: f32 = 0;
     var value3: f32 = 0;
     var color: rl.Color = undefined;
 
-    var emitter = Emitter{};
+    var emitter = particles.Emitter{};
-    try emitter.init();
+    try emitter.init(allocator, screenWidth, screenHeight);
 
     //const img : rl.Texture = rl.loadTexture("img.png");
     rl.initWindow(screenWidth, screenHeight, "raylib-zig [core] example - basic window");
@@ -253,14 +39,14 @@ pub fn main() anyerror!void {
         std.posix.exit(1);
     }
     rl.unloadImage(image);
-
     rl.setTargetFPS(60);
 
     const file = try plot.open("plot.dat");
     var plotStr: []u8 = undefined;
     var plotStrBuf: [128]u8 = undefined;
     try plot.log(file, "acceleration, position, velocity, show\n");
-    var att: [10]Attractor = undefined;
+
+    var att: [10]particles.Attractor = undefined;
     var active: i32 = 0;
     var editMode: bool = false;
 
@@ -280,10 +66,8 @@ pub fn main() anyerror!void {
             std.debug.print("dropdownbox: {}", .{active});
         }
 
-        if(active == 1)
+        if (active == 1) {
-        {
+            if (rg.guiWindowBox(rectangle(10, 10, 800, 600), "Window Box") == 1) {
-            if(rg.guiWindowBox(rectangle(10,10,800,600),"Window Box") == 1)
-            {
                 active = 0;
                 editMode = false;
             }
@@ -293,8 +77,6 @@ pub fn main() anyerror!void {
             _ = rg.guiSlider(rectangle(10, 190, 600, 10), "-3", "3", &value3, -100, 100);
             _ = rg.guiColorPicker(rectangle(10, 200, 300, 100), "Choose Color", &color);
         }
-        else
-        {
         if (rl.isMouseButtonDown(rl.MouseButton.mouse_button_left)) {
             emitter.emit(@as(u32, @intFromFloat(value)), value2, value3);
         }
@@ -306,9 +88,9 @@ pub fn main() anyerror!void {
         emitter.update(&att, texture, color);
         rl.endBlendMode();
     }
-    }
     plot.close(file);
 }
+fn updateGUI() !void {}
 
 test "simple test" {
     var list = std.ArrayList(i32).init(std.testing.allocator);
@@ -316,18 +98,3 @@ test "simple test" {
     try list.append(42);
     try std.testing.expectEqual(@as(i32, 42), list.pop());
 }
-
-test "random" {
-    var seed: u64 = undefined;
-    var r1: f32 = undefined;
-    try std.posix.getrandom(std.mem.asBytes(&seed));
-
-    prng = std.rand.DefaultPrng.init(seed);
-    while (true) {
-        r1 = randMinMaxFloat(-10, 10);
-        //std.debug.print("randMinMaxFloat:{}\n",.{r1});
-        if (r1 > 8 or r1 < -8) {
-            std.debug.print("Greater:{}\n", .{r1});
-        }
-    }
-}

src/particles.zig

@@ -0,0 +1,203 @@
+const pr = @import("primitives.zig");
+const utils = @import("utils.zig");
+const std = @import("std");
+const rl = @import("raylib");
+
+var prng = std.rand.DefaultPrng.init(124346234556);
+const rand = prng.random();
+
+pub const Particle = struct {
+    const Self = @This();
+    position: pr.Vec = .{ .a = .{ .x = 0, .y = 0, .z = 0 } },
+    velocity: pr.Vec = .{ .a = .{ .x = 0, .y = 0, .z = 0 } },
+    acceleration: pr.Vec = .{ .a = .{ .x = 0, .y = 0, .z = 0 } },
+    lifespan: u8 = 0,
+    show: u8 = 0,
+    size: f32 = 0,
+    max_x: i32 = 0,
+    max_y: i32 = 0,
+    pub fn new(self: *Self, max_x: i32, max_y: i32) void {
+        self.max_x = max_x;
+        self.max_y = max_y;
+    }
+    pub fn update(self: *Self) void {
+        self.velocity.add(self.acceleration);
+        self.position.add(self.velocity);
+        //this is ambigous
+        //must fix!!
+        if (self.position.a.y > @as(f32, @floatFromInt(self.max_y))) {
+            self.velocity.a.y *= -0.9;
+            // self.acceleration.a.y *= -0.5;
+        }
+
+        if (self.lifespan > 0) {
+            self.lifespan -= 1;
+        } else {
+            self.show = 0;
+        }
+        self.acceleration.a.x = 0;
+        self.acceleration.a.y = 0;
+        self.acceleration.a.z = 0;
+    }
+    pub fn spawn(self: *Self, xaccel: f32, yaccel: f32) void {
+        const xrnr = utils.randMinMaxFloat(-xaccel, xaccel);
+        const yrnr = utils.randMinMaxFloat(-yaccel, yaccel);
+
+        self.size = utils.randMinMaxFloat(-2, 2);
+        self.lifespan = rand.intRangeAtMost(u8, 75, 255);
+        self.acceleration.a.x = xrnr;
+        self.acceleration.a.y = yrnr;
+        self.position.a.x = @floatFromInt(rl.getMouseX() - @divTrunc(self.max_x, 2));
+        std.debug.print("divtrunc x: {}\n,max_x:{}\n", .{ @divTrunc(self.max_x, 2), self.max_x });
+        self.position.a.y = @floatFromInt(rl.getMouseY() - @divTrunc(self.max_y, 2));
+        self.velocity.a.x = 0;
+        self.velocity.a.y = 0;
+        self.position.a.color.r = rand.intRangeAtMost(u8, 0, 30);
+        self.position.a.color.g = rand.intRangeAtMost(u8, 0, 255);
+        self.position.a.color.b = rand.intRangeAtMost(u8, 0, 255);
+        self.show = 1;
+    }
+    pub fn applyGravity(self: *Self, val: f32) void {
+        self.velocity.a.y += val;
+    }
+    pub fn applyForce(self: *Self, vec: pr.Vec) void {
+        self.acceleration.a.x += vec.a.x * 0.8;
+        self.acceleration.a.y += vec.a.y * 0.8;
+        self.acceleration.a.z = vec.a.z;
+        self.velocity.a.x *= 0.995;
+        self.velocity.a.y *= 0.995;
+    }
+};
+pub const Emitter = struct {
+    particleCount: u32 = 0,
+    particles: []Particle = undefined,
+    max_x: i32 = 0,
+    max_y: i32 = 0,
+
+    pub fn init(self: *Emitter, allocator: std.mem.Allocator, max_x: i32, max_y: i32) !void {
+        var xrnr = utils.randMinMaxFloat(-1, 1);
+        var yrnr = utils.randMinMaxFloat(-0.5, 0.5);
+
+        self.max_x = max_x;
+        self.max_y = max_y;
+        self.particles = try allocator.alloc(Particle, 500000);
+        for (self.particles) |*p| {
+            xrnr = utils.randMinMaxFloat(-2, 2);
+            yrnr = utils.randMinMaxFloat(-2, 2);
+            p.* = Particle{ .velocity = .{ .a = .{ .x = 0, .y = 0 } }, .acceleration = .{ .a = .{ .x = xrnr, .y = yrnr } } };
+            p.*.new(self.max_x, self.max_y);
+        }
+    }
+    pub fn emit(self: *Emitter, count: u32, xaccel: f32, yaccel: f32) void {
+        var i: u32 = 0;
+        for (self.particles) |*p| {
+            if (p.show == 0) {
+                i += 1;
+                p.spawn(xaccel, yaccel);
+            }
+            if (i >= count) {
+                break;
+            }
+        }
+    }
+    pub fn update(self: *Emitter, att: []Attractor, texture: rl.Texture2D, color: rl.Color) void {
+        var posx: i32 = 0;
+        var posy: i32 = 0;
+
+        var vec2: rl.Vector2 = undefined;
+
+        if (rl.isMouseButtonPressed(rl.MouseButton.mouse_button_right)) {
+            for (att) |*at| {
+                if (at.init_done != 1) {
+                    at.init(.{ .a = .{ .x = @floatFromInt(rl.getMouseX() - @divTrunc(self.max_x, 2)), .y = @floatFromInt(rl.getMouseY() - @divTrunc(self.max_y, 2)), .z = 0 } }, self.max_x, self.max_y);
+                    at.mode = 1;
+                    break;
+                }
+            }
+        }
+        if (rl.isMouseButtonPressed(rl.MouseButton.mouse_button_middle)) {
+            for (att) |*at| {
+                if (at.init_done != 1) {
+                    at.init(.{ .a = .{ .x = @floatFromInt(rl.getMouseX() - @divTrunc(self.max_x, 2)), .y = @floatFromInt(rl.getMouseY() - @divTrunc(self.max_y, 2)), .z = 0 } }, self.max_x, self.max_y);
+                    at.mode = 0;
+                    break;
+                }
+            }
+        }
+
+        for (att) |at| {
+            at.draw();
+        }
+        for (self.particles) |*p| {
+            if (p.show == 1) {
+                //p.applyGravity(2);
+                for (att) |at| {
+                    if (at.mode == 0) {
+                        p.applyForce(at.attract(p.*));
+                    } else {
+                        p.applyForce(at.repel(p.*));
+                    }
+                }
+                p.update();
+
+                if (p.position.a.x < 10000 and p.position.a.x > -10000) {
+                    posx = @intFromFloat(@as(f32, @floatFromInt(self.max_x)) / 2 + p.position.a.x);
+                }
+                if (p.position.a.y < 10000 and p.position.a.y > -10000) {
+                    posy = @intFromFloat(@as(f32, @floatFromInt(self.max_y)) / 2 + p.position.a.y);
+                }
+                //rl.drawRectangle(posx,posy,2,2,rl.Color{.r=p.position.a.color.r,.g=p.position.a.color.g,.b=p.position.a.color.b,.a=255});
+                vec2 = .{ .x = (@as(f32, @floatFromInt(self.max_x)) / 2 + p.position.a.x), .y = (@as(f32, @floatFromInt(self.max_y)) / 2 + p.position.a.y) };
+                rl.drawTextureEx(texture, vec2, 0.5, p.size, color);
+            }
+        }
+    }
+};
+pub const Attractor = struct {
+    vec: pr.Vec,
+    init_done: u8 = 0,
+    mode: u8 = 0,
+    max_x: i32 = 0,
+    max_y: i32 = 0,
+    pub fn init(self: *Attractor, vec: pr.Vec, max_x: i32, max_y: i32) void {
+        self.vec = vec;
+        self.init_done = 1;
+        self.max_x = max_x;
+        self.max_y = max_y;
+    }
+    pub fn attract(self: Attractor, particle: Particle) pr.Vec {
+        if (self.init_done == 1) {
+            const distance = self.vec.sub(particle.position);
+            var force: pr.Vec = undefined;
+            if (distance.a.x != 0 and distance.a.y != 0) {
+                force.a.x = distance.a.x / 10 * @abs(1 / distance.a.x);
+                force.a.y = distance.a.y / 10 * @abs(1 / distance.a.y);
+                force.a.z = 0;
+            }
+            return force;
+        } else {
+            return .{ .a = .{ .x = 0, .y = 0, .z = 0 } };
+        }
+    }
+    pub fn repel(self: Attractor, particle: Particle) pr.Vec {
+        if (self.init_done == 1) {
+            const distance = self.vec.sub(particle.position);
+            var force: pr.Vec = undefined;
+            if (distance.a.x != 0 and distance.a.y != 0) {
+                force.a.x = -distance.a.x / 10 * @abs(1 / distance.a.x);
+                force.a.y = -distance.a.y / 10 * @abs(1 / distance.a.y);
+                force.a.z = 0;
+            }
+            return force;
+        } else {
+            return .{ .a = .{ .x = 0, .y = 0, .z = 0 } };
+        }
+    }
+    pub fn draw(self: Attractor) void {
+        const posx: i32 = @intFromFloat(@as(f32, @floatFromInt(self.max_x)) / 2 + self.vec.a.x);
+        const posy: i32 = @intFromFloat(@as(f32, @floatFromInt(self.max_y)) / 2 + self.vec.a.y);
+        if (self.init_done == 1) {
+            rl.drawRectangle(posx, posy, 10, 10, rl.Color{ .r = 10, .g = 10, .b = 120, .a = 255 });
+        }
+    }
+};

src/utils.zig

@@ -0,0 +1,16 @@
+const std = @import("std");
+
+var prng = std.rand.DefaultPrng.init(124346234556);
+const rand = prng.random();
+
+pub fn init() void {
+    var seed: u64 = undefined;
+    try std.posix.getrandom(std.mem.asBytes(&seed));
+    prng = std.rand.DefaultPrng.init(seed);
+}
+
+pub fn randMinMaxFloat(min: f32, max: f32) f32 {
+    var r1 = rand.float(f32);
+    r1 = 2 * (r1 - 0.5); //-0.5..0.5
+    return (@abs(min) + @abs(max)) / 2 * r1;
+}