wgpu: implement wgpu renderer

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"] }
+pollster = "0.4.0"
 {%- endif %}
 
 # rust-gpu

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

@@ -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/Cargo.toml.liquid

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

graphics/mygraphics/Cargo.toml

@@ -1,4 +1,102 @@
+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<()> {
-    println!("wgpu renderer");
+    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())?;
+
+    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(())
 }

graphics/mygraphics/Cargo.toml.liquid

@@ -0,0 +1,61 @@
+use mygraphics_shaders::ShaderConstants;
+use wgpu::{
+    ColorTargetState, ColorWrites, Device, FragmentState, FrontFace, MultisampleState, PolygonMode,
+    PrimitiveState, PrimitiveTopology, RenderPass, RenderPipeline, RenderPipelineDescriptor,
+    ShaderStages, TextureFormat, VertexState, include_spirv,
+};
+
+pub struct MyRenderPipeline {
+    pipeline: RenderPipeline,
+}
+
+impl MyRenderPipeline {
+    pub fn new(device: &Device, out_format: TextureFormat) -> anyhow::Result<Self> {
+        let module = device.create_shader_module(include_spirv!(env!("SHADER_SPV_PATH")));
+        Ok(Self {
+            pipeline: device.create_render_pipeline(&RenderPipelineDescriptor {
+                label: Some("MyRenderPipeline"),
+                layout: None,
+                vertex: VertexState {
+                    module: &module,
+                    entry_point: None,
+                    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: None,
+                    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);
+    }
+}

graphics/mygraphics/src/wgpu_renderer/mod.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()));
+    }
+}

graphics/mygraphics/src/wgpu_renderer/render_pipeline.rs

@@ -0,0 +1,117 @@
+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<'a> {
+    adapter: Adapter,
+    device: Device,
+    window: Arc<Window>,
+    surface: Surface<'a>,
+    format: TextureFormat,
+
+    // state below
+    active: Option<ActiveConfiguration>,
+    should_recreate: bool,
+}
+
+pub struct ActiveConfiguration {
+    size: PhysicalSize<u32>,
+}
+
+impl<'a> MySwapchainManager<'a> {
+    pub fn new(
+        adapter: Adapter,
+        device: Device,
+        window: Arc<Window>,
+        surface: Surface<'a>,
+    ) -> Self {
+        let caps = surface.get_capabilities(&adapter);
+        Self {
+            adapter,
+            device,
+            window,
+            surface,
+            format: caps.formats[0],
+            active: None,
+            should_recreate: true,
+        }
+    }
+
+    #[inline]
+    pub fn should_recreate(&mut self) {
+        self.should_recreate = true;
+    }
+
+    pub fn format(&self) -> TextureFormat {
+        self.format
+    }
+
+    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 active.size != size {
+                self.should_recreate();
+            }
+        } else {
+            self.should_recreate();
+        }
+
+        const RECREATE_ATTEMPTS: u32 = 10;
+        for _ in 0..RECREATE_ATTEMPTS {
+            if self.should_recreate {
+                self.should_recreate = false;
+                self.configure_surface(size)?;
+            }
+
+            match self.surface.get_current_texture() {
+                Ok(surface_texture) => {
+                    if surface_texture.suboptimal {
+                        self.should_recreate = true;
+                    }
+                    let output_view =
+                        surface_texture
+                            .texture
+                            .create_view(&wgpu::TextureViewDescriptor {
+                                format: Some(self.format),
+                                ..wgpu::TextureViewDescriptor::default()
+                            });
+                    let r = f(output_view);
+                    surface_texture.present();
+                    return Ok(r);
+                }
+                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<()> {
+        let mut surface_config = self
+            .surface
+            .get_default_config(&self.adapter, size.width, size.height)
+            .with_context(|| {
+                format!(
+                    "Incompatible adapter for surface, returned capabilities: {:?}",
+                    self.surface.get_capabilities(&self.adapter)
+                )
+            })?;
+
+        // force srgb surface format
+        surface_config.view_formats.push(self.format);
+        // limit framerate to vsync
+        surface_config.present_mode = wgpu::PresentMode::AutoVsync;
+        self.surface.configure(&self.device, &surface_config);
+
+        self.active = Some(ActiveConfiguration { size });
+        Ok(())
+    }
+}