diff --git a/Cargo.lock b/Cargo.lock index a0aada0..d4e268f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -37,6 +37,21 @@ dependencies = [ "libc", ] +[[package]] +name = "anyhow" +version = "1.0.65" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "98161a4e3e2184da77bb14f02184cdd111e83bbbcc9979dfee3c44b9a85f5602" + +[[package]] +name = "approx" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f2a05fd1bd10b2527e20a2cd32d8873d115b8b39fe219ee25f42a8aca6ba278" +dependencies = [ + "num-traits", +] + [[package]] name = "arrayvec" version = "0.7.2" @@ -168,6 +183,16 @@ version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e" +[[package]] +name = "cgmath" +version = "0.18.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a98d30140e3296250832bbaaff83b27dcd6fa3cc70fb6f1f3e5c9c0023b5317" +dependencies = [ + "approx", + "num-traits", +] + [[package]] name = "cocoa" version = "0.24.0" @@ -1257,7 +1282,9 @@ checksum = "f1382d1f0a252c4bf97dc20d979a2fdd05b024acd7c2ed0f7595d7817666a157" name = "renderer" version = "0.1.0" dependencies = [ + "anyhow", "bytemuck", + "cgmath", "env_logger", "image", "log", diff --git a/Cargo.toml b/Cargo.toml index 26288d2..146d92c 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -13,3 +13,5 @@ wgpu = "0.13" pollster = "0.2" bytemuck = { version = "1.4", features = [ "derive" ] } image = { version = "0.24", features = [ "png" ] } +anyhow = "1.0" +cgmath = "0.18" diff --git a/src/core/camera.rs b/src/core/camera.rs new file mode 100644 index 0000000..f325fa7 --- /dev/null +++ b/src/core/camera.rs @@ -0,0 +1,236 @@ +use std::time::Duration; + +use cgmath::num_traits::clamp; +use winit::event::*; + +pub struct Camera { + pub position: cgmath::Point3, + pub pitch: f32, + pub yaw: f32, + pub projection: Projection, +} + +pub struct Projection { + pub aspect: f32, + pub fovy: f32, + pub znear: f32, + pub zfar: f32, +} + +impl Projection { + pub fn resize(&mut self, width: u32, height: u32) { + self.aspect = width as f32 / height as f32; + } + + pub fn get_matrix(&self) -> cgmath::Matrix4 { + return cgmath::perspective(cgmath::Deg(self.fovy), self.aspect, self.znear, self.zfar); + } +} + +impl Camera { + pub fn new( + position: cgmath::Point3, + pitch: f32, + yaw: f32, + fovy: f32, + aspect: f32, + ) -> Self { + Self { + position: position, + pitch: pitch, + yaw: yaw, + projection: Projection { + aspect: aspect, + fovy: fovy, + znear: 0.01, + zfar: 1000.0, + }, + } + } + + pub fn get_view_matrix(&self) -> cgmath::Matrix4 { + let (forward, _right, up) = self.get_vecs(); + return cgmath::Matrix4::look_to_rh(self.position, forward, up); + } + + pub fn build_view_projection_matrix(&self) -> cgmath::Matrix4 { + let view = self.get_view_matrix(); + let proj = self.projection.get_matrix(); + return proj * view; + } + + pub fn get_vecs( + &self, + ) -> ( + cgmath::Vector3, + cgmath::Vector3, + cgmath::Vector3, + ) { + use cgmath::InnerSpace; + let (yaw_sin, yaw_cos) = cgmath::Rad::from(cgmath::Deg(self.yaw)).0.sin_cos(); + let (pitch_sin, pitch_cos) = cgmath::Rad::from(cgmath::Deg(self.pitch)).0.sin_cos(); + let forward = + cgmath::Vector3::new(pitch_cos * yaw_cos, pitch_sin, pitch_cos * yaw_sin).normalize(); + let right = cgmath::Vector3::new(-yaw_sin, 0.0, yaw_cos).normalize(); + let up = forward.cross(right); + return (forward, right, up); + } + + pub fn update(&mut self, dt: Duration, controller: &CameraController) { + let dt = dt.as_secs_f32(); + self.pitch = clamp( + self.pitch + controller.deltay * controller.sensitivity * 0.022, + -89.0, + 89.0, + ); + self.yaw -= controller.deltax * controller.sensitivity * 0.022; + self.yaw = self.yaw % 360.0; + if self.yaw < 0.0 { + self.yaw = 360.0 + self.yaw; + } + println!( + "pitch: {:.6}, yaw: {:.6}, dt: {:.6}", + self.pitch, self.yaw, dt + ); + + let (forward, right, up) = self.get_vecs(); + self.position += + forward * (controller.move_forward - controller.move_backward) * controller.speed * dt; + // FIXME -right + self.position += + -right * (controller.move_right - controller.move_left) * controller.speed * dt; + self.position += up * (controller.move_up - controller.move_down) * controller.speed * dt; + } +} + +#[repr(C)] +#[derive(Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)] +pub struct CameraUniform { + pub view_proj: [[f32; 4]; 4], +} + +impl CameraUniform { + pub fn new() -> Self { + use cgmath::SquareMatrix; + Self { + view_proj: cgmath::Matrix4::identity().into(), + } + } + + pub fn update_view_proj(&mut self, camera: &Camera) { + self.view_proj = camera.build_view_projection_matrix().into(); + } +} + +pub struct CameraController { + pub speed: f32, + pub sensitivity: f32, + pub move_forward: f32, + pub move_backward: f32, + pub move_left: f32, + pub move_right: f32, + pub move_up: f32, + pub move_down: f32, + pub deltax: f32, + pub deltay: f32, +} + +impl CameraController { + pub fn new(speed: f32, sensitivity: f32) -> Self { + Self { + speed, + sensitivity, + move_forward: 0.0, + move_backward: 0.0, + move_left: 0.0, + move_right: 0.0, + move_up: 0.0, + move_down: 0.0, + deltax: 0.0, + deltay: 0.0, + } + } + + pub fn reset(&mut self, held_keys: bool) { + if held_keys { + self.move_forward = 0.0; + self.move_backward = 0.0; + self.move_left = 0.0; + self.move_right = 0.0; + self.move_up = 0.0; + self.move_down = 0.0; + } + self.deltax = 0.0; + self.deltay = 0.0; + } + + pub fn process_events( + &mut self, + window_event: Option<&WindowEvent>, + device_event: Option<&DeviceEvent>, + ) -> bool { + let mut handled = match window_event { + None => false, + Some(event) => match event { + WindowEvent::KeyboardInput { + input: + KeyboardInput { + state, + virtual_keycode: Some(keycode), + .. + }, + .. + } => { + let is_pressed = *state == ElementState::Pressed; + let amount = if is_pressed { 1.0 } else { 0.0 }; + match keycode { + VirtualKeyCode::W | VirtualKeyCode::Up => { + self.move_forward = amount; + return true; + } + VirtualKeyCode::A | VirtualKeyCode::Left => { + self.move_left = amount; + return true; + } + VirtualKeyCode::S | VirtualKeyCode::Down => { + self.move_backward = amount; + return true; + } + VirtualKeyCode::D | VirtualKeyCode::Right => { + self.move_right = amount; + return true; + } + VirtualKeyCode::Space => { + self.move_up = amount; + return true; + } + VirtualKeyCode::LControl => { + self.move_down = amount; + return true; + } + _ => false, + } + } + _ => false, + }, + }; + + if handled { + return true; + } + + handled = match device_event { + None => false, + Some(event) => match event { + DeviceEvent::MouseMotion { delta } => { + self.deltax += delta.0 as f32; + self.deltay += delta.1 as f32; + return true; + } + _ => false, + }, + }; + + return handled; + } +} diff --git a/src/core/instance.rs b/src/core/instance.rs new file mode 100644 index 0000000..0f14037 --- /dev/null +++ b/src/core/instance.rs @@ -0,0 +1,60 @@ +pub struct Instance { + pub position: cgmath::Vector3, + pub rotation: cgmath::Quaternion, +} + +#[repr(C)] +#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)] +pub struct InstanceRaw { + pub model: [[f32; 4]; 4], +} + +impl Instance { + pub fn to_raw(&self) -> InstanceRaw { + return InstanceRaw { + model: (cgmath::Matrix4::from_translation(self.position) + * cgmath::Matrix4::from(self.rotation)) + .into(), + }; + } +} + +impl InstanceRaw { + pub fn desc<'a>() -> wgpu::VertexBufferLayout<'a> { + use std::mem; + wgpu::VertexBufferLayout { + array_stride: mem::size_of::() as wgpu::BufferAddress, + // We need to switch from using a step mode of Vertex to Instance + // This means that our shaders will only change to use the next + // instance when the shader starts processing a new instance + step_mode: wgpu::VertexStepMode::Instance, + attributes: &[ + wgpu::VertexAttribute { + offset: 0, + // While our vertex shader only uses locations 0, and 1 now, in later tutorials we'll + // be using 2, 3, and 4, for Vertex. We'll start at slot 5 not conflict with them later + shader_location: 5, + format: wgpu::VertexFormat::Float32x4, + }, + // A mat4 takes up 4 vertex slots as it is technically 4 vec4s. We need to define a slot + // for each vec4. We'll have to reassemble the mat4 in + // the shader. + wgpu::VertexAttribute { + offset: mem::size_of::<[f32; 4]>() as wgpu::BufferAddress, + shader_location: 6, + format: wgpu::VertexFormat::Float32x4, + }, + wgpu::VertexAttribute { + offset: mem::size_of::<[f32; 8]>() as wgpu::BufferAddress, + shader_location: 7, + format: wgpu::VertexFormat::Float32x4, + }, + wgpu::VertexAttribute { + offset: mem::size_of::<[f32; 12]>() as wgpu::BufferAddress, + shader_location: 8, + format: wgpu::VertexFormat::Float32x4, + }, + ], + } + } +} diff --git a/src/core/mod.rs b/src/core/mod.rs new file mode 100644 index 0000000..c2b1e43 --- /dev/null +++ b/src/core/mod.rs @@ -0,0 +1,6 @@ +pub mod camera; +pub mod instance; +pub mod state; +pub mod texture; +pub mod updater; +pub mod vertex; diff --git a/src/surf/state.rs b/src/core/state.rs similarity index 61% rename from src/surf/state.rs rename to src/core/state.rs index e6bad35..b803435 100644 --- a/src/surf/state.rs +++ b/src/core/state.rs @@ -1,17 +1,44 @@ +use cgmath::prelude::*; +use std::time::Duration; + use wgpu::{include_wgsl, util::DeviceExt}; use winit::{event::*, window::Window}; -use super::types::Vertex; +use super::camera::{Camera, CameraController, CameraUniform}; +use super::instance::{Instance, InstanceRaw}; +use super::texture::Texture; +use super::vertex::Vertex; // test data const VERTICES: &[Vertex] = &[ - Vertex { position: [-0.0868241, 0.49240386, 0.0], tex_coords: [0.4131759, 0.99240386], }, // A - Vertex { position: [-0.49513406, 0.06958647, 0.0], tex_coords: [0.0048659444, 0.56958647], }, // B - Vertex { position: [-0.21918549, -0.44939706, 0.0], tex_coords: [0.28081453, 0.05060294], }, // C - Vertex { position: [0.35966998, -0.3473291, 0.0], tex_coords: [0.85967, 0.1526709], }, // D - Vertex { position: [0.44147372, 0.2347359, 0.0], tex_coords: [0.9414737, 0.7347359], }, // E + Vertex { + position: [-0.0868241, 0.49240386, 0.0], + tex_coords: [0.4131759, 0.99240386], + }, // A + Vertex { + position: [-0.49513406, 0.06958647, 0.0], + tex_coords: [0.0048659444, 0.56958647], + }, // B + Vertex { + position: [-0.21918549, -0.44939706, 0.0], + tex_coords: [0.28081453, 0.05060294], + }, // C + Vertex { + position: [0.35966998, -0.3473291, 0.0], + tex_coords: [0.85967, 0.1526709], + }, // D + Vertex { + position: [0.44147372, 0.2347359, 0.0], + tex_coords: [0.9414737, 0.7347359], + }, // E ]; const INDICES: &[u16] = &[0, 1, 4, 1, 2, 4, 2, 3, 4]; +const NUM_INSTANCES_PER_ROW: u32 = 10; +const INSTANCE_DISPLACEMENT: cgmath::Vector3 = cgmath::Vector3::new( + NUM_INSTANCES_PER_ROW as f32 * 0.5, + 0.0, + NUM_INSTANCES_PER_ROW as f32 * 0.5, +); pub struct State { pub size: winit::dpi::PhysicalSize, @@ -25,6 +52,13 @@ pub struct State { index_buffer: wgpu::Buffer, num_indices: u32, diffuse_bind_group: wgpu::BindGroup, + camera: Camera, + camera_uniform: CameraUniform, + camera_buffer: wgpu::Buffer, + camera_bind_group: wgpu::BindGroup, + camera_controller: CameraController, + instances: Vec, + instance_buffer: wgpu::Buffer, } impl State { @@ -65,60 +99,54 @@ impl State { surface.configure(&device, &config); - // Test image - let diffuse_bytes = include_bytes!("../../assets/test.png"); - let diffuse_image = image::load_from_memory(diffuse_bytes).unwrap(); - let diffuse_rgba = diffuse_image.to_rgba8(); - use image::GenericImageView; - let dimensions = diffuse_image.dimensions(); - let texture_size = wgpu::Extent3d { - width: dimensions.0, - height: dimensions.1, - depth_or_array_layers: 1, - }; - let diffuse_texture = device.create_texture(&wgpu::TextureDescriptor { - // All textures are stored as 3D, we represent our 2D texture - // by setting depth to 1. - size: texture_size, - mip_level_count: 1, // We'll talk about this a little later - sample_count: 1, - dimension: wgpu::TextureDimension::D2, - // Most images are stored using sRGB so we need to reflect that here. - format: wgpu::TextureFormat::Rgba8UnormSrgb, - // TEXTURE_BINDING tells wgpu that we want to use this texture in shaders - // COPY_DST means that we want to copy data to this texture - usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, - label: Some("diffuse_texture"), - }); - queue.write_texture( - // Tells wgpu where to copy the pixel data - wgpu::ImageCopyTexture { - texture: &diffuse_texture, - mip_level: 0, - origin: wgpu::Origin3d::ZERO, - aspect: wgpu::TextureAspect::All, - }, - // The actual pixel data - &diffuse_rgba, - // The layout of the texture - wgpu::ImageDataLayout { - offset: 0, - bytes_per_row: std::num::NonZeroU32::new(4 * dimensions.0), - rows_per_image: std::num::NonZeroU32::new(dimensions.1), - }, - texture_size, + // Camera + let camera = Camera::new( + (0.0, 0.0, 0.0).into(), + 0.0, + 0.0, + 60.0, + config.width as f32 / config.height as f32, ); - let diffuse_texture_view = - diffuse_texture.create_view(&wgpu::TextureViewDescriptor::default()); - let diffuse_sampler = device.create_sampler(&wgpu::SamplerDescriptor { - address_mode_u: wgpu::AddressMode::Repeat, - address_mode_v: wgpu::AddressMode::Repeat, - address_mode_w: wgpu::AddressMode::Repeat, - mag_filter: wgpu::FilterMode::Linear, - min_filter: wgpu::FilterMode::Linear, - mipmap_filter: wgpu::FilterMode::Linear, - ..Default::default() + + let mut camera_uniform = CameraUniform::new(); + camera_uniform.update_view_proj(&camera); + + let camera_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor { + label: Some("Camera Buffer"), + contents: bytemuck::cast_slice(&[camera_uniform]), + usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, }); + 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 camera_controller = CameraController::new(1.0, 2.0); + + // Test image + surface.configure(&device, &config); + let diffuse_bytes = include_bytes!("../../assets/test.png"); + let diffuse_texture = + Texture::from_bytes(&device, &queue, diffuse_bytes, "../../assets/test.png").unwrap(); + let texture_bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { entries: &[ @@ -148,16 +176,47 @@ impl State { entries: &[ wgpu::BindGroupEntry { binding: 0, - resource: wgpu::BindingResource::TextureView(&diffuse_texture_view), + resource: wgpu::BindingResource::TextureView(&diffuse_texture.view), }, wgpu::BindGroupEntry { binding: 1, - resource: wgpu::BindingResource::Sampler(&diffuse_sampler), + resource: wgpu::BindingResource::Sampler(&diffuse_texture.sampler), }, ], label: Some("diffuse_bind_group"), }); + let instances = (0..NUM_INSTANCES_PER_ROW) + .flat_map(|z| { + (0..NUM_INSTANCES_PER_ROW).map(move |x| { + let position = cgmath::Vector3 { + x: x as f32, + y: 0.0, + z: z as f32, + } - INSTANCE_DISPLACEMENT; + + let rotation = if position.is_zero() { + // this is needed so an object at (0, 0, 0) won't get scaled to zero + // as Quaternions can effect scale if they're not created correctly + cgmath::Quaternion::from_axis_angle( + cgmath::Vector3::unit_z(), + cgmath::Deg(0.0), + ) + } else { + cgmath::Quaternion::from_axis_angle(position.normalize(), cgmath::Deg(45.0)) + }; + + Instance { position, rotation } + }) + }) + .collect::>(); + let instance_data = instances.iter().map(Instance::to_raw).collect::>(); + let instance_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor { + label: Some("Instance Buffer"), + contents: bytemuck::cast_slice(&instance_data), + usage: wgpu::BufferUsages::VERTEX, + }); + // let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor { // label: Some("Shader"), // source: wgpu::ShaderSource::Wgsl(include_str!("../shaders/test.wgsl").into()), @@ -167,7 +226,7 @@ impl State { let render_pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { label: Some("Render Pipeline Layout"), - bind_group_layouts: &[&texture_bind_group_layout], + bind_group_layouts: &[&texture_bind_group_layout, &camera_bind_group_layout], push_constant_ranges: &[], }); @@ -177,7 +236,7 @@ impl State { vertex: wgpu::VertexState { module: &shader, entry_point: "vs_main", - buffers: &[Vertex::desc()], + buffers: &[Vertex::desc(), InstanceRaw::desc()], }, fragment: Some(wgpu::FragmentState { // 3. @@ -234,6 +293,13 @@ impl State { index_buffer, num_indices, diffuse_bind_group, + camera, + camera_uniform, + camera_buffer, + camera_bind_group, + camera_controller, + instances, + instance_buffer, }; } @@ -243,14 +309,32 @@ impl State { self.config.width = new_size.width; self.config.height = new_size.height; self.surface.configure(&self.device, &self.config); + self.camera + .projection + .resize(new_size.width, new_size.height); } } - pub fn input(&mut self, event: &WindowEvent) -> bool { - return false; + pub fn input( + &mut self, + window_event: Option<&WindowEvent>, + device_event: Option<&DeviceEvent>, + ) -> bool { + return self + .camera_controller + .process_events(window_event, device_event); } - pub fn update(&mut self) {} + pub fn update(&mut self, dt: Duration) { + self.camera.update(dt, &self.camera_controller); + self.camera_controller.reset(false); + self.camera_uniform.update_view_proj(&self.camera); + self.queue.write_buffer( + &self.camera_buffer, + 0, + bytemuck::cast_slice(&[self.camera_uniform]), + ); + } pub fn render(&mut self) -> Result<(), wgpu::SurfaceError> { let output = self.surface.get_current_texture()?; @@ -286,10 +370,15 @@ impl State { }); render_pass.set_pipeline(&self.render_pipeline); + render_pass.set_bind_group(0, &self.diffuse_bind_group, &[]); + render_pass.set_bind_group(1, &self.camera_bind_group, &[]); + render_pass.set_vertex_buffer(0, self.vertex_buffer.slice(..)); + render_pass.set_vertex_buffer(1, self.instance_buffer.slice(..)); render_pass.set_index_buffer(self.index_buffer.slice(..), wgpu::IndexFormat::Uint16); - render_pass.draw_indexed(0..self.num_indices, 0, 0..1); + + render_pass.draw_indexed(0..self.num_indices, 0, 0..self.instances.len() as _); } // submit will accept anything that implements IntoIter diff --git a/src/core/texture.rs b/src/core/texture.rs new file mode 100644 index 0000000..6fa7832 --- /dev/null +++ b/src/core/texture.rs @@ -0,0 +1,78 @@ +use anyhow::*; +use image::GenericImageView; + +pub struct Texture { + pub texture: wgpu::Texture, + pub view: wgpu::TextureView, + pub sampler: wgpu::Sampler, +} + +impl Texture { + pub fn from_bytes( + device: &wgpu::Device, + queue: &wgpu::Queue, + bytes: &[u8], + label: &str, + ) -> Result { + let img = image::load_from_memory(bytes)?; + Self::from_image(device, queue, &img, Some(label)) + } + + pub fn from_image( + device: &wgpu::Device, + queue: &wgpu::Queue, + img: &image::DynamicImage, + label: Option<&str>, + ) -> Result { + let rgba = img.to_rgba8(); + let dimensions = img.dimensions(); + + let size = wgpu::Extent3d { + width: dimensions.0, + height: dimensions.1, + depth_or_array_layers: 1, + }; + let texture = device.create_texture(&wgpu::TextureDescriptor { + label, + size, + mip_level_count: 1, + sample_count: 1, + dimension: wgpu::TextureDimension::D2, + format: wgpu::TextureFormat::Rgba8UnormSrgb, + usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, + }); + + queue.write_texture( + wgpu::ImageCopyTexture { + aspect: wgpu::TextureAspect::All, + texture: &texture, + mip_level: 0, + origin: wgpu::Origin3d::ZERO, + }, + &rgba, + wgpu::ImageDataLayout { + offset: 0, + bytes_per_row: std::num::NonZeroU32::new(4 * dimensions.0), + rows_per_image: std::num::NonZeroU32::new(dimensions.1), + }, + size, + ); + + let view = texture.create_view(&wgpu::TextureViewDescriptor::default()); + let sampler = device.create_sampler(&wgpu::SamplerDescriptor { + 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() + }); + + return Ok(Self { + texture, + view, + sampler, + }); + } +} diff --git a/src/surf/updater.rs b/src/core/updater.rs similarity index 85% rename from src/surf/updater.rs rename to src/core/updater.rs index 19d9c57..0888d98 100644 --- a/src/surf/updater.rs +++ b/src/core/updater.rs @@ -1,3 +1,5 @@ +use std::time::Instant; + use super::state::State; use winit::{ event::*, @@ -9,16 +11,19 @@ pub async fn run() { let event_loop = EventLoop::new(); let window = WindowBuilder::new().build(&event_loop).unwrap(); let mut state = State::new(&window).await; + let mut last_render = Instant::now(); // Event loop event_loop.run(move |event, _, control_flow| { match event { + Event::DeviceEvent { ref event, .. } => { + state.input(None, Some(event)); + } Event::WindowEvent { ref event, window_id, } if window_id == window.id() => { - if !state.input(event) { - // UPDATED! + if !state.input(Some(event), None) { match event { WindowEvent::CloseRequested | WindowEvent::KeyboardInput { @@ -36,13 +41,15 @@ pub async fn run() { WindowEvent::ScaleFactorChanged { new_inner_size, .. } => { state.resize(**new_inner_size); } - WindowEvent::CursorMoved { position, .. } => {} _ => {} } } } Event::RedrawRequested(window_id) if window_id == window.id() => { - state.update(); + let now = Instant::now(); + let dt = now - last_render; + last_render = now; + state.update(dt); match state.render() { Ok(_) => {} // Reconfigure the surface if lost diff --git a/src/surf/types.rs b/src/core/vertex.rs similarity index 100% rename from src/surf/types.rs rename to src/core/vertex.rs diff --git a/src/main.rs b/src/main.rs index c350231..255f7fa 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,7 +1,6 @@ -mod surf; +mod core; fn main() { env_logger::init(); - pollster::block_on(surf::updater::run()); + pollster::block_on(core::updater::run()); } - diff --git a/src/shaders/test.wgsl b/src/shaders/test.wgsl index 047129c..f084274 100644 --- a/src/shaders/test.wgsl +++ b/src/shaders/test.wgsl @@ -1,5 +1,18 @@ +struct InstanceInput { + @location(5) model_matrix_0: vec4, + @location(6) model_matrix_1: vec4, + @location(7) model_matrix_2: vec4, + @location(8) model_matrix_3: vec4, +}; + // Vertex shader +struct CameraUniform { + view_proj: mat4x4, +}; +@group(1) @binding(0) +var camera: CameraUniform; + struct VertexInput { @location(0) position: vec3, @location(1) tex_coords: vec2, @@ -13,12 +26,19 @@ struct VertexOutput { @vertex fn vs_main( model: VertexInput, + instance: InstanceInput, ) -> VertexOutput { + let model_matrix = mat4x4( + instance.model_matrix_0, + instance.model_matrix_1, + instance.model_matrix_2, + instance.model_matrix_3, + ); var out: VertexOutput; out.tex_coords = model.tex_coords; - out.clip_position = vec4(model.position, 1.0); + out.clip_position = camera.view_proj * model_matrix * vec4(model.position, 1.0); return out; -} +} // Fragment shader diff --git a/src/surf/mod.rs b/src/surf/mod.rs deleted file mode 100644 index 9b5cf9c..0000000 --- a/src/surf/mod.rs +++ /dev/null @@ -1,3 +0,0 @@ -pub mod state; -pub mod updater; -pub mod types;