From 1ac26620112becaac87fc8f8c533e755b803de6b Mon Sep 17 00:00:00 2001 From: Werner <26710260+GuilhermeWerner@users.noreply.github.com> Date: Wed, 5 Jan 2022 09:41:22 -0300 Subject: [PATCH] Test custom types with cubes example --- Examples/Cubes.rs | 156 ++++++++++--------- Examples/Triangle.rs | 16 +- Source/Render/Instance.rs | 4 +- Source/Render/Model.rs | 35 +++-- Source/Render/Pipeline/PipelineDescriptor.rs | 1 - Source/Render/Renderer.rs | 11 +- Source/Render/mod.rs | 36 ++--- Source/Runtime.rs | 12 +- Source/Shader/Shader.rs | 4 +- Source/State.rs | 8 +- 10 files changed, 153 insertions(+), 130 deletions(-) diff --git a/Examples/Cubes.rs b/Examples/Cubes.rs index 6dbeb65..4d5c8ae 100644 --- a/Examples/Cubes.rs +++ b/Examples/Cubes.rs @@ -9,7 +9,7 @@ use wgpu::util::DeviceExt; use winit::event::*; use Graphics::Camera::*; use Graphics::Render::*; -use Graphics::{Display, Runtime, State}; +use Graphics::{Runtime, State}; struct Cubes { render_pipeline: wgpu::RenderPipeline, @@ -25,9 +25,9 @@ struct Cubes { } impl State for Cubes { - fn Init(display: &Display) -> Result { + fn Init(renderer: &mut Renderer) -> Result { let texture_bind_group_layout = - display + renderer .device .create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { entries: &[ @@ -60,7 +60,7 @@ impl State for Cubes { eye: (0.0, 5.0, -10.0).into(), target: (0.0, 0.0, 0.0).into(), up: cgmath::Vector3::unit_y(), - aspect: display.config.width as f32 / display.config.height as f32, + aspect: renderer.config.width as f32 / renderer.config.height as f32, fovy: 45.0, znear: 0.1, zfar: 100.0, @@ -71,7 +71,7 @@ impl State for Cubes { let mut camera_uniform = CameraUniform::New(); camera_uniform.UpdateViewProjection(&camera); - let camera_buffer = display + let camera_buffer = renderer .device .create_buffer_init(&wgpu::util::BufferInitDescriptor { label: Some("Camera Buffer"), @@ -104,7 +104,7 @@ impl State for Cubes { let instance_data = instances.iter().map(Instance::ToRaw).collect::>(); let instance_buffer = - display + renderer .device .create_buffer_init(&wgpu::util::BufferInitDescriptor { label: Some("Instance Buffer"), @@ -113,7 +113,7 @@ impl State for Cubes { }); let camera_bind_group_layout = - display + renderer .device .create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { entries: &[wgpu::BindGroupLayoutEntry { @@ -129,7 +129,7 @@ impl State for Cubes { label: Some("camera_bind_group_layout"), }); - let camera_bind_group = display + let camera_bind_group = renderer .device .create_bind_group(&wgpu::BindGroupDescriptor { layout: &camera_bind_group_layout, @@ -143,8 +143,8 @@ impl State for Cubes { // Model let obj_model = Model::Load( - &display.device, - &display.queue, + &renderer.device, + &renderer.queue, &texture_bind_group_layout, PathBuf::from("./Content/SM_Cube.obj"), ) @@ -152,7 +152,7 @@ impl State for Cubes { // Shader - let shader = display + let shader = renderer .device .create_shader_module(&wgpu::ShaderModuleDescriptor { label: Some("shader.wgsl"), @@ -162,12 +162,12 @@ impl State for Cubes { // Texture let depth_texture = - Texture::CreateDepthTexture(&display.device, &display.config, "depth_texture"); + Texture::CreateDepthTexture(&renderer.device, &renderer.config, "depth_texture"); // Pipeline let render_pipeline_layout = - display + renderer .device .create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { label: Some("Render Pipeline Layout"), @@ -175,54 +175,70 @@ impl State for Cubes { push_constant_ranges: &[], }); - let render_pipeline = - display - .device - .create_render_pipeline(&wgpu::RenderPipelineDescriptor { - label: Some("Render Pipeline"), - layout: Some(&render_pipeline_layout), - vertex: wgpu::VertexState { - module: &shader, - entry_point: "main", - buffers: &[ModelVertex::GetDescriptor(), InstanceRaw::GetDescriptor()], - }, - fragment: Some(wgpu::FragmentState { - module: &shader, - entry_point: "main", - targets: &[wgpu::ColorTargetState { - format: display.config.format, - blend: Some(wgpu::BlendState { - color: wgpu::BlendComponent::REPLACE, - alpha: wgpu::BlendComponent::REPLACE, - }), - write_mask: wgpu::ColorWrites::ALL, - }], - }), - primitive: wgpu::PrimitiveState { - topology: wgpu::PrimitiveTopology::TriangleList, - strip_index_format: None, - front_face: wgpu::FrontFace::Ccw, - cull_mode: Some(wgpu::Face::Back), - // Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE - polygon_mode: wgpu::PolygonMode::Fill, - // Requires Features::DEPTH_CLAMPING - clamp_depth: false, - // Requires Features::CONSERVATIVE_RASTERIZATION - conservative: false, - }, - depth_stencil: Some(wgpu::DepthStencilState { - format: Texture::DEPTH_FORMAT, - depth_write_enabled: true, - depth_compare: wgpu::CompareFunction::Less, - stencil: wgpu::StencilState::default(), - bias: wgpu::DepthBiasState::default(), - }), - multisample: wgpu::MultisampleState { - count: 1, - mask: !0, - alpha_to_coverage_enabled: false, - }, - }); + let render_pipeline = { + let mut layout = ModelVertex::GetLayout(); + + let attributes = layout + .attributes + .drain(..) + .map(|x| x.into()) + .collect::>(); + + let wgpu_layout = wgpu::VertexBufferLayout { + array_stride: layout.stride as wgpu::BufferAddress, + step_mode: layout.step_mode.into(), + attributes: attributes.as_ref(), + }; + + renderer + .device + .create_render_pipeline(&wgpu::RenderPipelineDescriptor { + label: Some("Render Pipeline"), + layout: Some(&render_pipeline_layout), + vertex: wgpu::VertexState { + module: &shader, + entry_point: "main", + buffers: &[wgpu_layout, InstanceRaw::GetLayout()], + }, + fragment: Some(wgpu::FragmentState { + module: &shader, + entry_point: "main", + targets: &[wgpu::ColorTargetState { + format: renderer.config.format, + blend: Some(wgpu::BlendState { + color: wgpu::BlendComponent::REPLACE, + alpha: wgpu::BlendComponent::REPLACE, + }), + write_mask: wgpu::ColorWrites::ALL, + }], + }), + primitive: wgpu::PrimitiveState { + topology: wgpu::PrimitiveTopology::TriangleList, + strip_index_format: None, + front_face: wgpu::FrontFace::Ccw, + cull_mode: Some(wgpu::Face::Back), + // Setting this to anything other than Fill requires Features::NON_FILL_POLYGON_MODE + polygon_mode: wgpu::PolygonMode::Fill, + // Requires Features::DEPTH_CLAMPING + clamp_depth: false, + // Requires Features::CONSERVATIVE_RASTERIZATION + conservative: false, + }, + depth_stencil: Some(wgpu::DepthStencilState { + format: Texture::DEPTH_FORMAT, + depth_write_enabled: true, + depth_compare: wgpu::CompareFunction::Less, + stencil: wgpu::StencilState::default(), + bias: wgpu::DepthBiasState::default(), + }), + multisample: wgpu::MultisampleState { + count: 1, + mask: !0, + alpha_to_coverage_enabled: false, + }, + }) + }; + Ok(Self { render_pipeline, @@ -238,32 +254,32 @@ impl State for Cubes { }) } - fn Input(&mut self, display: &Display, event: &WindowEvent) -> bool { + fn Input(&mut self, renderer: &mut Renderer, event: &WindowEvent) -> bool { self.camera_controller.ProcessEvents(event) } - fn Update(&mut self, display: &Display, delta: Duration) { + fn Update(&mut self, renderer: &mut Renderer, delta: Duration) { self.camera_controller.UpdateCamera(&mut self.camera); self.camera_uniform.UpdateViewProjection(&self.camera); - display.queue.write_buffer( + renderer.queue.write_buffer( &self.camera_buffer, 0, bytemuck::cast_slice(&[self.camera_uniform]), ); } - fn Resize(&mut self, display: &Display) { + fn Resize(&mut self, renderer: &mut Renderer) { self.depth_texture = - Texture::CreateDepthTexture(&display.device, &display.config, "depth_texture"); + Texture::CreateDepthTexture(&renderer.device, &renderer.config, "depth_texture"); } - fn Draw(&mut self, display: &mut Display) -> Result<(), wgpu::SurfaceError> { - let output = display.surface.get_current_texture().unwrap(); + fn Draw(&mut self, renderer: &mut Renderer) -> Result<(), wgpu::SurfaceError> { + let output = renderer.surface.get_current_texture().unwrap(); let view = output .texture .create_view(&wgpu::TextureViewDescriptor::default()); - let mut encoder = display + let mut encoder = renderer .device .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("Render Encoder"), @@ -304,7 +320,7 @@ impl State for Cubes { ); } - display.queue.submit(std::iter::once(encoder.finish())); + renderer.queue.submit(std::iter::once(encoder.finish())); output.present(); Ok(()) diff --git a/Examples/Triangle.rs b/Examples/Triangle.rs index 16aa4cd..ab33203 100644 --- a/Examples/Triangle.rs +++ b/Examples/Triangle.rs @@ -60,7 +60,7 @@ struct Triangle { } impl State for Triangle { - fn Init(renderer: &Renderer) -> Result { + fn Init(renderer: &mut Renderer) -> Result { // Shader let shader = Shader::FromWgsl(include_str!("../Shaders/Triangle.wgsl")); @@ -99,12 +99,12 @@ impl State for Triangle { label: Some("RENDER_PIPELINE"), layout: Some(&render_pipeline_layout), vertex: wgpu::VertexState { - module: &shader_module, + module: renderer.shaders.get("Wgsl").unwrap(), entry_point: "main", buffers: &[wgpu_layout], }, fragment: Some(wgpu::FragmentState { - module: &shader_module, + module: renderer.shaders.get("Wgsl").unwrap(), entry_point: "main", targets: &[wgpu::ColorTargetState { format: renderer.config.format, @@ -154,20 +154,20 @@ impl State for Triangle { }) } - fn Input(&mut self, renderer: &Renderer, event: &WindowEvent) -> bool { + fn Input(&mut self, renderer: &mut Renderer, event: &WindowEvent) -> bool { false } - fn Update(&mut self, renderer: &Renderer, delta: Duration) {} + fn Update(&mut self, renderer: &mut Renderer, delta: Duration) {} - fn Resize(&mut self, renderer: &Renderer) {} + fn Resize(&mut self, renderer: &mut Renderer) {} fn Draw(&mut self, renderer: &mut Renderer) -> Result<(), wgpu::SurfaceError> { renderer .Draw( &self.render_pipeline, - &self.vertex_buffer, - &self.index_buffer, + "Vertex Buffer", + "Index Buffer", self.num_indices, ) .unwrap(); diff --git a/Source/Render/Instance.rs b/Source/Render/Instance.rs index 398fcc6..fd33ff9 100644 --- a/Source/Render/Instance.rs +++ b/Source/Render/Instance.rs @@ -6,8 +6,8 @@ pub const NUM_INSTANCES: u32 = NUM_INSTANCES_PER_ROW * NUM_INSTANCES_PER_ROW; pub 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, + 0.0 ); pub struct Instance { @@ -32,7 +32,7 @@ pub struct InstanceRaw { } impl InstanceRaw { - pub fn GetDescriptor<'a>() -> wgpu::VertexBufferLayout<'a> { + pub fn GetLayout<'a>() -> wgpu::VertexBufferLayout<'a> { wgpu::VertexBufferLayout { array_stride: mem::size_of::() as wgpu::BufferAddress, // We need to switch from using a step mode of Vertex to Instance diff --git a/Source/Render/Model.rs b/Source/Render/Model.rs index 637e964..a9f41c9 100644 --- a/Source/Render/Model.rs +++ b/Source/Render/Model.rs @@ -1,5 +1,6 @@ -use super::Texture; -use super::{Material, Mesh, Vertex}; +use super::{ + Material, Mesh, StepMode, Texture, Vertex, VertexAttribute, VertexBufferLayout, VertexFormat, +}; use anyhow::Result; use bytemuck::{Pod, Zeroable}; use std::path::Path; @@ -112,26 +113,30 @@ pub struct ModelVertex { } impl Vertex for ModelVertex { - fn GetDescriptor<'a>() -> wgpu::VertexBufferLayout<'a> { + fn GetLayout() -> VertexBufferLayout { use std::mem; - wgpu::VertexBufferLayout { - array_stride: mem::size_of::() as wgpu::BufferAddress, - step_mode: wgpu::VertexStepMode::Vertex, - attributes: &[ - wgpu::VertexAttribute { + VertexBufferLayout { + label: "Model".into(), + stride: mem::size_of::(), + step_mode: StepMode::Vertex, + attributes: vec![ + VertexAttribute { + label: "Position".into(), + format: VertexFormat::Float32x3, offset: 0, shader_location: 0, - format: wgpu::VertexFormat::Float32x3, }, - wgpu::VertexAttribute { - offset: mem::size_of::<[f32; 3]>() as wgpu::BufferAddress, + VertexAttribute { + label: "Position".into(), shader_location: 1, - format: wgpu::VertexFormat::Float32x2, + offset: mem::size_of::<[f32; 3]>(), + format: VertexFormat::Float32x2, }, - wgpu::VertexAttribute { - offset: mem::size_of::<[f32; 5]>() as wgpu::BufferAddress, + VertexAttribute { + label: "Color".into(), shader_location: 2, - format: wgpu::VertexFormat::Float32x3, + offset: mem::size_of::<[f32; 5]>(), + format: VertexFormat::Float32x3, }, ], } diff --git a/Source/Render/Pipeline/PipelineDescriptor.rs b/Source/Render/Pipeline/PipelineDescriptor.rs index b3ed12a..18f2b81 100644 --- a/Source/Render/Pipeline/PipelineDescriptor.rs +++ b/Source/Render/Pipeline/PipelineDescriptor.rs @@ -5,5 +5,4 @@ pub struct PipelineDescriptor { pub label: Cow<'static, str>, pub layout: Option, pub shader_stages: String, - } diff --git a/Source/Render/Renderer.rs b/Source/Render/Renderer.rs index de7d346..1532c58 100644 --- a/Source/Render/Renderer.rs +++ b/Source/Render/Renderer.rs @@ -22,12 +22,12 @@ impl Renderer { pub async fn New(window: Window) -> Result { let size = window.inner_size(); - let instance = wgpu::Instance::new(wgpu::Backends::all()); + let instance = wgpu::Instance::new(wgpu::Backends::PRIMARY); let surface = unsafe { instance.create_surface(&window) }; let adapter = instance .request_adapter(&wgpu::RequestAdapterOptions { - power_preference: wgpu::PowerPreference::default(), + power_preference: wgpu::PowerPreference::HighPerformance, compatible_surface: Some(&surface), force_fallback_adapter: false, }) @@ -122,10 +122,13 @@ impl Renderer { pub fn Draw( &self, pipeline: &wgpu::RenderPipeline, - vertex_buffer: &wgpu::Buffer, - index_buffer: &wgpu::Buffer, + vertex_buffer: &str, + index_buffer: &str, num_indices: u32, ) -> Result<()> { + let vertex_buffer = self.vertex_buffers.get(vertex_buffer).unwrap(); + let index_buffer = self.index_buffers.get(index_buffer).unwrap(); + let output = self.surface.get_current_texture()?; let view = output diff --git a/Source/Render/mod.rs b/Source/Render/mod.rs index 5618a1d..c1ef553 100644 --- a/Source/Render/mod.rs +++ b/Source/Render/mod.rs @@ -1,24 +1,24 @@ pub mod Pipeline; -//#[path = "DrawModel.rs"] -//mod _DrawModel; -//pub use self::_DrawModel::*; +#[path = "DrawModel.rs"] +mod _DrawModel; +pub use self::_DrawModel::*; #[path = "IndexFormat.rs"] mod _IndexFormat; pub use self::_IndexFormat::*; -//#[path = "Instance.rs"] -//mod _Instance; -//pub use self::_Instance::*; +#[path = "Instance.rs"] +mod _Instance; +pub use self::_Instance::*; -//#[path = "Material.rs"] -//mod _Material; -//pub use self::_Material::*; +#[path = "Material.rs"] +mod _Material; +pub use self::_Material::*; -//#[path = "Model.rs"] -//mod _Model; -//pub use self::_Model::*; +#[path = "Model.rs"] +mod _Model; +pub use self::_Model::*; #[path = "Renderer.rs"] mod _Renderer; @@ -28,13 +28,13 @@ pub use self::_Renderer::*; mod _StepMode; pub use self::_StepMode::*; -//#[path = "Mesh.rs"] -//mod _Mesh; -//pub use self::_Mesh::*; +#[path = "Mesh.rs"] +mod _Mesh; +pub use self::_Mesh::*; -//#[path = "Texture.rs"] -//mod _Texture; -//pub use self::_Texture::*; +#[path = "Texture.rs"] +mod _Texture; +pub use self::_Texture::*; #[path = "Vertex.rs"] mod _Vertex; diff --git a/Source/Runtime.rs b/Source/Runtime.rs index 92026bb..b4be2ac 100644 --- a/Source/Runtime.rs +++ b/Source/Runtime.rs @@ -23,7 +23,7 @@ impl Runtime { let mut renderer = pollster::block_on(Renderer::New(window))?; - let mut app = T::Init(&renderer)?; + let mut app = T::Init(&mut renderer)?; let mut last_update = Instant::now(); @@ -47,7 +47,7 @@ impl Runtime { let delta = now - last_update; last_update = now; - app.Update(&renderer, delta); + app.Update(&mut renderer, delta); match app.Draw(&mut renderer) { Ok(_) => {} @@ -55,7 +55,7 @@ impl Runtime { Err(wgpu::SurfaceError::Lost) => { let size = renderer.window.inner_size(); renderer.Resize(size.width, size.height); - app.Resize(&renderer); + app.Resize(&mut renderer); } // The system is out of memory, we should probably quit Err(wgpu::SurfaceError::OutOfMemory) => { @@ -78,7 +78,7 @@ impl Runtime { } } Event::WindowEvent { event, window_id } if window_id == renderer.window.id() => { - if !app.Input(&renderer, &event) { + if !app.Input(&mut renderer, &event) { match event { WindowEvent::CloseRequested | WindowEvent::KeyboardInput { @@ -93,11 +93,11 @@ impl Runtime { WindowEvent::Focused(focused) => is_focused = focused, WindowEvent::ScaleFactorChanged { new_inner_size, .. } => { renderer.Resize(new_inner_size.width, new_inner_size.height); - app.Resize(&renderer); + app.Resize(&mut renderer); } WindowEvent::Resized(physical_size) => { renderer.Resize(physical_size.width, physical_size.height); - app.Resize(&renderer); + app.Resize(&mut renderer); } _ => {} } diff --git a/Source/Shader/Shader.rs b/Source/Shader/Shader.rs index b23689e..b1d4dc1 100644 --- a/Source/Shader/Shader.rs +++ b/Source/Shader/Shader.rs @@ -30,7 +30,7 @@ impl Shader { pub fn FromGlsl(stage: ShaderStage, glsl: &str) -> Self { Self { - label: "".into(), + label: "Glsl".into(), source: ShaderSource::Glsl(glsl.to_string()), stage, } @@ -38,7 +38,7 @@ impl Shader { pub fn FromWgsl(wgsl: &str) -> Self { Self { - label: "".into(), + label: "Wgsl".into(), source: ShaderSource::Wgsl(wgsl.to_string()), stage: ShaderStage::Multiple, } diff --git a/Source/State.rs b/Source/State.rs index 55415bd..babc86d 100644 --- a/Source/State.rs +++ b/Source/State.rs @@ -5,9 +5,9 @@ use winit::event::*; /// Represents a application with reactive state. pub trait State: Sized + 'static { - fn Init(renderer: &Renderer) -> Result; - fn Input(&mut self, renderer: &Renderer, event: &WindowEvent) -> bool; - fn Update(&mut self, renderer: &Renderer, delta: Duration); - fn Resize(&mut self, renderer: &Renderer); + fn Init(renderer: &mut Renderer) -> Result; + fn Input(&mut self, renderer: &mut Renderer, event: &WindowEvent) -> bool; + fn Update(&mut self, renderer: &mut Renderer, delta: Duration); + fn Resize(&mut self, renderer: &mut Renderer); fn Draw(&mut self, renderer: &mut Renderer) -> Result<(), wgpu::SurfaceError>; }