fix: cargo xtask generate

Author: goldnor

generated/graphics/ash/cargo-gpu/Cargo.toml

@@ -29,7 +29,7 @@ spirv-std = { git = "https://github.com/Rust-GPU/rust-gpu", rev = "30896871ba00e
 glam = { version = "0.32.0", default-features = false }
 bytemuck = { version = "1.24.0", features = ["derive"] }
 raw-window-handle = "0.6.2"
-winit = "0.30.0"
+winit = "0.30.13"
 env_logger = "0.11.8"
 anyhow = "1.0.98"
 

generated/graphics/ash/spirv-builder/Cargo.toml

@@ -30,7 +30,7 @@ spirv-std = { git = "https://github.com/Rust-GPU/rust-gpu", rev = "30896871ba00e
 glam = { version = "0.32.0", default-features = false }
 bytemuck = { version = "1.24.0", features = ["derive"] }
 raw-window-handle = "0.6.2"
-winit = "0.30.0"
+winit = "0.30.13"
 env_logger = "0.11.8"
 anyhow = "1.0.98"
 

generated/graphics/wgpu/cargo-gpu/Cargo.toml

@@ -17,7 +17,7 @@ unexpected_cfgs = { level = "allow", check-cfg = ['cfg(target_arch, values("spir
 
 [workspace.dependencies]
 # API
-wgpu = { version = "27.0.1", default-features = false, features = ["std", "parking_lot", "vulkan", "vulkan-portability", "spirv", "wgsl"] }
+wgpu = { version = "29.0.1", default-features = false, features = ["std", "parking_lot", "vulkan", "vulkan-portability", "spirv", "wgsl"] }
 pollster = "0.4.0"
 
 # rust-gpu
@@ -28,7 +28,7 @@ spirv-std = { git = "https://github.com/Rust-GPU/rust-gpu", rev = "30896871ba00e
 glam = { version = "0.32.0", default-features = false }
 bytemuck = { version = "1.24.0", features = ["derive"] }
 raw-window-handle = "0.6.2"
-winit = "0.30.0"
+winit = "0.30.13"
 env_logger = "0.11.8"
 anyhow = "1.0.98"
 

generated/graphics/wgpu/cargo-gpu/mygraphics/src/wgpu_renderer/app.rs

@@ -0,0 +1,83 @@
+use std::{sync::Arc, time::Instant};
+
+use winit::{
+    application::ApplicationHandler,
+    dpi::LogicalSize,
+    event::{ElementState, KeyEvent, WindowEvent},
+    event_loop::ActiveEventLoop,
+    keyboard::{Key, NamedKey},
+    window::{Window, WindowId},
+};
+
+use crate::wgpu_renderer::state::State;
+
+pub(crate) struct App {
+    start: Instant,
+    state: Option<State>,
+}
+
+impl App {
+    pub fn new() -> Self {
+        let start = std::time::Instant::now();
+
+        App { start, state: None }
+    }
+
+    pub fn try_resume(&mut self, event_loop: &ActiveEventLoop) -> anyhow::Result<()> {
+        let attribs = Window::default_attributes()
+            .with_title("Rust GPU - wgpu")
+            .with_inner_size(LogicalSize::new(1280, 720));
+
+        let window = event_loop.create_window(attribs).map(Arc::new)?;
+
+        let state = pollster::block_on(State::try_new(
+            event_loop.owned_display_handle(),
+            window.clone(),
+        ))?;
+        self.state = Some(state);
+
+        window.request_redraw();
+
+        Ok(())
+    }
+}
+
+impl ApplicationHandler for App {
+    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+        if let Err(e) = self.try_resume(event_loop) {
+            eprintln!("Failed to resume: {e:?}");
+            event_loop.exit();
+        }
+    }
+
+    fn window_event(&mut self, event_loop: &ActiveEventLoop, _id: WindowId, event: WindowEvent) {
+        let Some(state) = self.state.as_mut() else {
+            eprintln!("Failed to retrieve app state.");
+            event_loop.exit();
+            return;
+        };
+
+        match event {
+            WindowEvent::CloseRequested
+            | WindowEvent::KeyboardInput {
+                event:
+                    KeyEvent {
+                        logical_key: Key::Named(NamedKey::Escape),
+                        state: ElementState::Pressed,
+                        ..
+                    },
+                ..
+            } => {
+                event_loop.exit();
+            }
+            WindowEvent::RedrawRequested => {
+                state.render(self.start.elapsed().as_secs_f32());
+                state.get_window().request_redraw();
+            }
+            WindowEvent::Resized(size) => {
+                state.resize(size);
+            }
+            _ => (),
+        }
+    }
+}

generated/graphics/wgpu/cargo-gpu/mygraphics/src/wgpu_renderer/mod.rs

@@ -1,103 +1,19 @@
-use crate::wgpu_renderer::swapchain::MySwapchainManager;
-use anyhow::Context;
-use mygraphics_shaders::ShaderConstants;
-use std::sync::Arc;
-use winit::event::{Event, WindowEvent};
-use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop};
+use crate::wgpu_renderer::app::App;
+use winit::event_loop::{ControlFlow, EventLoop};
 
+mod app;
 mod render_pipeline;
 mod renderer;
-mod swapchain;
+mod state;
 
 pub fn main() -> anyhow::Result<()> {
     env_logger::init();
-    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 = 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.clone())?;
-    let adapter =
-        wgpu::util::initialize_adapter_from_env_or_default(&instance, Some(&surface)).await?;
-
-    let required_features = wgpu::Features::PUSH_CONSTANTS;
-    let required_limits = wgpu::Limits {
-        max_push_constant_size: 128,
-        ..Default::default()
-    };
-    let (device, queue) = adapter
-        .request_device(&wgpu::DeviceDescriptor {
-            label: None,
-            required_features,
-            required_limits,
-            experimental_features: wgpu::ExperimentalFeatures::disabled(),
-            memory_hints: wgpu::MemoryHints::Performance,
-            trace: Default::default(),
-        })
-        .await
-        .context("Failed to create device")?;
-
-    let mut swapchain = MySwapchainManager::new(adapter.clone(), device.clone(), window, surface);
-    let renderer = renderer::MyRenderer::new(device, queue, swapchain.format())?;
+    event_loop.set_control_flow(ControlFlow::Poll);
 
-    let start = std::time::Instant::now();
-    let mut event_handler =
-        move |event: Event<_>, event_loop_window_target: &ActiveEventLoop| match event {
-            Event::AboutToWait => swapchain.render(|render_target| {
-                renderer.render(
-                    &ShaderConstants {
-                        time: start.elapsed().as_secs_f32(),
-                        width: render_target.texture().width(),
-                        height: render_target.texture().height(),
-                    },
-                    render_target,
-                );
-            }),
-            Event::WindowEvent { event, .. } => {
-                match event {
-                    WindowEvent::KeyboardInput {
-                        event:
-                            winit::event::KeyEvent {
-                                logical_key:
-                                    winit::keyboard::Key::Named(winit::keyboard::NamedKey::Escape),
-                                state: winit::event::ElementState::Pressed,
-                                ..
-                            },
-                        ..
-                    }
-                    | WindowEvent::CloseRequested => event_loop_window_target.exit(),
-                    WindowEvent::Resized(_) => swapchain.should_recreate(),
-                    _ => {}
-                }
-                Ok(())
-            }
-            _ => {
-                event_loop_window_target.set_control_flow(ControlFlow::Poll);
-                Ok(())
-            }
-        };
+    let mut app = App::new();
+    event_loop.run_app(&mut app)?;
 
-    // FIXME(eddyb) incomplete `winit` upgrade, follow the guides in:
-    // https://github.com/rust-windowing/winit/releases/tag/v0.30.0
-    #[allow(deprecated)]
-    event_loop.run(move |event, event_loop_window_target| {
-        event_handler(event, event_loop_window_target).unwrap();
-    })?;
     Ok(())
 }

generated/graphics/wgpu/cargo-gpu/mygraphics/src/wgpu_renderer/render_pipeline.rs

@@ -2,9 +2,8 @@ use crate::wgpu_renderer::renderer::{GlobalBindGroup, GlobalBindGroupLayout};
 use mygraphics_shaders::ShaderConstants;
 use wgpu::{
     ColorTargetState, ColorWrites, Device, FragmentState, FrontFace, MultisampleState,
-    PipelineLayoutDescriptor, PolygonMode, PrimitiveState, PrimitiveTopology, PushConstantRange,
-    RenderPass, RenderPipeline, RenderPipelineDescriptor, ShaderStages, TextureFormat, VertexState,
-    include_spirv,
+    PipelineLayoutDescriptor, PolygonMode, PrimitiveState, PrimitiveTopology, RenderPass,
+    RenderPipeline, RenderPipelineDescriptor, TextureFormat, VertexState, include_spirv,
 };
 
 #[derive(Debug, Clone)]
@@ -22,11 +21,8 @@ impl MyRenderPipeline {
 
         let layout = device.create_pipeline_layout(&PipelineLayoutDescriptor {
             label: Some("MyRenderPipeline layout"),
-            bind_group_layouts: &[&global_bind_group_layout.0],
-            push_constant_ranges: &[PushConstantRange {
-                stages: ShaderStages::VERTEX_FRAGMENT,
-                range: 0..size_of::<ShaderConstants>() as u32,
-            }],
+            bind_group_layouts: &[Some(&global_bind_group_layout.0)],
+            immediate_size: size_of::<ShaderConstants>() as u32,
         });
 
         Ok(Self {
@@ -60,7 +56,7 @@ impl MyRenderPipeline {
                         write_mask: ColorWrites::ALL,
                     })],
                 }),
-                multiview: None,
+                multiview_mask: None,
                 cache: None,
             }),
         })

generated/graphics/wgpu/cargo-gpu/mygraphics/src/wgpu_renderer/renderer.rs

@@ -53,6 +53,7 @@ impl MyRenderer {
             depth_stencil_attachment: None,
             timestamp_writes: None,
             occlusion_query_set: None,
+            multiview_mask: None,
         });
         self.pipeline.draw(&mut rpass, &global_bind_group);
         drop(rpass);