bla2

Author: Firestar99

Cargo.lock

@@ -21,6 +21,7 @@ unexpected_cfgs = { level = "allow", check-cfg = ['cfg(target_arch, values("spir
 ash = "0.38"
 ash-window = "0.13"
 wgpu = { version = "27.0.1", default-features = false, features = ["std", "parking_lot", "vulkan", "vulkan-portability", "spirv", "wgsl"] }
+pollster = "0.4.0"
 
 # rust-gpu
 cargo-gpu = { git = "https://github.com/Rust-GPU/cargo-gpu", rev = "bf24eb6060e0c7b0013eceddd23b5d7cee68f4cc" }

Cargo.toml

@@ -23,6 +23,7 @@ ash-window = "0.13"
 {%- endif -%}
 {%- if api == "wgpu" -%}
 wgpu = { version = "27.0.1", default-features = false, features = ["std", "parking_lot", "vulkan", "vulkan-portability", "spirv", "wgsl"] }
+
 {%- endif %}
 
 # rust-gpu

graphics/Cargo.toml.liquid

@@ -18,6 +18,7 @@ mygraphics-shaders = { path = "../mygraphics-shaders" }
 ash.workspace = true
 ash-window.workspace = true
 wgpu.workspace = true
+pollster.workspace = true
 
 # other
 raw-window-handle.workspace = true

graphics/mygraphics/Cargo.toml

@@ -28,6 +28,7 @@ ash-window.workspace = true
 {%- endif -%}
 {%- if api == "wgpu" -%}
 wgpu.workspace = true
+pollster.workspace = true
 {%- endif %}
 
 # other

graphics/mygraphics/Cargo.toml.liquid

@@ -1,33 +1,37 @@
-use crate::wgpu_renderer::render_pipeline::MyRenderPipeline;
 use crate::wgpu_renderer::swapchain::MySwapchainManager;
 use anyhow::Context;
 use mygraphics_shaders::ShaderConstants;
-use wgpu::RenderPassDescriptor;
-use wgpu::wgt::CommandEncoderDescriptor;
+use std::sync::Arc;
 use winit::event::{Event, WindowEvent};
 use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop};
 
 mod render_pipeline;
 mod renderer;
 mod swapchain;
 
-pub async fn main() -> anyhow::Result<()> {
+pub fn main() -> anyhow::Result<()> {
+    pollster::block_on(main_inner())
+}
+
+pub async fn main_inner() -> anyhow::Result<()> {
     // env_logger::init();
     let event_loop = EventLoop::new()?;
     // FIXME(eddyb) incomplete `winit` upgrade, follow the guides in:
     // https://github.com/rust-windowing/winit/releases/tag/v0.30.0
     #[allow(deprecated)]
-    let window = event_loop.create_window(
-        winit::window::Window::default_attributes()
-            .with_title("Rust GPU - wgpu")
-            .with_inner_size(winit::dpi::LogicalSize::new(
-                f64::from(1280),
-                f64::from(720),
-            )),
-    )?;
+    let window = Arc::new(
+        event_loop.create_window(
+            winit::window::Window::default_attributes()
+                .with_title("Rust GPU - wgpu")
+                .with_inner_size(winit::dpi::LogicalSize::new(
+                    f64::from(1280),
+                    f64::from(720),
+                )),
+        )?,
+    );
 
     let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor::from_env_or_default());
-    let surface = instance.create_surface(&window)?;
+    let surface = instance.create_surface(window.clone())?;
     let adapter =
         wgpu::util::initialize_adapter_from_env_or_default(&instance, Some(&surface)).await?;
 
@@ -49,31 +53,20 @@ pub async fn main() -> anyhow::Result<()> {
         .context("Failed to create device")?;
 
     let mut swapchain = MySwapchainManager::new(adapter.clone(), device.clone(), window, surface);
-    let render_pipeline = MyRenderPipeline::new(&device, swapchain.format())?;
+    let renderer = renderer::MyRenderer::new(device, queue, swapchain.format())?;
 
     let start = std::time::Instant::now();
     let mut event_handler =
         move |event: Event<_>, event_loop_window_target: &ActiveEventLoop| match event {
-            Event::AboutToWait => swapchain.render(|f| {
-                let mut cmd = device.create_command_encoder(&CommandEncoderDescriptor {
-                    label: Some("main draw"),
-                });
-                let mut rpass = cmd.begin_render_pass(&RenderPassDescriptor {
-                    label: Some("main renderpass"),
-                    color_attachments: &[],
-                    depth_stencil_attachment: None,
-                    timestamp_writes: None,
-                    occlusion_query_set: None,
-                });
-                render_pipeline.draw(
-                    &mut rpass,
+            Event::AboutToWait => swapchain.render(|render_target| {
+                renderer.render(
                     &ShaderConstants {
                         time: start.elapsed().as_secs_f32(),
-                        width: f.texture().width(),
-                        height: f.texture().height(),
+                        width: render_target.texture().width(),
+                        height: render_target.texture().height(),
                     },
+                    render_target,
                 );
-                queue.submit(std::iter::once(cmd));
             }),
             Event::WindowEvent { event, .. } => {
                 match event {
@@ -91,7 +84,6 @@ pub async fn main() -> anyhow::Result<()> {
                     WindowEvent::Resized(_) => swapchain.should_recreate(),
                     _ => {}
                 }
-
                 Ok(())
             }
             _ => {

graphics/mygraphics/src/wgpu_renderer/mod.rs

@@ -44,6 +44,7 @@ impl MyRenderer {
             occlusion_query_set: None,
         });
         self.pipeline.draw(&mut rpass, shader_constants);
+        drop(rpass);
 
         self.queue.submit(std::iter::once(cmd.finish()));
     }

graphics/mygraphics/src/wgpu_renderer/renderer.rs

@@ -1,13 +1,14 @@
 use anyhow::Context;
+use std::sync::Arc;
 use wgpu::{Adapter, Device, Surface, SurfaceError, TextureFormat, TextureView};
 use winit::dpi::PhysicalSize;
 use winit::window::Window;
 
-pub struct MySwapchainManager {
+pub struct MySwapchainManager<'a> {
     adapter: Adapter,
     device: Device,
-    window: Window,
-    surface: Surface<'static>,
+    window: Arc<Window>,
+    surface: Surface<'a>,
     format: TextureFormat,
 
     // state below
@@ -19,12 +20,12 @@ pub struct ActiveConfiguration {
     size: PhysicalSize<u32>,
 }
 
-impl MySwapchainManager {
+impl<'a> MySwapchainManager<'a> {
     pub fn new(
         adapter: Adapter,
         device: Device,
-        window: Window,
-        surface: Surface<'static>,
+        window: Arc<Window>,
+        surface: Surface<'a>,
     ) -> Self {
         let caps = surface.get_capabilities(&adapter);
         Self {
@@ -47,9 +48,9 @@ impl MySwapchainManager {
         self.format
     }
 
-    pub fn render<R>(&mut self, f: impl FnOnce(TextureView) -> R) -> R {
+    pub fn render<R>(&mut self, f: impl FnOnce(TextureView) -> R) -> anyhow::Result<R> {
         let size = self.window.inner_size();
-        if let Some(active) = self.active {
+        if let Some(active) = &self.active {
             if active.size != size {
                 self.should_recreate();
             }
@@ -83,8 +84,14 @@ impl MySwapchainManager {
                 Err(SurfaceError::Outdated | SurfaceError::Lost) => {
                     self.should_recreate = true;
                 }
+                Err(e) => {
+                    anyhow::bail!("get_current_texture() failed: {}", e)
+                }
             };
         }
+        anyhow::bail!(
+            "looped {RECREATE_ATTEMPTS} times trying to acquire swapchain image and failed repeatedly!"
+        );
     }
 
     fn configure_surface(&mut self, size: PhysicalSize<u32>) -> anyhow::Result<()> {