guilhermewerner/wgpu-renderer
1
0
Fork 0
mirror of https://github.com/guilhermewerner/wgpu-renderer synced 2025-06-15 13:24:20 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Test custom types with cubes example

Browse Source
This commit is contained in:
Werner
2022-01-05 09:41:22 -03:00
parent f45d465c3f
commit 1ac2662011
10 changed files with 153 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

156
Examples/Cubes.rs
View File

@ -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<Self> {
fn Init(renderer: &mut Renderer) -> Result<Self> {
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::<Vec<_>>();
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::<Vec<_>>();
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(())

16
Examples/Triangle.rs
View File

@ -60,7 +60,7 @@ struct Triangle {
}
impl State for Triangle {
fn Init(renderer: &Renderer) -> Result<Self> {
fn Init(renderer: &mut Renderer) -> Result<Self> {
// 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();

4
Source/Render/Instance.rs
View File

@ -6,8 +6,8 @@ pub const NUM_INSTANCES: u32 = NUM_INSTANCES_PER_ROW * NUM_INSTANCES_PER_ROW;
pub const INSTANCE_DISPLACEMENT: cgmath::Vector3<f32> = 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::<InstanceRaw>() as wgpu::BufferAddress,
// We need to switch from using a step mode of Vertex to Instance

35
Source/Render/Model.rs
View File

@ -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::<ModelVertex>() as wgpu::BufferAddress,
step_mode: wgpu::VertexStepMode::Vertex,
attributes: &[
wgpu::VertexAttribute {
VertexBufferLayout {
label: "Model".into(),
stride: mem::size_of::<ModelVertex>(),
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,
},
],
}

1
Source/Render/Pipeline/PipelineDescriptor.rs
View File

@ -5,5 +5,4 @@ pub struct PipelineDescriptor {
pub label: Cow<'static, str>,
pub layout: Option<String>,
pub shader_stages: String,
}

11
Source/Render/Renderer.rs
View File

@ -22,12 +22,12 @@ impl Renderer {
pub async fn New(window: Window) -> Result<Self> {
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

36
Source/Render/mod.rs
View File

@ -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;

12
Source/Runtime.rs
View File

@ -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);
}
_ => {}
}

4
Source/Shader/Shader.rs
View File

@ -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,
}

8
Source/State.rs
View File

@ -5,9 +5,9 @@ use winit::event::*;
/// Represents a application with reactive state.
pub trait State: Sized + 'static {
fn Init(renderer: &Renderer) -> Result<Self>;
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<Self>;
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>;
}