Add sprite animation using texture array

Texture arrays are limited 128 on mid 2014 macbook pro running mac os catalina. This means sprite animations are limited to 128 which might not be enough for complex characters. This feature may have to be re-implemented using a texture atlas in the future due to this limitation.

Author: rishflab

assets/adventurer_idle.png

@@ -1,13 +1,15 @@
 #version 450
 
 layout(location = 0) in vec2 v_TexCoord;
+layout(location = 1) flat in uint v_tex_id;
+
 layout(location = 0) out vec4 o_Target;
 
-layout(set = 1, binding = 0) uniform texture2D t_Color;
+layout(set = 1, binding = 0) uniform texture2D t_Color[128];
 layout(set = 1, binding = 1) uniform sampler s_Color;
 
 void main() {
-    vec4 texel = texture(sampler2D(t_Color, s_Color), v_TexCoord);
+    vec4 texel = texture(sampler2D(t_Color[v_tex_id], s_Color), v_TexCoord);
     if(texel.a < 0.5) {
         discard;
     }

assets/adventurer_walk1.png

@@ -6,8 +6,11 @@ layout(location=2) in vec4 model_matrix_0;
 layout(location=3) in vec4 model_matrix_1;
 layout(location=4) in vec4 model_matrix_2;
 layout(location=5) in vec4 model_matrix_3;
+layout(location=6) in uint frame_id;
 
 layout(location=0) out vec2 v_tex_coords;
+layout(location=1) flat out uint v_tex_id;
+
 
 layout(set = 0, binding = 0) uniform Uniforms {
     mat4 ortho;
@@ -24,6 +27,7 @@ void main() {
     );
 
     v_tex_coords = a_tex_coords;
+    v_tex_id = frame_id;
 
     vec4 centre = vec4(vec3(0.0), 1.0);
 

assets/adventurer_walk2.png

@@ -44,7 +44,9 @@ impl App {
             .await
             .unwrap();
 
-        let optional_features = wgpu::Features::empty();
+        let optional_features = wgpu::Features::empty()
+            | wgpu::Features::SAMPLED_TEXTURE_BINDING_ARRAY
+            | wgpu::Features::SAMPLED_TEXTURE_ARRAY_DYNAMIC_INDEXING;
         let required_features = wgpu::Features::empty();
         let adapter_features = adapter.features();
         assert!(
@@ -53,15 +55,18 @@ impl App {
             required_features - adapter_features
         );
 
-        let needed_limits = wgpu::Limits::default();
+        let limits = wgpu::Limits {
+            max_sampled_textures_per_shader_stage: 1024,
+            ..Default::default()
+        };
 
         let trace_dir = std::env::var("WGPU_TRACE");
         let (device, queue) = adapter
             .request_device(
                 &wgpu::DeviceDescriptor {
                     label: wgpu::Label::None,
                     features: (optional_features & adapter_features) | required_features,
-                    limits: needed_limits,
+                    limits,
                 },
                 trace_dir.ok().as_ref().map(std::path::Path::new),
             )

shaders/shader.frag

@@ -1,3 +1,5 @@
+#![allow(clippy::single_match)]
+#![feature(or_patterns)]
 extern crate erlking;
 
 use cgmath::{Deg, Quaternion, Rotation3, Vector3};
@@ -7,7 +9,7 @@ use erlking::{
 };
 use glam::Vec3;
 use hecs::World;
-use std::time::Duration;
+use std::time::{Duration, Instant};
 use winit::{
     event::{ElementState, VirtualKeyCode},
     event_loop::EventLoop,
@@ -16,6 +18,32 @@ use winit::{
 #[derive(Clone, Copy)]
 struct MoveSpeed(f32);
 
+enum PlayerState {
+    Idle,
+    Walk(Instant),
+}
+
+impl PlayerState {
+    pub fn animation_state(&self, now: Instant) -> u32 {
+        match self {
+            Self::Idle => 0,
+            Self::Walk(start) => {
+                let animation = vec![(2, 0.2), (1, 0.0)];
+                let dt = now - *start;
+                let dt = dt.as_secs_f32() % 0.4;
+                let mut frame = 0;
+                for (f, time) in animation {
+                    if dt > time {
+                        frame = f;
+                        break;
+                    }
+                }
+                frame
+            }
+        }
+    }
+}
+
 fn main() {
     let event_loop = EventLoop::new();
     let app = futures::executor::block_on(App::new("parallax-demo", &event_loop));
@@ -31,7 +59,11 @@ fn main() {
         )),
         Scale(1),
         KeyboardInput(None),
-        Sprite("player".to_string()),
+        Sprite {
+            id: "player".to_string(),
+            frame_id: 0,
+        },
+        PlayerState::Idle,
         movespeed,
     );
 
@@ -55,7 +87,10 @@ fn main() {
             Deg(0.0),
         )),
         Scale(1),
-        Sprite("apple".to_string()),
+        Sprite {
+            id: "apple".to_string(),
+            frame_id: 0,
+        },
     );
 
     let ashberry = (
@@ -65,7 +100,10 @@ fn main() {
             Deg(0.0),
         )),
         Scale(1),
-        Sprite("ashberry".to_string()),
+        Sprite {
+            id: "ashberry".to_string(),
+            frame_id: 0,
+        },
     );
 
     let baobab = (
@@ -75,7 +113,10 @@ fn main() {
             Deg(0.0),
         )),
         Scale(1),
-        Sprite("baobab".to_string()),
+        Sprite {
+            id: "baobab".to_string(),
+            frame_id: 0,
+        },
     );
 
     let beech = (
@@ -85,8 +126,12 @@ fn main() {
             Deg(0.0),
         )),
         Scale(1),
-        Sprite("beech".to_string()),
+        Sprite {
+            id: "beech".to_string(),
+            frame_id: 0,
+        },
     );
