diff --git a/src/bin/wireframe/camera.rs b/src/bin/wireframe/camera.rs new file mode 100644 index 0000000..1c2c2b8 --- /dev/null +++ b/src/bin/wireframe/camera.rs @@ -0,0 +1,123 @@ +use std::mem; + +use glam::{mat4, vec3, vec4, Mat4, Vec2, Vec3}; + +#[repr(C)] +#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)] +struct CameraUniform { + mvp: [[f32; 4]; 4], + scale: [f32; 2], + pad: [u32; 2], +} + +pub struct Camera { + buf: wgpu::Buffer, + bind: wgpu::BindGroup, + layout: wgpu::BindGroupLayout, +} + +impl Camera { + pub fn new(device: &wgpu::Device) -> Camera { + let buf = device.create_buffer(&wgpu::BufferDescriptor { + label: Some("Camera Buffer"), + usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, + size: mem::size_of::() as u64, + mapped_at_creation: false, + }); + let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { + entries: &[wgpu::BindGroupLayoutEntry { + binding: 0, + visibility: wgpu::ShaderStages::VERTEX, + ty: wgpu::BindingType::Buffer { + ty: wgpu::BufferBindingType::Uniform, + has_dynamic_offset: false, + min_binding_size: None, + }, + count: None, + }], + label: Some("Camera BindGroupLayout"), + }); + let bind = device.create_bind_group(&wgpu::BindGroupDescriptor { + layout: &layout, + entries: &[wgpu::BindGroupEntry { + binding: 0, + resource: buf.as_entire_binding(), + }], + label: Some("Camera BindGroup"), + }); + Camera { buf, bind, layout } + } + + pub fn bind_group_layout(&self) -> &wgpu::BindGroupLayout { + &self.layout + } + + pub fn bind_group(&self) -> &wgpu::BindGroup { + &self.bind + } + + fn uniform(view_mtx: Mat4, view_size: Vec2) -> CameraUniform { + const M: Mat4 = mat4( + vec4(0., 0., 1., 0.), + vec4(-1., 0., 0., 0.), + vec4(0., 1., 0., 0.), + vec4(0., 0., 0., 1.), + ); + let size = view_size.normalize() * std::f32::consts::SQRT_2; + let proj = make_proj_matrix(vec3(size.x, size.y, 2.), (1., 4096.)) * M; + + let mvp = proj * view_mtx; + CameraUniform { + mvp: mvp.to_cols_array_2d(), + scale: (1. / size).to_array(), + pad: [0; 2], + } + } + + pub fn set(&self, queue: &wgpu::Queue, view_mtx: Mat4, view_size: Vec2) { + let uniform = Self::uniform(view_mtx, view_size); + queue.write_buffer(&self.buf, 0, bytemuck::bytes_of(&uniform)); + } +} + +/// Make a projection matrix, assuming input coordinates are (right, up, forward). +/// +/// `corner` is a vector that will be mapped to (x=1, y=1) after the perspective division. +/// `zrange` is the Z range that will be mapped to z∈[-1, 1]. It has no other effect. Both ends have to be positive though. +fn make_proj_matrix(corner: Vec3, zrange: (f32, f32)) -> Mat4 { + let scale = 1.0 / corner; + let zspan = zrange.1 - zrange.0; + mat4( + scale.x * vec4(1., 0., 0., 0.), + scale.y * vec4(0., 1., 0., 0.), + scale.z * vec4(0., 0., (zrange.0 + zrange.1) / zspan, 1.), + scale.z * vec4(0., 0., -2. * zrange.0 * zrange.1 / zspan, 0.), + ) +} + +#[cfg(test)] +mod tests { + use super::*; + use approx::assert_abs_diff_eq; + use glam::vec3; + + #[test] + fn test_proj_matrix() { + let m = make_proj_matrix(vec3(2., 3., 4.), (0.5, 20.0)); + + let v = m * vec4(2., 3., 4., 1.); + assert_abs_diff_eq!(v.x / v.w, 1.0); + assert_abs_diff_eq!(v.y / v.w, 1.0); + assert!(-v.w < v.z && v.z < v.w, "z out of range in {v}"); + + let v = m * vec4(2., 3., 0.5, 1.); + assert_abs_diff_eq!(v.x / v.w, 8.0); + assert_abs_diff_eq!(v.y / v.w, 8.0); + assert_abs_diff_eq!(v.z / v.w, -1.0); + + let v = m * vec4(2., 3., 20.0, 1.); + assert_abs_diff_eq!(v.x / v.w, 0.2); + assert_abs_diff_eq!(v.y / v.w, 0.2); + assert_abs_diff_eq!(v.z / v.w, 1.0); + } +} diff --git a/src/bin/wireframe/main.rs b/src/bin/wireframe/main.rs index b4ede44..01b7e3f 100644 --- a/src/bin/wireframe/main.rs +++ b/src/bin/wireframe/main.rs @@ -1,6 +1,6 @@ use std::{iter, mem, time::Instant}; -use glam::{mat4, vec2, vec3, vec4, Mat4, Vec3}; +use glam::{vec2, vec3, Vec3}; use wgpu::{util::DeviceExt, ShaderStages}; use winit::{ event::*, @@ -9,6 +9,7 @@ use winit::{ window::{Window, WindowBuilder}, }; +mod camera; mod scene; // The coordinate system: @@ -140,14 +141,6 @@ static KEYS_ROTATE: &'static [(PhysicalKey, Vec3)] = &[ (PhysicalKey::Code(KeyCode::Numpad6), vec3(0., 0., -1.)), ]; -#[repr(C)] -#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)] -struct CameraUniform { - mvp: [[f32; 4]; 4], - scale: [f32; 2], - pad: [u32; 2], -} - #[repr(C)] #[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)] struct LineUniform { @@ -164,11 +157,10 @@ struct State<'a> { render_pipeline: wgpu::RenderPipeline, kbd: keyctl::Keyboard, - cam: camctl::CameraLocation, t1: Instant, - camera_buffer: wgpu::Buffer, - camera_bind_group: wgpu::BindGroup, + cam_loc: camctl::CameraLocation, + cam_obj: camera::Camera, scene: Vec, @@ -227,37 +219,10 @@ impl<'a> State<'a> { }; let kbd = keyctl::Keyboard::new(); - let cam = camctl::CameraLocation::new(); + let cam_loc = camctl::CameraLocation::new(); let t1 = Instant::now(); - let camera_buffer = device.create_buffer(&wgpu::BufferDescriptor { - label: Some("Camera Buffer"), - usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, - size: mem::size_of::() as u64, - mapped_at_creation: false, - }); - let camera_bind_group_layout = - device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { - entries: &[wgpu::BindGroupLayoutEntry { - binding: 0, - visibility: wgpu::ShaderStages::VERTEX, - ty: wgpu::BindingType::Buffer { - ty: wgpu::BufferBindingType::Uniform, - has_dynamic_offset: false, - min_binding_size: None, - }, - count: None, - }], - label: Some("camera_bind_group_layout"), - }); - let camera_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor { - layout: &camera_bind_group_layout, - entries: &[wgpu::BindGroupEntry { - binding: 0, - resource: camera_buffer.as_entire_binding(), - }], - label: Some("camera_bind_group"), - }); + let cam_obj = camera::Camera::new(&device); let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some("Shader"), @@ -272,7 +237,7 @@ impl<'a> State<'a> { let render_pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { label: Some("Render Pipeline Layout"), - bind_group_layouts: &[&camera_bind_group_layout], + bind_group_layouts: &[cam_obj.bind_group_layout()], push_constant_ranges: &[line_push_constant_range], }); @@ -349,11 +314,10 @@ impl<'a> State<'a> { size, render_pipeline, kbd, - cam, + cam_loc, + cam_obj, t1, scene, - camera_buffer, - camera_bind_group, window, } } @@ -378,29 +342,13 @@ impl<'a> State<'a> { self.t1 = t2; dt.as_secs_f32() }; - self.cam.move_rel(100. * dt * self.kbd.control(&KEYS_MOVE)); - self.cam - .rotate_rel_ypr(2. * dt * self.kbd.control(&KEYS_ROTATE)); - let size = vec2(self.config.width as f32, self.config.height as f32); - let size = size.normalize() * std::f32::consts::SQRT_2; - let proj = make_proj_matrix(vec3(size.x, size.y, 2.), (1., 4096.)); - let my_to_gl = mat4( - vec4(0., 0., 1., 0.), - vec4(-1., 0., 0., 0.), - vec4(0., 1., 0., 0.), - vec4(0., 0., 0., 1.), - ); - let view = my_to_gl * self.cam.view_mtx(); - let mvp = proj * view; - let camera_uniform = CameraUniform { - mvp: mvp.to_cols_array_2d(), - scale: (1. / size).to_array(), - pad: [0; 2], - }; - self.queue - .write_buffer(&self.camera_buffer, 0, bytemuck::bytes_of(&camera_uniform)); + self.cam_loc + .move_rel(100. * dt * self.kbd.control(&KEYS_MOVE)); + self.cam_loc + .rotate_rel_ypr(2. * dt * self.kbd.control(&KEYS_ROTATE)); + self.cam_obj.set(&self.queue, self.cam_loc.view_mtx(), size); } fn render(&mut self) -> Result<(), wgpu::SurfaceError> { @@ -437,7 +385,7 @@ impl<'a> State<'a> { }); render_pass.set_pipeline(&self.render_pipeline); - render_pass.set_bind_group(0, &self.camera_bind_group, &[]); + render_pass.set_bind_group(0, self.cam_obj.bind_group(), &[]); for wireframe in &self.scene { let line = LineUniform { color: wireframe.color.to_array(), @@ -526,45 +474,3 @@ pub async fn run() { fn main() { pollster::block_on(run()); } - -/// Make a projection matrix, assuming input coordinates are (right, up, forward). -/// -/// `corner` is a vector that will be mapped to (x=1, y=1) after the perspective division. -/// `zrange` is the Z range that will be mapped to z∈[-1, 1]. It has no other effect. Both ends have to be positive though. -fn make_proj_matrix(corner: Vec3, zrange: (f32, f32)) -> Mat4 { - let scale = 1.0 / corner; - let zspan = zrange.1 - zrange.0; - mat4( - scale.x * vec4(1., 0., 0., 0.), - scale.y * vec4(0., 1., 0., 0.), - scale.z * vec4(0., 0., (zrange.0 + zrange.1) / zspan, 1.), - scale.z * vec4(0., 0., -2. * zrange.0 * zrange.1 / zspan, 0.), - ) -} - -#[cfg(test)] -mod tests { - use super::*; - use approx::assert_abs_diff_eq; - use glam::vec3; - - #[test] - fn test_proj_matrix() { - let m = make_proj_matrix(vec3(2., 3., 4.), (0.5, 20.0)); - - let v = m * vec4(2., 3., 4., 1.); - assert_abs_diff_eq!(v.x / v.w, 1.0); - assert_abs_diff_eq!(v.y / v.w, 1.0); - assert!(-v.w < v.z && v.z < v.w, "z out of range in {v}"); - - let v = m * vec4(2., 3., 0.5, 1.); - assert_abs_diff_eq!(v.x / v.w, 8.0); - assert_abs_diff_eq!(v.y / v.w, 8.0); - assert_abs_diff_eq!(v.z / v.w, -1.0); - - let v = m * vec4(2., 3., 20.0, 1.); - assert_abs_diff_eq!(v.x / v.w, 0.2); - assert_abs_diff_eq!(v.y / v.w, 0.2); - assert_abs_diff_eq!(v.z / v.w, 1.0); - } -}