Rects as App state (#2)

Author: LukasBombach

src/app.rs

@@ -5,12 +5,63 @@ use winit::event::WindowEvent;
 use winit::event_loop::ActiveEventLoop;
 use winit::window::{Window, WindowId};
 
+use crate::gpu;
 use crate::gpu::Gpu;
 
-#[derive(Default)]
+#[derive(Copy, Clone, Debug)]
+struct Rect {
+    pos: [u32; 2],
+    size: [u32; 2],
+}
+
+impl Rect {
+    pub fn new(x: u32, y: u32, w: u32, h: u32) -> Self {
+        Self {
+            pos: [x, y],
+            size: [w, h],
+        }
+    }
+
+    pub fn to_instance(&self) -> gpu::Instance {
+        gpu::Instance::new(
+            self.pos[0] as f32,
+            self.pos[1] as f32,
+            self.size[0] as f32,
+            self.size[1] as f32,
+        )
+    }
+}
+
 pub struct App<'window> {
     window: Option<Arc<Window>>,
     gpu: Option<Gpu<'window>>,
+    rects: Vec<Rect>,
+}
+
+impl App<'_> {
+    pub fn new() -> Self {
+        Self {
+            window: None,
+            gpu: None,
+            rects: Vec::new(),
+        }
+    }
+
+    pub fn add_rect(&mut self, x: u32, y: u32, w: u32, h: u32) {
+        self.rects.push(Rect::new(x, y, w, h));
+        self.sync_gpu_instance_buffer();
+    }
+
+    fn rects_to_instances(&self) -> Vec<gpu::Instance> {
+        self.rects.iter().map(|r| r.to_instance()).collect()
+    }
+
+    fn sync_gpu_instance_buffer(&mut self) {
+        let instances = self.rects_to_instances();
+        if let Some(gpu) = self.gpu.as_mut() {
+            gpu.update_instance_buffer(&instances);
+        }
+    }
 }
 
 impl<'window> ApplicationHandler for App<'window> {
@@ -23,7 +74,7 @@ impl<'window> ApplicationHandler for App<'window> {
                     .expect("create window err."),
             );
             self.window = Some(window.clone());
-            let gpu = Gpu::new(window.clone());
+            let gpu = Gpu::new(window.clone(), self.rects_to_instances());
             self.gpu = Some(gpu);
         }
     }

src/gpu.rs

@@ -11,13 +11,13 @@ use winit::window::Window;
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Pod, Zeroable)]
-struct Instance {
+pub struct Instance {
     pos: [f32; 2],
     size: [f32; 2],
 }
 
 impl Instance {
-    fn new(x: f32, y: f32, width: f32, height: f32) -> Self {
+    pub fn new(x: f32, y: f32, width: f32, height: f32) -> Self {
         Self {
             pos: [x, y],
             size: [width, height],
@@ -40,11 +40,11 @@ pub struct Gpu<'window> {
 }
 
 impl<'window> Gpu<'window> {
-    pub fn new(window: Arc<Window>) -> Gpu<'window> {
-        pollster::block_on(Gpu::new_async(window))
+    pub fn new(window: Arc<Window>, instances: Vec<Instance>) -> Gpu<'window> {
+        pollster::block_on(Gpu::new_async(window, instances))
     }
 
-    pub async fn new_async(window: Arc<Window>) -> Gpu<'window> {
+    pub async fn new_async(window: Arc<Window>, instances: Vec<Instance>) -> Gpu<'window> {
         /*
          * window
          */
@@ -100,16 +100,6 @@ impl<'window> Gpu<'window> {
             range: 0..push_const_size,
         };
 
-        /*
-         * rects
-         */
-
-        let rects: Vec<Instance> = vec![
-            Instance::new(100.0, 100.0, 200.0, 200.0),
-            Instance::new(400.0, 100.0, 200.0, 200.0),
-            Instance::new(700.0, 100.0, 200.0, 200.0),
-        ];
-
         /*
          * vertices
          */
@@ -142,10 +132,10 @@ impl<'window> Gpu<'window> {
 
         let instance_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
             label: Some("Instance Buffer"),
-            contents: cast_slice(&rects),
+            contents: cast_slice(&instances),
             usage: wgpu::BufferUsages::VERTEX,
         });
-        let instance_count = rects.len() as u32;
+        let instance_count = instances.len() as u32;
 
         /*
          * shader
@@ -290,4 +280,15 @@ impl<'window> Gpu<'window> {
         self.queue.submit(Some(encoder.finish()));
         frame.present();
     }
+
+    pub fn update_instance_buffer(&mut self, instances: &[Instance]) {
+        self.instance_buffer = self
+            .device
+            .create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                label: Some("Instance Buffer"),
+                contents: cast_slice(instances),
+                usage: wgpu::BufferUsages::VERTEX,
+            });
+        self.instance_count = instances.len() as u32;
+    }
 }

src/main.rs

@@ -6,8 +6,12 @@ mod app;
 mod gpu;
 
 fn main() -> Result<(), EventLoopError> {
+    let mut app = App::new();
+    app.add_rect(100, 100, 250, 250);
+    app.add_rect(200, 150, 250, 250);
+    app.add_rect(300, 200, 250, 250);
+
     let event_loop = EventLoop::new().unwrap();
     event_loop.set_control_flow(ControlFlow::Poll);
-    let mut app = App::default();
     event_loop.run_app(&mut app)
 }