Wasi hello-triangle example

examples-wasi/src/entrypoint_wasi.rs

@@ -55,12 +55,12 @@ const EXAMPLES: &[ExampleDesc] = &[
     //     webgl: false, // No canvas for WebGL
     //     webgpu: true,
     // },
-    // ExampleDesc {
-    //     name: "hello_triangle",
-    //     function: crate::hello_triangle::main,
-    //     webgl: true,
-    //     webgpu: true,
-    // },
+    ExampleDesc {
+        name: "hello_triangle",
+        function: crate::hello_triangle::main,
+        webgl: true,
+        webgpu: true,
+    },
     // ExampleDesc {
     //     name: "hello_windows",
     //     function: crate::hello_windows::main,

examples-wasi/src/hello_triangle/README.md

@@ -0,0 +1,13 @@
+# hello_triangle
+
+This example renders a triangle to a window.
+
+## To Run
+
+```
+cargo run --bin wgpu-examples hello_triangle
+```
+
+## Screenshots
+
+![Triangle window](./screenshot.png)

examples-wasi/src/hello_triangle/mod.rs

@@ -0,0 +1,181 @@
+use std::borrow::Cow;
+use winit::{
+    event::{Event, WindowEvent},
+    event_loop::EventLoop,
+    window::Window,
+};
+
+async fn run(event_loop: EventLoop<()>, window: Window) {
+    let mut size = window.inner_size();
+    size.width = size.width.max(1);
+    size.height = size.height.max(1);
+
+    let instance = wgpu::Instance::default();
+
+    let surface = instance.create_surface(&window).unwrap();
+    let adapter = instance
+        .request_adapter(&wgpu::RequestAdapterOptions {
+            power_preference: wgpu::PowerPreference::default(),
+            force_fallback_adapter: false,
+            // Request an adapter which can render to our surface
+            compatible_surface: Some(&surface),
+        })
+        .await
+        .expect("Failed to find an appropriate adapter");
+
+    // Create the logical device and command queue
+    let (device, queue) = adapter
+        .request_device(
+            &wgpu::DeviceDescriptor {
+                label: None,
+                required_features: wgpu::Features::empty(),
+                // Make sure we use the texture resolution limits from the adapter, so we can support images the size of the swapchain.
+                required_limits: wgpu::Limits::downlevel_webgl2_defaults()
+                    .using_resolution(adapter.limits()),
+            },
+            None,
+        )
+        .await
+        .expect("Failed to create device");
+
+    // Load the shaders from disk
+    let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+        label: None,
+        source: wgpu::ShaderSource::Wgsl(Cow::Borrowed(include_str!("shader.wgsl"))),
+    });
+
+    let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+        label: None,
+        bind_group_layouts: &[],
+        push_constant_ranges: &[],
+    });
+
+    let swapchain_capabilities = surface.get_capabilities(&adapter);
+    let swapchain_format = swapchain_capabilities.formats[0];
+
+    let render_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+        label: None,
+        layout: Some(&pipeline_layout),
+        vertex: wgpu::VertexState {
+            module: &shader,
+            entry_point: "vs_main",
+            buffers: &[],
+        },
+        fragment: Some(wgpu::FragmentState {
+            module: &shader,
+            entry_point: "fs_main",
+            targets: &[Some(swapchain_format.into())],
+        }),
+        primitive: wgpu::PrimitiveState::default(),
+        depth_stencil: None,
+        multisample: wgpu::MultisampleState::default(),
+        multiview: None,
+    });
+
+    let mut config = surface
+        .get_default_config(&adapter, size.width, size.height)
+        .unwrap();
+    surface.configure(&device, &config);
+    log::info!("333333333333333333333333333333333 - 1");
+
+    let window = &window;
+    event_loop
+        .run(move |event, target| {
+            log::info!("333333333333333333333333333333333 - 2");
+            // Have the closure take ownership of the resources.
+            // `event_loop.run` never returns, therefore we must do this to ensure
+            // the resources are properly cleaned up.
+            let _ = (&instance, &adapter, &shader, &pipeline_layout);
+
+            if let Event::WindowEvent {
+                window_id: _,
+                event,
+            } = event
+            {
+                match event {
+                    WindowEvent::Resized(new_size) => {
+                        // Reconfigure the surface with the new size
+                        config.width = new_size.width.max(1);
+                        config.height = new_size.height.max(1);
+                        surface.configure(&device, &config);
+                        // On macos the window needs to be redrawn manually after resizing
+                        window.request_redraw();
+                    }
+                    WindowEvent::RedrawRequested => {
+                        log::info!("333333333333333333333333333333333 - 3");
+
+                        let frame = surface
+                            .get_current_texture()
+                            .expect("Failed to acquire next swap chain texture");
+                        let view = frame
+                            .texture
+                            .create_view(&wgpu::TextureViewDescriptor::default());
+                        let mut encoder =
+                            device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
+                                label: None,
+                            });
+                        {
+                            let mut rpass =
+                                encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                                    label: None,
+                                    color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                                        view: &view,
+                                        resolve_target: None,
+                                        ops: wgpu::Operations {
+                                            load: wgpu::LoadOp::Clear(wgpu::Color::GREEN),
+                                            store: wgpu::StoreOp::Store,
+                                        },
+                                    })],
+                                    depth_stencil_attachment: None,
+                                    timestamp_writes: None,
+                                    occlusion_query_set: None,
+                                });
+                            rpass.set_pipeline(&render_pipeline);
+                            rpass.draw(0..3, 0..1);
+                        }
+
+                        queue.submit(Some(encoder.finish()));
+                        frame.present();
+                    }
+                    WindowEvent::CloseRequested => target.exit(),
+                    _ => {}
+                };
+            }
+        })
+        .unwrap();
+    log::info!("333333333333333333333333333333333 - 4");
+}
+
+pub fn main() {
+    crate::entrypoint_wasi::WasiLogger::init();
+    let event_loop = EventLoop::<()>::new().unwrap();
+    #[allow(unused_mut)]
+    let mut builder = winit::window::WindowBuilder::new();
+    // #[cfg(target_arch = "wasm32")]
+    // {
+    //     use wasm_bindgen::JsCast;
+    //     use winit::platform::web::WindowBuilderExtWebSys;
+    //     let canvas = web_sys::window()
+    //         .unwrap()
+    //         .document()
+    //         .unwrap()
+    //         .get_element_by_id("canvas")
+    //         .unwrap()
+    //         .dyn_into::<web_sys::HtmlCanvasElement>()
+    //         .unwrap();
+    //     builder = builder.with_canvas(Some(canvas));
+    // }
+    let window = builder.build(&event_loop).unwrap();
+
+    // #[cfg(not(target_arch = "wasm32"))]
+    // {
+    //     env_logger::init();
+        pollster::block_on(run(event_loop, window));
+    // }
+    // #[cfg(target_arch = "wasm32")]
+    // {
+    //     std::panic::set_hook(Box::new(console_error_panic_hook::hook));
+    //     console_log::init().expect("could not initialize logger");
+    //     wasm_bindgen_futures::spawn_local(run(event_loop, window));
+    // }
+}

examples-wasi/src/hello_triangle/shader.wgsl

@@ -0,0 +1,11 @@
+@vertex
+fn vs_main(@builtin(vertex_index) in_vertex_index: u32) -> @builtin(position) vec4<f32> {
+    let x = f32(i32(in_vertex_index) - 1);
+    let y = f32(i32(in_vertex_index & 1u) * 2 - 1);
+    return vec4<f32>(x, y, 0.0, 1.0);
+}
+
+@fragment
+fn fs_main() -> @location(0) vec4<f32> {
+    return vec4<f32>(1.0, 0.0, 0.0, 1.0);
+}

examples-wasi/src/lib.rs

@@ -12,7 +12,7 @@ mod flume;
 // pub mod hello;
 pub mod hello_compute;
 // pub mod hello_synchronization;
-// pub mod hello_triangle;
+pub mod hello_triangle;
 // pub mod hello_windows;
 // pub mod hello_workgroups;
 // pub mod mipmap;