particles kinda workin

Author: Stuart-Mouse

Fire_Rescue/data/game_data.lsd

@@ -143,8 +143,7 @@ assets: {
         "building back": {
             z_index:                -1,
             position:               [ 0, 0 ],
-            render_scale_basis:     9,
-            render_scale_axis:      .Y,
+            sizing:                 [ 9, .Y ],
             texture_id:             .BUILDING_BACK,
 
             animations: {
@@ -156,12 +155,44 @@ assets: {
                 // READY:      $"IN_GAME",
                 // GAME_OVER:  $"IN_GAME",
             }
+            
+            particle_emitters: [
+                {
+                    desired_particle_count: 256,
+                    texture_id:     .FIRE,
+                    
+                    velocity:       [ [ 0, -1  ], [ 0, -1   ] ],
+                    acceleration:   [ [ 0, -0.1], [ 0, -0.1 ] ],
+                    
+                    emit_box:       [ 0, 0, 16, 9 ], // for testing
+                    emit_frequency: [ 0.1, 0.5 ],
+                    fade_in_time:   [ 0.1, 0.1 ],
+                    fade_out_time:  [ 0.1, 0.1 ],
+                    
+                    rotation:               [ 0, 6.28 ],
+                    rotation_velocity:      [ -3.14, 3.14 ],
+                    rotation_acceleration:  [ -7, 7 ],
+                    
+                    size:           [ [ 0.25, 0.25 ], [ 0.5, 0.5 ] ],
+                    size_velocity:          [ [ -0.001, -0.001 ], [ 0.001, 0.001 ] ],
+                    size_acceleration:      [ [ -0.001, -0.001 ], [ 0.001, 0.001 ] ],
+                    
+                    alpha:          [ 1, 1 ],
+                    
+                    lifetime:       [ 1, 3 ],
+                    
+                    animation: {
+                        frames: [
+                            { clip: [ 0, 0, 16, 16 ] }
+                        ]
+                    }
+                }
+            ]
         }
         "building front": {
             z_index:                1,
             position:               [ 0, 0 ],
-            render_scale_basis:     9,
-            render_scale_axis:      .Y,
+            sizing:                 [ 9, .Y ],
             texture_id:             .BUILDING_FRONT,
 
             animations: {

Fire_Rescue/source/game.jai

@@ -46,8 +46,8 @@ Game: struct {
         decorations:    [] Decoration;
     }
 
-    controller: Enumerated_Array(Controller_Keys, Input_Key);
-    
+    // misc
+    controller:         Enumerated_Array(Controller_Keys, Input_Key);
     tile_render_unit:   float;
     viewport:           Rectf;
     pending_reload:     bool;
@@ -65,17 +65,8 @@ Game: struct {
         next_jump_time:             float;
         time_of_last_mode_change:   float;
 
-        
-        // visual 
-        // foreground_particles: Slot_Array(Particle, 256);
-        // background_particles: Slot_Array(Particle, 256);
-        // Particle_Emitter smoke_emitter;
-        // Particle_Emitter fire_emitter;
-        
-        
         // frame timing info
         last_update_time:       Apollo_Time;
-        
         last_render_time:       Apollo_Time;
         render_delta_time:      float;  // delta_time used for variable-step update
 
@@ -131,7 +122,7 @@ init_game :: () {
     });
     if !ok  exit(1);
 
-    // post-processing on physics valuesk
+    // post-processing on physics values
     for *guy_templates {
         using it;
 
@@ -143,6 +134,12 @@ init_game :: () {
 
     for *textures  Simp.texture_load_from_file(it, texture_paths[it_index]);
 
+    for *decorations {
+        for *it.particle_emitters {
+            prep_particle_emitter(it);
+        }
+    }
+    
     // window resize needs to be handled after loading tile_unit_basis
     handle_window_resize_for_game();
 }
@@ -273,8 +270,7 @@ Decoration :: struct {
     z_index:            int; // negative is rendered behind player and guys, positive is in front
 
     position:           Vec2f;
-    render_scale_basis: float;
-    render_scale_axis:  Axis;
+    sizing:             Sizing_Policy;
 
     texture_id:         Texture_ID;
     animator:           Simple_Animator(Game.state.Mode);
@@ -287,6 +283,9 @@ free_decoration :: (decor: *Decoration) {
     for *decor.animations {
         free_animation(it);
     }
+    for *decor.particle_emitters {
+        free_particle_emitter(it);
+    }
 }
 
 handle_window_resize_for_game :: () {
@@ -641,7 +640,7 @@ render_decoration :: (decor: *Decoration) {
     clip          := to_Rectf(current_frame.clip);
     texture       := *textures[decor.texture_id];
 
-    render_scale  := decor.render_scale_basis / get_axis(clip.size, decor.render_scale_axis);
+    render_scale  := get_scalar(clip.size, decor.sizing);
     render_offset := current_frame.offset * render_scale;
 
     render_rect := Rectf.{
@@ -655,6 +654,10 @@ render_decoration :: (decor: *Decoration) {
         size     = render_rect.size,
         texture  = texture,
     );
+    
+    for *decor.particle_emitters {
+        do_particle_emitter(it, .{});
+    }
 }
 
 render_ambulance :: () {
@@ -801,6 +804,13 @@ start_game :: () {
     player.position = constants.stretcher_init_position;
     score = 0;
     lives = 3;
+    
+    for *decorations {
+        for *it.particle_emitters {
+            memset(it.particles.data, 0, it.particles.count * size_of(Particle));
+            it.next_emit_time = 0;
+        }
+    }
 }
 
 spawn_new_guy :: () {
@@ -837,4 +847,15 @@ get_sorted_decorations :: () -> (bg: [] *Decoration, fg: [] *Decoration) {
     bg := array_view(sorted, 0, first_fg_index);
     fg := array_view(sorted, first_fg_index);
     return bg, fg;
-}
+}
+
+
+Sizing_Policy :: struct {
+    // units:          enum { TILE; VIEWPORT; WINDOW; }; // TODO
+    target_size:    float;
+    scale_axis:     Axis;
+}
+
+get_scalar :: inline (size: Vec2f, policy: Sizing_Policy) -> float {
+    return policy.target_size / get_axis(size, policy.scale_axis);
+}

Fire_Rescue/source/main.jai

@@ -174,3 +174,4 @@ init_gon_io_data :: () {
 // // IMPORTANT NOTE: right now this also serves as the owner for 'source strings' that are referenced by the script!
 // prev_commands:          [..] struct { statement: string; result: string; }; 
 // prev_commands_index:    int;
+

Fire_Rescue/source/particles.jai

@@ -2,6 +2,10 @@
 /*
     Particles and Emitters are updated on a variable-timestep basis.
     Becuase of this, we don't really separate the update and render routines.
+
+    TODO: definitely need to set proper sizing modes based on a single axis, 
+          rather than having absolute sizing where each axis is scaled independently
+
 */
 
 
@@ -34,50 +38,52 @@ Particle :: struct {
     // maybe later add animation states so we can transition to another state on death or contact with certain elements in level
 }
 
-do_particle :: (emitter: Particle_Emitter, using particle: *Particle, delta_time: float) -> bool {
-    particle.velocity          += particle.acceleration * delta_time;
-    particle.position          += particle.velocity     * delta_time;
+do_particle :: (using particle: *Particle, emitter: Particle_Emitter, delta_time: float) -> bool {
+    velocity          += acceleration * delta_time;
+    position          += velocity     * delta_time;
+    
+    rotation_velocity += rotation_acceleration * delta_time;
+    rotation          += rotation_velocity     * delta_time;
 
-    particle.rotation_velocity += particle.rotation_acceleration * delta_time;
-    particle.rotation          += particle.rotation_velocity     * delta_time;
+    alpha_velocity    += alpha_acceleration * delta_time;
+    alpha             += alpha_velocity     * delta_time;
 
-    particle.alpha_velocity    += particle.alpha_acceleration * delta_time;
-    particle.alpha             += particle.alpha_velocity     * delta_time;
+    step_animator(*animator, emitter.animation, Game.render_delta_time);
 
-    step_animator(*animator, animation, Game.render_delta_time);
+    offset := Vec2f.{ 0, 0 }; // TODO: make parameter
 
-    clip            := rect_to_frect(animation.frames[animator.current].clip);
-    render_size     := size * render_unit;
-    render_position := ((position + offset) * tile_render_unit) - (render_size / 2);
+    current_frame   := get_current_frame(animator, emitter.animation);
+    clip            := rect_to_frect(current_frame.clip);
+    render_size     := size * Game.tile_render_unit;
+    render_position := ((position + offset) * Game.tile_render_unit) - (render_size / 2);
 
-    lifetime_lerp   := clamp((Game.current_time - spawn_time) / lifetime, 0, 1);
+    lifetime_lerp   := clamp((Game.time_since_start - spawn_time) / lifetime, 0, 1);
 
     // fade-in and fade-out particle
-    render_alpha = alpha;
+    render_alpha := alpha;
     if lifetime_lerp < fade_in_time {
         render_alpha *= lifetime_lerp / fade_in_time;
     } else if lifetime_lerp > 1 - fade_out_time {
         render_alpha *= ((1 - lifetime_lerp) / fade_out_time);
     }
 
+    texture := *Game.textures[emitter.texture_id];
+    
     render_draw_quad(
         texture  = texture,
         position = render_position,
         size     = render_size,
         clip     = *clip,
-        flip     = animation.frames[animator.current].flip,
-        palette  = palette,
+        flip     = current_frame.flip,
+        // palette  = palette,
         color    = .{ 1, 1, 1, render_alpha },
         rotate   = rotation
     );
 
-    return spawn_time + lifetime > Game.current_time;
+    return spawn_time + lifetime > Game.time_since_start;
 }
 
 Particle_Emitter :: struct {
-    my_update_particle: type_of(update_particle);
-    my_render_particle: type_of(render_particle);
-    
     // user can set desired_particle_count in LSD, 
     // then we use that to init the particles array
     desired_particle_count: int; 
@@ -97,7 +103,7 @@ Particle_Emitter :: struct {
     rotation_velocity:      Range(float);
     rotation_acceleration:  Range(float);
 
-    alpha:                  Range(float);
+    alpha:                  Range(float) = .{ 1, 1 };
     alpha_velocity:         Range(float);
     alpha_acceleration:     Range(float);
 
@@ -117,19 +123,32 @@ Particle_Emitter :: struct {
     }
 }
 
-init_particle_emitter :: (emitter: Particle_Emitter) {
-    emitter.particles = NewArray(particle_count, desired_particle_count);
+free_particle_emitter :: (using emitter: *Particle_Emitter) {
+    array_free(emitter.particles);
+}
+
+prep_particle_emitter :: (using emitter: *Particle_Emitter) {
+    particles = NewArray(desired_particle_count, Particle);
 
-    if emit_frequency[0] <= 0 {
-        log("Warning: emit_frquency values cannot be zero! Defaulting to 1.");
-        emit_frequency[0] = 1;
+    check_emit_frequency :: inline (value: *float, name: string) {
+        if value.* <= 0 {
+            log("Warning: % must be greater than zero! Defaulting to 1.", name);
+            value.* = 1;
+        }
     }
-    if emit_frequency[1] <= 0 {
-        log("Warning: emit_frquency values cannot be zero! Defaulting to 1.");
-        emit_frequency[1] = 1;
+    check_emit_frequency(*emit_frequency.min,  "emit_frequency.min");
+    check_emit_frequency(*emit_frequency.max,  "emit_frequency.max");
+        
+    check_fade_time :: inline (value: *float, name: string) {
+        if value.* < 0 {
+            log("Warning: % must be between 0 and 1! Clamping value.", name);
+            value.* = clamp(value.*, 0, 1);
+        }
     }
-    
-    // check fade times
+    check_fade_time(*fade_in_time.min,  "fade_in_time.min");
+    check_fade_time(*fade_in_time.max,  "fade_in_time.max");
+    check_fade_time(*fade_out_time.min, "fade_out_time.min");
+    check_fade_time(*fade_out_time.max, "fade_out_time.max");
 }
 
 get_first_empty_particle_slot :: (emitter: *Particle_Emitter) -> *Particle {
@@ -138,10 +157,10 @@ get_first_empty_particle_slot :: (emitter: *Particle_Emitter) -> *Particle {
 }
 
 do_particle_emitter :: (using emitter: *Particle_Emitter, offset: Vector2) {
-    while Game.current_time > next_emit_time {
+    while Game.time_since_start > next_emit_time {
         p := get_first_empty_particle_slot(emitter);
         if !p {
-            next_emit_time = Game.current_time + random_get_within_range(emit_frequency);
+            next_emit_time = Game.time_since_start + random_get_within_range(emit_frequency);
             break;
         }
 
@@ -160,6 +179,9 @@ do_particle_emitter :: (using emitter: *Particle_Emitter, offset: Vector2) {
             alpha_acceleration    = random_get_within_range(alpha_acceleration),
             lifetime              = random_get_within_range(lifetime),
 
+            fade_in\_time         = random_get_within_range(fade_in\_time),
+            fade_out_time         = random_get_within_range(fade_out_time),
+            
             spawn_time            = next_emit_time,
             active                = true,
         };
@@ -168,13 +190,44 @@ do_particle_emitter :: (using emitter: *Particle_Emitter, offset: Vector2) {
     }
 
     for *emitter.particles {
-        if !do_particle(emitter, it) {
+        if !it.active  continue;
+        if !do_particle(it, emitter, Game.render_delta_time) {
             it.active = false;
         }
     }
 }
 
 
+// manual particle emitting procedures
+
+// emit particles using the particle emitter's properties to initialize
+// TODO: create a version that allows user to manually override particular initializer properties
+//       this will require either making some separate Particle_Initializer struct or having a lot of optional parameters
+emit_particles :: (using emitter: *Particle_Emitter, count: int, offset: Vector2) {
+    for 0..count-1 {
+        p := get_first_empty_particle_slot(emitter);
+        if !p  return;
+        
+        p.* = Particle.{
+            position              = offset + emit_box.position + random_get_within_range(Vector2.{}, emit_box.size),
+            velocity              = random_get_within_range(velocity),
+            acceleration          = random_get_within_range(acceleration),
+            size                  = random_get_within_range(size),
+            size_velocity         = random_get_within_range(size_velocity),
+            size_acceleration     = random_get_within_range(size_acceleration),
+            rotation              = random_get_within_range(rotation),
+            rotation_velocity     = random_get_within_range(rotation_velocity),
+            rotation_acceleration = random_get_within_range(rotation_acceleration),
+            alpha                 = random_get_within_range(alpha),
+            alpha_velocity        = random_get_within_range(alpha_velocity),
+            alpha_acceleration    = random_get_within_range(alpha_acceleration),
+            lifetime              = random_get_within_range(lifetime),
+            
+            spawn_time            = Game.time_since_start,
+            active                = true,
+        };
+    }
+}
 
 
 
@@ -183,7 +236,7 @@ do_particle_emitter :: (using emitter: *Particle_Emitter, offset: Vector2) {
 // TODO: move to another file?
 Range :: struct(T: Type) { min, max: T; }
 
-random_get_within_range :: (using range: Range(T)) -> T {
+random_get_within_range :: (using range: Range($T)) -> T {
     return random_get_within_range(range.min, range.max);
 }