+
     parallax_demo.spawn_entity(player);
     parallax_demo.spawn_entity(apple);
     parallax_demo.spawn_entity(ashberry);
@@ -95,14 +140,16 @@ fn main() {
     parallax_demo.spawn_entity(camera);
 
     parallax_demo.add_system(&move_player);
+    parallax_demo.add_system(&move_camera);
+    parallax_demo.add_system(&update_animation_state);
 
     app.run(event_loop, parallax_demo);
 }
 
-fn move_player(world: &World, dt: Duration) {
-    let mut q = world.query::<(&KeyboardInput, &mut Position, &MoveSpeed)>();
+fn move_player(world: &World, dt: Duration, instant: Instant) {
+    let mut q = world.query::<(&KeyboardInput, &mut Position, &MoveSpeed, &mut PlayerState)>();
 
-    for (_, (key, pos, speed)) in q.iter() {
+    for (_, (key, pos, speed, state)) in q.iter() {
         if let Some(input) = key.0 {
             let dx = Vector3::new(speed.0 * dt.as_secs_f32(), 0.0, 0.0);
             match input {
@@ -111,19 +158,32 @@ fn move_player(world: &World, dt: Duration) {
                     virtual_keycode: Some(VirtualKeyCode::Left),
                     ..
                 } => {
+                    match state {
+                        PlayerState::Idle => *state = PlayerState::Walk(instant),
+                        _ => (),
+                    }
                     pos.0 -= dx;
                 }
                 winit::event::KeyboardInput {
                     state: ElementState::Pressed,
                     virtual_keycode: Some(VirtualKeyCode::Right),
                     ..
                 } => {
+                    match state {
+                        PlayerState::Idle => *state = PlayerState::Walk(instant),
+                        _ => (),
+                    }
                     pos.0 += dx;
                 }
-                _ => (),
+                _ => *state = PlayerState::Idle,
             }
+        } else {
+            *state = PlayerState::Idle;
         }
     }
+}
+
+fn move_camera(world: &World, dt: Duration, _instant: Instant) {
     let mut q = world.query::<(
         &ActiveCamera,
         &mut ParallaxCamera,
@@ -153,3 +213,11 @@ fn move_player(world: &World, dt: Duration) {
         }
     }
 }
+
+fn update_animation_state(world: &World, _dt: Duration, instant: Instant) {
+    let mut q = world.query::<(&PlayerState, &mut Sprite)>();
+
+    for (_, (state, sprite)) in q.iter() {
+        sprite.frame_id = state.animation_state(instant);
+    }
+}

shaders/shader.vert

@@ -40,12 +40,14 @@ pub struct Instance {
     pub position: cgmath::Vector3<f32>,
     pub rotation: cgmath::Quaternion<f32>,
     pub scale: f32,
+    pub frame_id: u32,
 }
 
 #[repr(C)]
 #[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
 pub struct InstanceRaw {
     model: [[f32; 4]; 4],
+    frame_id: u32,
 }
 
 impl From<Instance> for InstanceRaw {
@@ -55,6 +57,7 @@ impl From<Instance> for InstanceRaw {
                 * cgmath::Matrix4::from(from.rotation)
                 * cgmath::Matrix4::from_scale(from.scale))
             .into(),
+            frame_id: from.frame_id,
         }
     }
 }
