app: Move render_pass into scene

src/game/main_scene.rs

@@ -1,13 +1,20 @@
-use crate::core::input::InputManager;
+use std::{error::Error, sync::Arc};
+
 use crate::core::render::primitives::camera::Camera;
-use crate::core::render::render_context::RenderContext;
 use crate::core::render::texture::Texture;
 use crate::core::scene::Scene;
-use crate::core::timer::Timer;
+use crate::core::scene::SceneContext;
+use egui_winit_vulkano::{Gui, egui};
 use glam::{Mat4, Vec3};
-use vulkano::command_buffer::{
-    AutoCommandBufferBuilder, CommandBufferUsage, PrimaryAutoCommandBuffer,
-    PrimaryCommandBufferAbstract,
+use vulkano::{
+    command_buffer::{
+        AutoCommandBufferBuilder, CommandBufferUsage, PrimaryCommandBufferAbstract,
+        RenderingAttachmentInfo, RenderingInfo,
+    },
+    image::view::ImageView,
+    pipeline::graphics::viewport::Viewport,
+    render_pass::{AttachmentLoadOp, AttachmentStoreOp},
+    sync::GpuFuture,
 };
 
 use super::assets::square::Square;
@@ -29,11 +36,11 @@ impl Scene for MainScene {
         self.state.is_some()
     }
 
-    fn load(&mut self, render_context: &RenderContext) {
+    fn load(&mut self, scene_context: &SceneContext) {
         let square = Square::new(
-            render_context.device(),
-            render_context.memory_allocator(),
-            render_context.swapchain_format(),
+            &scene_context.device,
+            &scene_context.memory_allocator,
+            scene_context.swapchain_format,
         )
         .unwrap();
 
@@ -45,22 +52,22 @@ impl Scene for MainScene {
             ),
             Mat4::perspective_rh_gl(
                 std::f32::consts::FRAC_PI_2,
-                render_context.aspect_ratio(),
+                scene_context.aspect_ratio,
                 0.01,
                 100.0,
             ),
         );
 
         let mut uploads = AutoCommandBufferBuilder::primary(
-            render_context.command_buffer_allocator().clone(),
-            render_context.graphics_queue().queue_family_index(),
+            scene_context.command_buffer_allocator.clone(),
+            scene_context.graphics_queue.queue_family_index(),
             CommandBufferUsage::OneTimeSubmit,
         )
         .unwrap();
 
         let texture = Texture::from_file(
-            render_context.device(),
-            render_context.memory_allocator(),
+            &scene_context.device,
+            &scene_context.memory_allocator,
             &mut uploads,
             "res/textures/wooden-crate.jpg",
         )
@@ -69,7 +76,7 @@ impl Scene for MainScene {
         let _ = uploads
             .build()
             .unwrap()
-            .execute(render_context.graphics_queue().clone())
+            .execute(scene_context.graphics_queue.clone())
             .unwrap();
 
         self.state = Some(MainSceneState {
@@ -80,43 +87,99 @@ impl Scene for MainScene {
         });
     }
 
-    fn update(
-        &mut self,
-        render_context: &RenderContext,
-        input_manager: &InputManager,
-        timer: &Timer,
-    ) {
+    fn update(&mut self, scene_context: &SceneContext) {
         let state = self.state.as_mut().unwrap();
-        state.camera.update(input_manager, timer, state.speed, 10.0);
+        state.camera.update(
+            &scene_context.input_manager,
+            &scene_context.timer,
+            state.speed,
+            10.0,
+        );
 
         state.camera.set_projection(Mat4::perspective_rh_gl(
             std::f32::consts::FRAC_PI_2,
-            render_context.aspect_ratio(),
+            scene_context.aspect_ratio,
             0.01,
             100.0,
         ));
     }
 
     fn render(
-        &self,
-        render_context: &RenderContext,
-        builder: &mut AutoCommandBufferBuilder<PrimaryAutoCommandBuffer>,
-    ) {
+        &mut self,
+        image_view: &Arc<ImageView>,
+        acquire_future: Box<dyn GpuFuture>,
+        scene_context: &SceneContext,
+        gui: &mut Gui,
+    ) -> Result<Box<dyn GpuFuture>, Box<dyn Error>> {
         let state = self.state.as_ref().unwrap();
+
+        let mut builder = AutoCommandBufferBuilder::primary(
+            scene_context.command_buffer_allocator.clone(),
+            scene_context.graphics_queue.queue_family_index(),
+            CommandBufferUsage::OneTimeSubmit,
+        )?;
+
+        {
+            let viewport = Viewport {
+                offset: [0.0, 0.0],
+                extent: scene_context.window_size,
+                depth_range: 0.0..=1.0,
+            };
+
+            builder
+                .begin_rendering(RenderingInfo {
+                    color_attachments: vec![Some(RenderingAttachmentInfo {
+                        load_op: AttachmentLoadOp::Clear,
+                        store_op: AttachmentStoreOp::Store,
+                        clear_value: Some([0.0, 0.0, 0.0, 1.0].into()),
+                        ..RenderingAttachmentInfo::image_view(image_view.clone())
+                    })],
+                    ..Default::default()
+                })?
+                .set_viewport(0, [viewport].into_iter().collect())?;
+        }
+
         let camera_uniform = state
             .camera
-            .create_buffer(render_context.memory_allocator())
-            .unwrap();
+            .create_buffer(&scene_context.memory_allocator)?;
 
         state
             .square
             .render(
-                builder,
-                render_context.descriptor_set_allocator(),
+                &mut builder,
+                &scene_context.descriptor_set_allocator,
                 &camera_uniform,
                 &state.texture,
             )
             .unwrap();
+
+        builder.end_rendering()?;
+
+        let command_buffer = builder.build()?;
+
+        let render_future =
+            acquire_future.then_execute(scene_context.graphics_queue.clone(), command_buffer)?;
+
+        gui.immediate_ui(|gui| {
+            let ctx = gui.context();
+
+            egui::Window::new("Informations")
+                .vscroll(true)
+                .show(&ctx, |ui| {
+                    ui.label(format!("Resolution: {:?}", scene_context.window_size));
+
+                    ui.label(format!("{:#?}", scene_context.input_manager));
+
+                    ui.label(format!(
+                        "Delta time: {:?}",
+                        scene_context.timer.delta_time()
+                    ));
+                });
+        });
+
+        let render_future = gui.draw_on_image(render_future, image_view.clone());
+
+        Ok(render_future)
     }
 
     fn unload(&mut self) {}