From f438f0b920a75bd3ffb093d2750e2ac99569cafb Mon Sep 17 00:00:00 2001
From: Dzmitry Malyshau <kvarkus@gmail.com>
Date: Mon, 31 May 2021 22:19:51 -0400
Subject: [PATCH] [rs] Bunnymark example

---
 wgpu/examples/bunnymark/icon.png    | Bin 0 -> 15713 bytes
 wgpu/examples/bunnymark/main.rs     | 359 ++++++++++++++++++++++++++++
 wgpu/examples/bunnymark/shader.wgsl |  43 ++++
 3 files changed, 402 insertions(+)
 create mode 100644 wgpu/examples/bunnymark/icon.png
 create mode 100644 wgpu/examples/bunnymark/main.rs
 create mode 100644 wgpu/examples/bunnymark/shader.wgsl

diff --git a/wgpu/examples/bunnymark/icon.png b/wgpu/examples/bunnymark/icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..5e72defd21325e252a4ecce54b5858c5c55882a0
GIT binary patch
literal 15713
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

literal 0
HcmV?d00001

diff --git a/wgpu/examples/bunnymark/main.rs b/wgpu/examples/bunnymark/main.rs
new file mode 100644
index 0000000000..e3a773586e
--- /dev/null
+++ b/wgpu/examples/bunnymark/main.rs
@@ -0,0 +1,359 @@
+use bytemuck::{Pod, Zeroable};
+use std::{borrow::Cow, mem};
+use wgpu::util::DeviceExt;
+
+#[path = "../framework.rs"]
+mod framework;
+
+const MAX_BUNNIES: usize = 1 << 20;
+const BUNNY_SIZE: f32 = 0.15 * 256.0;
+const GRAVITY: f32 = -9.8 * 100.0;
+const MAX_VELOCITY: f32 = 750.0;
+
+#[repr(C)]
+#[derive(Clone, Copy, Pod, Zeroable)]
+struct Globals {
+    mvp: [[f32; 4]; 4],
+    size: [f32; 2],
+    pad: [f32; 2],
+}
+
+#[repr(C, align(256))]
+#[derive(Clone, Copy, Zeroable)]
+struct Locals {
+    position: [f32; 2],
+    velocity: [f32; 2],
+    color: u32,
+    _pad: u32,
+}
+
+/// Example struct holds references to wgpu resources and frame persistent data
+struct Example {
+    global_group: wgpu::BindGroup,
+    local_group: wgpu::BindGroup,
+    pipeline: wgpu::RenderPipeline,
+    bunnies: Vec<Locals>,
+    local_buffer: wgpu::Buffer,
+    extent: [u32; 2],
+}
+
+impl framework::Example for Example {
+    /// constructs initial instance of Example struct
+    fn init(
+        sc_desc: &wgpu::SwapChainDescriptor,
+        _adapter: &wgpu::Adapter,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+    ) -> Self {
+        let shader = device.create_shader_module(&wgpu::ShaderModuleDescriptor {
+            label: None,
+            source: wgpu::ShaderSource::Wgsl(Cow::Borrowed(include_str!("shader.wgsl"))),
+            flags: wgpu::ShaderFlags::all(),
+        });
+
+        let global_bind_group_layout =
+            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+                entries: &[
+                    wgpu::BindGroupLayoutEntry {
+                        binding: 0,
+                        visibility: wgpu::ShaderStage::VERTEX,
+                        ty: wgpu::BindingType::Buffer {
+                            ty: wgpu::BufferBindingType::Uniform,
+                            has_dynamic_offset: false,
+                            min_binding_size: wgpu::BufferSize::new(mem::size_of::<Globals>() as _),
+                        },
+                        count: None,
+                    },
+                    wgpu::BindGroupLayoutEntry {
+                        binding: 1,
+                        visibility: wgpu::ShaderStage::FRAGMENT,
+                        ty: wgpu::BindingType::Texture {
+                            sample_type: wgpu::TextureSampleType::Float { filterable: true },
+                            view_dimension: wgpu::TextureViewDimension::D2,
+                            multisampled: false,
+                        },
+                        count: None,
+                    },
+                    wgpu::BindGroupLayoutEntry {
+                        binding: 2,
+                        visibility: wgpu::ShaderStage::FRAGMENT,
+                        ty: wgpu::BindingType::Sampler {
+                            filtering: true,
+                            comparison: false,
+                        },
+                        count: None,
+                    },
+                ],
+                label: None,
+            });
+        let local_bind_group_layout =
+            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+                entries: &[wgpu::BindGroupLayoutEntry {
+                    binding: 0,
+                    visibility: wgpu::ShaderStage::VERTEX,
+                    ty: wgpu::BindingType::Buffer {
+                        ty: wgpu::BufferBindingType::Uniform,
+                        has_dynamic_offset: true,
+                        min_binding_size: wgpu::BufferSize::new(mem::size_of::<Locals>() as _),
+                    },
+                    count: None,
+                }],
+                label: None,
+            });
+        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+            label: None,
+            bind_group_layouts: &[&global_bind_group_layout, &local_bind_group_layout],
+            push_constant_ranges: &[],
+        });
+
+        let 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: &[wgpu::ColorTargetState {
+                    format: sc_desc.format,
+                    blend: Some(wgpu::BlendState::ALPHA_BLENDING),
+                    write_mask: wgpu::ColorWrite::default(),
+                }],
+            }),
+            primitive: wgpu::PrimitiveState {
+                topology: wgpu::PrimitiveTopology::TriangleStrip,
+                ..wgpu::PrimitiveState::default()
+            },
+            depth_stencil: None,
+            multisample: wgpu::MultisampleState::default(),
+        });
+
+        let texture = {
+            let img_data = include_bytes!("icon.png");
+            let decoder = png::Decoder::new(std::io::Cursor::new(img_data));
+            let (info, mut reader) = decoder.read_info().unwrap();
+            let mut buf = vec![0; info.buffer_size()];
+            reader.next_frame(&mut buf).unwrap();
+
+            let size = wgpu::Extent3d {
+                width: info.width,
+                height: info.height,
+                depth_or_array_layers: 1,
+            };
+            let texture = device.create_texture(&wgpu::TextureDescriptor {
+                label: None,
+                size,
+                mip_level_count: 1,
+                sample_count: 1,
+                dimension: wgpu::TextureDimension::D2,
+                format: wgpu::TextureFormat::Rgba8UnormSrgb,
+                usage: wgpu::TextureUsage::COPY_DST | wgpu::TextureUsage::SAMPLED,
+            });
+            queue.write_texture(
+                wgpu::ImageCopyTexture {
+                    texture: &texture,
+                    mip_level: 0,
+                    origin: wgpu::Origin3d::ZERO,
+                },
+                &buf,
+                wgpu::ImageDataLayout {
+                    offset: 0,
+                    bytes_per_row: std::num::NonZeroU32::new(info.width * 4),
+                    rows_per_image: None,
+                },
+                size,
+            );
+            texture
+        };
+
+        let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
+            label: None,
+            address_mode_u: wgpu::AddressMode::ClampToEdge,
+            address_mode_v: wgpu::AddressMode::ClampToEdge,
+            address_mode_w: wgpu::AddressMode::ClampToEdge,
+            mag_filter: wgpu::FilterMode::Linear,
+            min_filter: wgpu::FilterMode::Nearest,
+            mipmap_filter: wgpu::FilterMode::Nearest,
+            ..Default::default()
+        });
+
+        let globals = Globals {
+            mvp: cgmath::ortho(
+                0.0,
+                sc_desc.width as f32,
+                0.0,
+                sc_desc.height as f32,
+                -1.0,
+                1.0,
+            )
+            .into(),
+            size: [BUNNY_SIZE; 2],
+            pad: [0.0; 2],
+        };
+        let global_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: Some("global"),
+            contents: bytemuck::bytes_of(&globals),
+            usage: wgpu::BufferUsage::COPY_DST | wgpu::BufferUsage::UNIFORM,
+        });
+        let local_buffer = device.create_buffer(&wgpu::BufferDescriptor {
+            label: Some("local"),
+            size: (MAX_BUNNIES as wgpu::BufferAddress) * wgpu::BIND_BUFFER_ALIGNMENT,
+            usage: wgpu::BufferUsage::COPY_DST | wgpu::BufferUsage::UNIFORM,
+            mapped_at_creation: false,
+        });
+
+        let view = texture.create_view(&wgpu::TextureViewDescriptor::default());
+        let global_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            layout: &global_bind_group_layout,
+            entries: &[
+                wgpu::BindGroupEntry {
+                    binding: 0,
+                    resource: global_buffer.as_entire_binding(),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 1,
+                    resource: wgpu::BindingResource::TextureView(&view),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 2,
+                    resource: wgpu::BindingResource::Sampler(&sampler),
+                },
+            ],
+            label: None,
+        });
+        let local_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            layout: &local_bind_group_layout,
+            entries: &[wgpu::BindGroupEntry {
+                binding: 0,
+                resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
+                    buffer: &local_buffer,
+                    offset: 0,
+                    size: wgpu::BufferSize::new(mem::size_of::<Locals>() as _),
+                }),
+            }],
+            label: None,
+        });
+
+        Example {
+            pipeline,
+            global_group,
+            local_group,
+            bunnies: Vec::new(),
+            local_buffer,
+            extent: [sc_desc.width, sc_desc.height],
+        }
+    }
+
+    /// update is called for any WindowEvent not handled by the framework
+    fn update(&mut self, event: winit::event::WindowEvent) {
+        if let winit::event::WindowEvent::KeyboardInput {
+            input:
+                winit::event::KeyboardInput {
+                    virtual_keycode: Some(winit::event::VirtualKeyCode::Space),
+                    state: winit::event::ElementState::Pressed,
+                    ..
+                },
+            ..
+        } = event
+        {
+            let spawn_count = 64 + self.bunnies.len() / 2;
+            let color = rand::random::<u32>();
+            println!(
+                "Spawning {} bunnies, total at {}",
+                spawn_count,
+                self.bunnies.len() + spawn_count
+            );
+            for _ in 0..spawn_count {
+                let speed = rand::random::<f32>() * MAX_VELOCITY - (MAX_VELOCITY * 0.5);
+                self.bunnies.push(Locals {
+                    position: [0.0, 0.5 * (self.extent[1] as f32)],
+                    velocity: [speed, 0.0],
+                    color,
+                    _pad: 0,
+                });
+            }
+        }
+    }
+
+    /// resize is called on WindowEvent::Resized events
+    fn resize(
+        &mut self,
+        _sc_desc: &wgpu::SwapChainDescriptor,
+        _device: &wgpu::Device,
+        _queue: &wgpu::Queue,
+    ) {
+        //empty
+    }
+
+    /// render is called each frame, dispatching compute groups proportional
+    ///   a TriangleList draw call for all NUM_PARTICLES at 3 vertices each
+    fn render(
+        &mut self,
+        frame: &wgpu::SwapChainTexture,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        _spawner: &framework::Spawner,
+    ) {
+        let delta = 0.01;
+        for bunny in self.bunnies.iter_mut() {
+            bunny.position[0] += bunny.velocity[0] * delta;
+            bunny.position[1] += bunny.velocity[1] * delta;
+            bunny.velocity[1] += GRAVITY * delta;
+            if (bunny.velocity[0] > 0.0
+                && bunny.position[0] + 0.5 * BUNNY_SIZE > self.extent[0] as f32)
+                || (bunny.velocity[0] < 0.0 && bunny.position[0] - 0.5 * BUNNY_SIZE < 0.0)
+            {
+                bunny.velocity[0] *= -1.0;
+            }
+            if bunny.velocity[1] < 0.0 && bunny.position[1] < 0.5 * BUNNY_SIZE {
+                bunny.velocity[1] *= -1.0;
+            }
+        }
+
+        queue.write_buffer(&self.local_buffer, 0, unsafe {
+            std::slice::from_raw_parts(
+                self.bunnies.as_ptr() as *const u8,
+                self.bunnies.len() * wgpu::BIND_BUFFER_ALIGNMENT as usize,
+            )
+        });
+
+        let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
+        {
+            let clear_color = wgpu::Color {
+                r: 0.1,
+                g: 0.2,
+                b: 0.3,
+                a: 1.0,
+            };
+            let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                label: None,
+                color_attachments: &[wgpu::RenderPassColorAttachment {
+                    view: &frame.view,
+                    resolve_target: None,
+                    ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(clear_color),
+                        store: true,
+                    },
+                }],
+                depth_stencil_attachment: None,
+            });
+            rpass.set_pipeline(&self.pipeline);
+            rpass.set_bind_group(0, &self.global_group, &[]);
+            for i in 0..self.bunnies.len() {
+                let offset = (i as wgpu::DynamicOffset)
+                    * (wgpu::BIND_BUFFER_ALIGNMENT as wgpu::DynamicOffset);
+                rpass.set_bind_group(1, &self.local_group, &[offset]);
+                rpass.draw(0..4, 0..1);
+            }
+        }
+
+        queue.submit(Some(encoder.finish()));
+    }
+}
+
+fn main() {
+    framework::run::<Example>("bunnymark");
+}
diff --git a/wgpu/examples/bunnymark/shader.wgsl b/wgpu/examples/bunnymark/shader.wgsl
new file mode 100644
index 0000000000..b8639d1ca3
--- /dev/null
+++ b/wgpu/examples/bunnymark/shader.wgsl
@@ -0,0 +1,43 @@
+[[block]]
+struct Globals {
+    mvp: mat4x4<f32>;
+    size: vec2<f32>;
+};
+
+[[block]]
+struct Locals {
+    position: vec2<f32>;
+    velocity: vec2<f32>;
+    color: u32;
+};
+
+[[group(0), binding(0)]]
+var<uniform> globals: Globals;
+
+[[group(1), binding(0)]]
+var<uniform> locals: Locals;
+
+struct VertexOutput {
+    [[builtin(position)]] position: vec4<f32>;
+    [[location(0)]] tex_coords: vec2<f32>;
+    [[location(1)]] color: vec4<f32>;
+};
+
+[[stage(vertex)]]
+fn vs_main([[builtin(vertex_index)]] vi: u32) -> VertexOutput {
+    let tc = vec2<f32>(f32(vi & 1u), 0.5 * f32(vi & 2u));
+    let offset = vec2<f32>(tc.x * globals.size.x, tc.y * globals.size.y);
+    let pos = globals.mvp * vec4<f32>(locals.position + offset, 0.0, 1.0);
+    let color = vec4<f32>((vec4<u32>(locals.color) >> vec4<u32>(0u, 8u, 16u, 24u)) & vec4<u32>(255u)) / 255.0;
+    return VertexOutput(pos, tc, color);
+}
+
+[[group(0), binding(1)]]
+var texture: texture_2d<f32>;
+[[group(0), binding(2)]]
+var sampler: sampler;
+
+[[stage(fragment)]]
+fn fs_main(in: VertexOutput) -> [[location(0)]] vec4<f32> {
+    return in.color * textureSampleLevel(texture, sampler, in.tex_coords, 0.0);
+}