@@ -86,6 +89,11 @@ impl InstanceRaw {
                     shader_location: 5,
                     format: wgpu::VertexFormat::Float4,
                 },
+                wgpu::VertexAttribute {
+                    offset: mem::size_of::<[f32; 16]>() as wgpu::BufferAddress,
+                    shader_location: 6,
+                    format: wgpu::VertexFormat::Uint,
+                },
             ],
         }
     }

src/app.rs

@@ -8,10 +8,13 @@ use crate::{
 };
 use cgmath::{Quaternion, Vector3};
 use hecs::{DynamicBundle, Entity, World};
-use std::{collections::HashMap, time::Duration};
+use std::{
+    collections::HashMap,
+    time::{Duration, Instant},
+};
 use winit::event::WindowEvent;
 
-mod app;
+pub mod app;
 pub mod camera;
 mod gpu_primitives;
 mod renderer;
@@ -25,13 +28,16 @@ pub use app::App;
 pub struct Position(pub Vector3<f32>);
 pub struct Rotation(pub Quaternion<f32>);
 pub struct Scale(pub u8);
-pub struct Sprite(pub String);
+pub struct Sprite {
+    pub id: String,
+    pub frame_id: u32,
+}
 pub struct KeyboardInput(pub Option<winit::event::KeyboardInput>);
 
 pub struct Game<'a> {
     world: World,
     timer: Timer,
-    systems: Vec<&'a dyn Fn(&World, Duration)>,
+    systems: Vec<&'a dyn Fn(&World, Duration, Instant)>,
 }
 
 impl<'a> Game<'a> {
@@ -45,35 +51,36 @@ impl<'a> Game<'a> {
     fn run(&mut self) -> Scene {
         self.timer.tick();
         for system in self.systems.iter() {
-            system(&self.world, self.timer.elapsed())
+            system(&self.world, self.timer.elapsed(), self.timer.now())
         }
         self.build_scene()
     }
     pub fn spawn_entity(&mut self, components: impl DynamicBundle) -> Entity {
         self.world.spawn(components)
     }
-    pub fn add_system(&mut self, system: &'a dyn Fn(&World, Duration)) {
+    pub fn add_system(&mut self, system: &'a dyn Fn(&World, Duration, Instant)) {
         self.systems.push(system)
     }
     fn build_scene(&mut self) -> Scene {
         let mut sprites: HashMap<String, Vec<InstanceRaw>> = HashMap::default();
 
-        for (_, (pos, rot, scale, sprite_id)) in
-            &mut self
-                .world
-                .query::<(&Position, &Rotation, &Scale, &Sprite)>()
+        for (_, (pos, rot, scale, sprite)) in &mut self
+            .world
+            .query::<(&Position, &Rotation, &Scale, &Sprite)>()
         {
             let instance_raw = InstanceRaw::from(Instance {
                 position: pos.0,
                 rotation: rot.0,
                 scale: scale.0 as f32,
+                frame_id: sprite.frame_id,
             });
-            if let Some(instances) = sprites.get(&sprite_id.0) {
+            if let Some(instances) = sprites.get(&sprite.id) {
+                // TODO: try and remove these clones
                 let mut new = instances.clone();
                 new.push(instance_raw);
-                sprites.insert(sprite_id.0.clone(), new);
+                sprites.insert(sprite.id.clone(), new);
             } else {
-                sprites.insert(sprite_id.0.clone(), vec![instance_raw]);
+                sprites.insert(sprite.id.clone(), vec![instance_raw]);
             }
         }