203 lines
7.5 KiB
Zig
203 lines
7.5 KiB
Zig
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));
|
|
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 });
|
|
}
|
|
}
|
|
};
|