251 lines
7.4 KiB
Zig
251 lines
7.4 KiB
Zig
const std = @import("std");
|
|
const rl = @import("raylib");
|
|
const rg = @import("raygui");
|
|
const pr = @import("primitives.zig");
|
|
const allocator = std.heap.page_allocator;
|
|
|
|
var prng = std.rand.DefaultPrng.init(124346556);
|
|
|
|
|
|
const rand = prng.random();
|
|
|
|
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;
|
|
}
|
|
|
|
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});
|
|
}
|
|
}
|
|
}
|
|
const screenWidth = 1200;
|
|
const screenHeight = 800;
|
|
|
|
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,
|
|
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.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.velocity.a.x += vec.a.x * 0.5;
|
|
self.velocity.a.y += vec.a.y * 0.5;
|
|
self.velocity.a.z += vec.a.z;
|
|
}
|
|
};
|
|
|
|
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(0,2);
|
|
yrnr = randMinMaxFloat(0,2);
|
|
p.* = Particle{.velocity = .{.a = .{.x = 1,.y = -3}},.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,texture : rl.Texture2D) void
|
|
{
|
|
var posx : i32 = 0;
|
|
var posy : i32 = 0;
|
|
const att : Attractor = .{.vec = .{.a=.{.x=10,.y=10,.z=10}}};
|
|
const att2 : Attractor = .{.vec = .{.a=.{.x=-100,.y=-100,.z=0}}};
|
|
|
|
att.draw();
|
|
att2.draw();
|
|
for (self.particles) |*p| {
|
|
if(p.show == 1)
|
|
{
|
|
|
|
p.applyGravity(0);
|
|
p.applyForce(att.attract(p.*));
|
|
p.applyForce(att2.attract(p.*));
|
|
p.update();
|
|
|
|
posx = @intFromFloat(screenWidth / 2 + p.position.a.x);
|
|
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});
|
|
rl.drawTexture(texture,posx,posy,rl.Color.white);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
const Attractor = struct
|
|
{
|
|
vec : pr.Vec,
|
|
pub fn attract(self:Attractor,particle : Particle) pr.Vec
|
|
{
|
|
|
|
var vec = self.vec.sub(particle.position);
|
|
if( vec.a.x != 0 and vec.a.y != 0)
|
|
{
|
|
vec.a.x = vec.a.x/20;
|
|
vec.a.y = vec.a.y/20;
|
|
}
|
|
return vec;
|
|
}
|
|
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);
|
|
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));
|
|
}
|
|
fn rectangle(x : u16,y : u16,width : u16,height : u16) rl.Rectangle
|
|
{
|
|
return rl.Rectangle{ .x = @as(f32, @floatFromInt(x)), .y = @as(f32, @floatFromInt(y)), .width = @as(f32, @floatFromInt(width)), .height = @as(f32, @floatFromInt(height)) };
|
|
}
|
|
|
|
pub fn main() anyerror!void {
|
|
|
|
const rect3 = rectangle(10,150,600,10);
|
|
const rect4 = rectangle(10,170,600,10);
|
|
const rect5 = rectangle(10,190,600,10);
|
|
|
|
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 emitter = Emitter{};
|
|
try emitter.init();
|
|
|
|
//const img : rl.Texture = rl.loadTexture("img.png");
|
|
rl.initWindow(screenWidth, screenHeight, "raylib-zig [core] example - basic window");
|
|
defer rl.closeWindow(); // Close window and OpenGL context
|
|
|
|
var texture : rl.Texture2D = undefined;
|
|
const image : rl.Image = rl.loadImage("resources/blut.png");
|
|
if(image.width > 0)
|
|
{
|
|
texture = rl.loadTextureFromImage(image);
|
|
}
|
|
else
|
|
{
|
|
std.debug.print("error opening resource",.{});
|
|
std.posix.exit(1);
|
|
}
|
|
rl.unloadImage(image);
|
|
|
|
|
|
|
|
rl.setTargetFPS(60); // Set our game to run at 60 frames-per-second
|
|
|
|
while (!rl.windowShouldClose()) { // Detect window close button or ESC key
|
|
rl.beginDrawing();
|
|
defer rl.endDrawing();
|
|
|
|
rl.clearBackground(rl.Color{.r=181,
|
|
.g =177,
|
|
.b =154,
|
|
.a = 255,
|
|
});
|
|
|
|
_ = rg.guiSlider(rect3,"0","500",&value,ItoF(0),ItoF(500));
|
|
_ = rg.guiSlider(rect4,"-3","3",&value2,ItoF(-10),ItoF(10));
|
|
_ = rg.guiSlider(rect5,"-3","3",&value3,-10,10);
|
|
|
|
if(rl.isMouseButtonDown(rl.MouseButton.mouse_button_left))
|
|
{
|
|
emitter.emit(@as(u32,@intFromFloat(value)),value2,value3);
|
|
}
|
|
|
|
rl.beginBlendMode(rl.BlendMode.blend_additive);
|
|
emitter.update(texture);
|
|
rl.endBlendMode();
|
|
}
|
|
}
|
|
|
|
test "simple test" {
|
|
var list = std.ArrayList(i32).init(std.testing.allocator);
|
|
defer list.deinit(); // try commenting this out and see if zig detects the memory leak!
|
|
try list.append(42);
|
|
try std.testing.expectEqual(@as(i32, 42), list.pop());
|
|
}
|