First scene refactor working

src/game/main_scene.rs

@@ -1,5 +1,8 @@
+use crate::core::input::InputState;
+use crate::core::render::pipelines::triangle_pipeline::shaders::vs;
+use crate::core::render::render_context::RenderContext;
 use crate::core::scene::Scene;
-use crate::render::pipelines::triangle_pipeline::shaders::vs;
+use crate::core::timer::Timer;
 use glam::{Mat3, Mat4, Vec3};
 use std::error::Error;
 use std::sync::Arc;
@@ -10,11 +13,13 @@ use vulkano::descriptor_set::{DescriptorSet, WriteDescriptorSet};
 use vulkano::memory::allocator::{AllocationCreateInfo, MemoryTypeFilter, StandardMemoryAllocator};
 use vulkano::pipeline::{GraphicsPipeline, Pipeline, PipelineBindPoint};
 use vulkano_util::renderer::VulkanoWindowRenderer;
+use winit::event::ElementState;
+use winit::keyboard::{KeyCode, PhysicalKey};
 
-use crate::render::pipelines::triangle_pipeline::create_triangle_pipeline;
-use crate::render::vertex::Vertex2D;
+use crate::core::render::pipelines::triangle_pipeline::create_triangle_pipeline;
+use crate::core::render::vertex::Vertex2D;
 
