generated

Author: Firestar99

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

@@ -29,6 +29,6 @@ glam = { version = "0.30.9", default-features = false }
 bytemuck = { version = "1.24.0", features = ["derive"] }
 raw-window-handle = "0.6.2"
 winit = "0.30.0"
-cfg-if = "1.0.0"
+env_logger = "0.11.8"
 anyhow = "1.0.98"
 

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

@@ -30,7 +30,7 @@ glam = { version = "0.30.9", default-features = false }
 bytemuck = { version = "1.24.0", features = ["derive"] }
 raw-window-handle = "0.6.2"
 winit = "0.30.0"
-cfg-if = "1.0.0"
+env_logger = "0.11.8"
 anyhow = "1.0.98"
 
 # Optimize build scripts, copied from rust-gpu's repo

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

@@ -18,6 +18,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"] }
+pollster = "0.4.0"
 
 # rust-gpu
 cargo-gpu = { git = "https://github.com/Rust-GPU/cargo-gpu", rev = "bf24eb6060e0c7b0013eceddd23b5d7cee68f4cc" }
@@ -28,6 +29,6 @@ glam = { version = "0.30.9", default-features = false }
 bytemuck = { version = "1.24.0", features = ["derive"] }
 raw-window-handle = "0.6.2"
 winit = "0.30.0"
-cfg-if = "1.0.0"
+env_logger = "0.11.8"
 anyhow = "1.0.98"
 

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

@@ -16,6 +16,8 @@ mygraphics-shaders = { path = "../mygraphics-shaders" }
 
 # API
 wgpu.workspace = true
+pollster.workspace = true
+env_logger.workspace = true
 
 # other
 raw-window-handle.workspace = true

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

@@ -0,0 +1,104 @@
+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};
+
+mod render_pipeline;
+mod renderer;
+mod swapchain;
+
+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 | wgpu::Features::EXPERIMENTAL_PASSTHROUGH_SHADERS;
+    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: unsafe { wgpu::ExperimentalFeatures::enabled() },
+            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())?;
+
+    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(())
+            }
+        };
+
+    // 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

@@ -0,0 +1,92 @@
+use mygraphics_shaders::ShaderConstants;
+use wgpu::{
+    ColorTargetState, ColorWrites, Device, FragmentState, FrontFace, MultisampleState,
+    PipelineLayoutDescriptor, PolygonMode, PrimitiveState, PrimitiveTopology, PushConstantRange,
+    RenderPass, RenderPipeline, RenderPipelineDescriptor, ShaderModuleDescriptorPassthrough,
+    ShaderRuntimeChecks, ShaderStages, TextureFormat, VertexState,
+};
+
+pub struct MyRenderPipeline {
+    pipeline: RenderPipeline,
+}
+
+impl MyRenderPipeline {
+    pub fn new(device: &Device, out_format: TextureFormat) -> anyhow::Result<Self> {
+        // Workaround in wgpu 27.0.1 where the macro expansion of `include_spirv_raw!` doesn't compile
+        // see https://github.com/gfx-rs/wgpu/pull/8250
+        // let module = unsafe {
+        //     device.create_shader_module_passthrough(include_spirv_raw!(env!("SHADER_SPV_PATH")))
+        // };
+        let module = unsafe {
+            device.create_shader_module_passthrough(ShaderModuleDescriptorPassthrough {
+                label: Some(env!("SHADER_SPV_PATH")),
+                entry_point: "".to_owned(),
+                num_workgroups: (0, 0, 0),
+                runtime_checks: ShaderRuntimeChecks::unchecked(),
+                spirv: Some(wgpu::util::make_spirv_raw(include_bytes!(env!(
+                    "SHADER_SPV_PATH"
+                )))),
+                dxil: None,
+                msl: None,
+                hlsl: None,
+                glsl: None,
+                wgsl: None,
+            })
+        };
+
+        let layout = device.create_pipeline_layout(&PipelineLayoutDescriptor {
+            label: Some("MyRenderPipeline layout"),
+            bind_group_layouts: &[],
+            push_constant_ranges: &[PushConstantRange {
+                stages: ShaderStages::VERTEX_FRAGMENT,
+                range: 0..size_of::<ShaderConstants>() as u32,
+            }],
+        });
+
+        Ok(Self {
+            pipeline: device.create_render_pipeline(&RenderPipelineDescriptor {
+                label: Some("MyRenderPipeline"),
+                layout: Some(&layout),
+                vertex: VertexState {
+                    module: &module,
+                    entry_point: Some("main_vs"),
+                    compilation_options: Default::default(),
+                    buffers: &[],
+                },
+                primitive: PrimitiveState {
+                    topology: PrimitiveTopology::TriangleList,
+                    strip_index_format: None,
+                    front_face: FrontFace::Ccw,
+                    cull_mode: None,
+                    unclipped_depth: false,
+                    polygon_mode: PolygonMode::Fill,
+                    conservative: false,
+                },
+                depth_stencil: None,
+                multisample: MultisampleState::default(),
+                fragment: Some(FragmentState {
+                    module: &module,
+                    entry_point: Some("main_fs"),
+                    compilation_options: Default::default(),
+                    targets: &[Some(ColorTargetState {
+                        format: out_format,
+                        blend: None,
+                        write_mask: ColorWrites::ALL,
+                    })],
+                }),
+                multiview: None,
+                cache: None,
+            }),
+        })
+    }
+
+    pub fn draw(&self, rpass: &mut RenderPass<'_>, shader_constants: &ShaderConstants) {
+        rpass.set_pipeline(&self.pipeline);
+        rpass.set_push_constants(
+            ShaderStages::VERTEX_FRAGMENT,
+            0,
+            bytemuck::bytes_of(shader_constants),
+        );
+        rpass.draw(0..3, 0..1);
+    }
+}

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

@@ -0,0 +1,51 @@
+use crate::wgpu_renderer::render_pipeline::MyRenderPipeline;
+use mygraphics_shaders::ShaderConstants;
+use wgpu::wgt::CommandEncoderDescriptor;
+use wgpu::{
+    Color, Device, LoadOp, Operations, Queue, RenderPassColorAttachment, RenderPassDescriptor,
+    StoreOp, TextureFormat, TextureView,
+};
+
+pub struct MyRenderer {
+    pub device: Device,
+    pub queue: Queue,
+    pipeline: MyRenderPipeline,
+}
+
+impl MyRenderer {
+    pub fn new(device: Device, queue: Queue, out_format: TextureFormat) -> anyhow::Result<Self> {
+        Ok(Self {
+            pipeline: MyRenderPipeline::new(&device, out_format)?,
+            device,
+            queue,
+        })
+    }
+
+    pub fn render(&self, shader_constants: &ShaderConstants, output: TextureView) {
+        let mut cmd = self
+            .device
+            .create_command_encoder(&CommandEncoderDescriptor {
+                label: Some("main draw"),
+            });
+
+        let mut rpass = cmd.begin_render_pass(&RenderPassDescriptor {
+            label: Some("main renderpass"),
+            color_attachments: &[Some(RenderPassColorAttachment {
+                view: &output,
+                depth_slice: None,
+                resolve_target: None,
+                ops: Operations {
+                    load: LoadOp::Clear(Color::BLACK),
+                    store: StoreOp::Store,
+                },
+            })],
+            depth_stencil_attachment: None,
+            timestamp_writes: None,
+            occlusion_query_set: None,
+        });
+        self.pipeline.draw(&mut rpass, shader_constants);
+        drop(rpass);
+
+        self.queue.submit(std::iter::once(cmd.finish()));
+    }
+}