-use super::vulkan_context::VulkanContext;
+use crate::core::render::vulkan_context::VulkanContext;
 
 const VERTICES: [Vertex2D; 12] = [
     // Triangle en haut à gauche
@@ -74,8 +79,8 @@ const VERTICES: [Vertex2D; 12] = [
 pub struct MainSceneState {
     pipeline: Arc<GraphicsPipeline>,
     vertex_buffer: Subbuffer<[Vertex2D]>,
-
-    rotation_start: Instant,
+    uniform_buffer: Subbuffer<vs::MVPData>,
+    rotation: f32,
 }
 
 #[derive(Default)]
@@ -84,103 +89,101 @@ pub struct MainScene {
 }
 
 impl Scene for MainScene {
-    fn load(&mut self, app: &mut App) {
-        let pipeline = create_triangle_pipeline(
-            app.vulkan_context.vulkano_context().device(),
-            app.vulkano_windows.swapchain_format(),
-        )?;
-        let vertex_buffer = Vertex2D::create_buffer(
-            Vec::from_iter(VERTICES),
-            vulkano_context.vulkano_context().memory_allocator(),
-        )?;
+    fn loaded(&self) -> bool {
+        self.state.is_some()
+    }
+
+    fn load(&mut self, render_context: &RenderContext) {
+        let pipeline =
+            create_triangle_pipeline(render_context.device(), render_context.swapchain_format())
+                .unwrap();
+        let vertex_buffer =
+            Vertex2D::create_buffer(Vec::from_iter(VERTICES), render_context.memory_allocator())
+                .unwrap();
+
+        let uniform_buffer = MainScene::get_uniform_buffer(
+            0.0,
+            render_context.memory_allocator(),
+            render_context.aspect_ratio(),
+        );
 
         self.state = Some(MainSceneState {
             pipeline,
             vertex_buffer,
-            rotation_start: Instant::now(),
+            uniform_buffer,
+            rotation: 0.0,
         })
     }
 
-    fn update(&mut self, app: &mut App) {
-        todo!()
+    fn update(&mut self, render_context: &RenderContext, input_state: &InputState, timer: &Timer) {
+        let state = self.state.as_mut().unwrap();
+        let delta_rotation = if input_state.get_key_state(PhysicalKey::Code(KeyCode::KeyA))
+            == &ElementState::Pressed
+        {
+            timer.delta_time() * 5.0
+        } else if input_state.get_key_state(PhysicalKey::Code(KeyCode::KeyD))
+            == &ElementState::Pressed
+        {
+            timer.delta_time() * -5.0
+        } else {
+            timer.delta_time() * 0.0
+        };
+        state.rotation += delta_rotation;
+        state.uniform_buffer = MainScene::get_uniform_buffer(
+            state.rotation,
+            render_context.memory_allocator(),
+            render_context.aspect_ratio(),
+        );
     }
 
-    fn render(&self) {
-        todo!()
-    }
-
-    fn unload(&mut self) {
-        todo!()
-    }
-}
-
-impl MainScene {
-    pub fn load(
-        vulkano_context: &VulkanContext,
-        vulkano_window_renderer: &VulkanoWindowRenderer,
-    ) -> Result<Self, Box<dyn Error>> {
-        let pipeline = create_triangle_pipeline(
-            vulkano_context.vulkano_context().device(),
-            vulkano_window_renderer.swapchain_format(),
-        )?;
-        let vertex_buffer = Vertex2D::create_buffer(
-            Vec::from_iter(VERTICES),
-            vulkano_context.vulkano_context().memory_allocator(),
-        )?;
-
-        Ok(Scene {
-            pipeline,
-            vertex_buffer,
-            rotation_start: Instant::now(),
-        })
-    }
-
-    pub fn render(
+    fn render(
         &self,
-        vulkan_context: &VulkanContext,
-        vulkano_window_renderer: &VulkanoWindowRenderer,
+        render_context: &RenderContext,
         builder: &mut AutoCommandBufferBuilder<PrimaryAutoCommandBuffer>,
-    ) -> Result<(), Box<dyn Error>> {
-        let vertex_count = self.vertex_buffer.len() as u32;
+    ) {
+        let vertex_count = self.state.as_ref().unwrap().vertex_buffer.len() as u32;
         let instance_count = vertex_count / 3;
 
-        let uniform_buffer = self.get_uniform_buffer(
-            vulkan_context.vulkano_context().memory_allocator(),
-            vulkano_window_renderer.aspect_ratio(),
-        );
-        let layout = &self.pipeline.layout().set_layouts()[0];
+        let layout = &self.state.as_ref().unwrap().pipeline.layout().set_layouts()[0];
         let descriptor_set = DescriptorSet::new(
-            vulkan_context.descriptor_set_allocator().clone(),
+            render_context.descriptor_set_allocator().clone(),
             layout.clone(),
-            [WriteDescriptorSet::buffer(0, uniform_buffer)],
+            [WriteDescriptorSet::buffer(
+                0,
+                self.state.as_ref().unwrap().uniform_buffer.clone(),
+            )],
             [],
         )
         .unwrap();
 
         unsafe {
             builder
-                .bind_pipeline_graphics(self.pipeline.clone())?
+                .bind_pipeline_graphics(self.state.as_ref().unwrap().pipeline.clone())
+                .unwrap()
                 .bind_descriptor_sets(
                     PipelineBindPoint::Graphics,
-                    self.pipeline.layout().clone(),
+                    self.state.as_ref().unwrap().pipeline.layout().clone(),
                     0,
                     descriptor_set,
-                )?
-                .bind_vertex_buffers(0, self.vertex_buffer.clone())?
-                .draw(vertex_count, instance_count, 0, 0)?;
+                )
+                .unwrap()
+                .bind_vertex_buffers(0, self.state.as_ref().unwrap().vertex_buffer.clone())
+                .unwrap()
+                .draw(vertex_count, instance_count, 0, 0)
+                .unwrap();
         }
-
-        Ok(())
     }
 
+    fn unload(&mut self) {}
+}
+
+impl MainScene {
     fn get_uniform_buffer(
-        &self,
+        rotation: f32,
         memory_allocator: &Arc<StandardMemoryAllocator>,
         aspect_ratio: f32,
     ) -> Subbuffer<vs::MVPData> {
-        let elapsed = self.rotation_start.elapsed();
-        let rotation = elapsed.as_secs() as f64 + elapsed.subsec_nanos() as f64 / 1_000_000_000.0;
-        let rotation = Mat3::from_rotation_y(rotation as f32);
+        let rotation = Mat3::from_rotation_y(rotation);
 
         // NOTE: This teapot was meant for OpenGL where the origin is at the lower left
         // instead the origin is at the upper left in Vulkan, so we reverse the Y axis.