nullprop/wgpu-renderer
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Fix geometry depth binding not updating after resize, refactoring

Browse source
This commit is contained in:
Lauri Räsänen 2023-11-10 19:38:12 +02:00
parent 7b752703ea
commit 3676f8fef5
6 changed files with 210 additions and 219 deletions
Download patch file Download diff file Expand all files Collapse all files

48
res/shaders/fog.wgsl
View file

@ -35,31 +35,16 @@ fn vs_main(
// Fragment shader
@group(2)@binding(0)
@group(1) @binding(0)
var t_light_depth: texture_depth_2d_array;
@group(2) @binding(1)
@group(1) @binding(1)
var s_light_depth: sampler_comparison;
@group(2)@binding(2)
@group(2) @binding(0)
var t_geometry_depth: texture_depth_2d;
@group(2) @binding(3)
@group(2) @binding(1)
var s_geometry_depth: sampler;
@group(3) @binding(0)
var t_diffuse: texture_2d<f32>;
@group(3)@binding(1)
var s_diffuse: sampler;
@group(3)@binding(2)
var t_normal: texture_2d<f32>;
@group(3) @binding(3)
var s_normal: sampler;
@group(3)@binding(4)
var t_roughness_metalness: texture_2d<f32>;
@group(3) @binding(5)
var s_roughness_metalness: sampler;
fn fog_noise(pos: vec3<f32>) -> f32 {
var p = pos * FOG_SCALE;
p.x += global_uniforms.time * 0.01;
@ -91,15 +76,7 @@ fn ray_march(origin: vec3<f32>, direction: vec3<f32>, scene_depth: f32) -> f32 {
return density;
}
fn scene_depth(clip_position: vec4<f32>) -> f32 {
if (clip_position.w <= 0.0) {
return 0.0;
}
let ndc = clip_position.xy / clip_position.w;
let uv = ndc * vec2<f32>(0.5, -0.5) + vec2<f32>(0.5, 0.5);
let depth = textureSample(t_geometry_depth, s_geometry_depth, uv);
fn depth_to_linear(depth: f32) -> f32 {
// convert to linear [near, far] range
let z_near = camera.planes.x;
let z_far = camera.planes.y;
@ -109,15 +86,21 @@ fn scene_depth(clip_position: vec4<f32>) -> f32 {
@fragment
fn fs_main(vert: FogVertexOutput) -> @location(0) vec4<f32> {
let cam_to_volume = vert.world_position.xyz - camera.position.xyz;
let distance_to_volume = length(cam_to_volume);
var distance_to_volume = length(cam_to_volume);
let direction = cam_to_volume / distance_to_volume;
// FIXME: t_geometry_depth is 0
var geometry_depth = scene_depth(vert.clip_position) - distance_to_volume;
geometry_depth = 3000.0;
// FIXME: geom depth should always be greater than the volume surface depth...
// why is this broken?
distance_to_volume = depth_to_linear(vert.clip_position.z);
let uv = vert.clip_position.xy / camera.planes.xy;
let depth = textureSample(t_geometry_depth, s_geometry_depth, uv);
let geometry_depth = depth_to_linear(depth) - distance_to_volume;
if (geometry_depth <= 0.0)
{
return vec4<f32>(0.0);
}
return vec4<f32>(1.0);
/*
let density = ray_march(vert.world_position.xyz, direction, geometry_depth);
var in_light = 0.0;
@ -170,4 +153,5 @@ fn fs_main(vert: FogVertexOutput) -> @location(0) vec4<f32> {
result = result / (result + vec3(1.0));
return vec4(result, density * FOG_ALPHA);
*/
}

4
res/shaders/globals.wgsl
View file

@ -15,7 +15,7 @@ struct Light {
color: vec4<f32>,
matrices: array<mat4x4<f32>, 6>,
}
@group(1) @binding(0)
@group(0) @binding(1)
var<uniform> light: Light;
struct GlobalUniforms {
@ -24,7 +24,7 @@ struct GlobalUniforms {
use_shadowmaps: u32,
_padding: u32,
}
@group(1) @binding(1)
@group(0) @binding(2)
var<uniform> global_uniforms: GlobalUniforms;
struct VertexInput {

16
res/shaders/pbr.wgsl
View file

@ -47,24 +47,24 @@ fn vs_main(
// Fragment shader
@group(2)@binding(0)
@group(1) @binding(0)
var t_light_depth: texture_depth_2d_array;
@group(2) @binding(1)
@group(1) @binding(1)
var s_light_depth: sampler_comparison;
@group(3) @binding(0)
@group(2) @binding(0)
var t_diffuse: texture_2d<f32>;
@group(3)@binding(1)
@group(2) @binding(1)
var s_diffuse: sampler;
@group(3)@binding(2)
@group(2) @binding(2)
var t_normal: texture_2d<f32>;
@group(3) @binding(3)
@group(2) @binding(3)
var s_normal: sampler;
@group(3)@binding(4)
@group(2) @binding(4)
var t_roughness_metalness: texture_2d<f32>;
@group(3) @binding(5)
@group(2) @binding(5)
var s_roughness_metalness: sampler;
@fragment

34
src/core/light.rs
View file

@ -46,31 +46,27 @@ pub trait DrawLight<'a> {
fn draw_light_mesh(
&mut self,
mesh: &'a Mesh,
camera_bind_group: &'a wgpu::BindGroup,
light_bind_group: &'a wgpu::BindGroup,
global_bind_group: &'a wgpu::BindGroup,
);
fn draw_light_mesh_instanced(
&mut self,
mesh: &'a Mesh,
instances: Range<u32>,
camera_bind_group: &'a wgpu::BindGroup,
light_bind_group: &'a wgpu::BindGroup,
global_bind_group: &'a wgpu::BindGroup,
);
fn draw_light_model(
&mut self,
model: &'a Model,
camera_bind_group: &'a wgpu::BindGroup,
light_bind_group: &'a wgpu::BindGroup,
global_bind_group: &'a wgpu::BindGroup,
);
fn draw_light_model_instanced(
&mut self,
model: &'a Model,
instances: Range<u32>,
camera_bind_group: &'a wgpu::BindGroup,
light_bind_group: &'a wgpu::BindGroup,
global_bind_group: &'a wgpu::BindGroup,
);
}
@ -81,48 +77,42 @@ impl<'a, 'b> DrawLight<'b> for wgpu::RenderPass<'a>
fn draw_light_mesh(
&mut self,
mesh: &'b Mesh,
camera_bind_group: &'b wgpu::BindGroup,
light_bind_group: &'b wgpu::BindGroup,
global_bind_group: &'b wgpu::BindGroup
) {
self.draw_light_mesh_instanced(mesh, 0..1, camera_bind_group, light_bind_group);
self.draw_light_mesh_instanced(mesh, 0..1, global_bind_group);
}
fn draw_light_mesh_instanced(
&mut self,
mesh: &'b Mesh,
instances: Range<u32>,
camera_bind_group: &'b wgpu::BindGroup,
light_bind_group: &'b wgpu::BindGroup,
global_bind_group: &'b wgpu::BindGroup
) {
self.set_vertex_buffer(0, mesh.vertex_buffer.slice(..));
self.set_index_buffer(mesh.index_buffer.slice(..), wgpu::IndexFormat::Uint32);
self.set_bind_group(0, camera_bind_group, &[]);
self.set_bind_group(1, light_bind_group, &[]);
self.set_bind_group(0, global_bind_group, &[]);
self.draw_indexed(0..mesh.num_elements, 0, instances);
}
fn draw_light_model(
&mut self,
model: &'b Model,
camera_bind_group: &'b wgpu::BindGroup,
light_bind_group: &'b wgpu::BindGroup,
global_bind_group: &'b wgpu::BindGroup
) {
self.draw_light_model_instanced(model, 0..1, camera_bind_group, light_bind_group);
self.draw_light_model_instanced(model, 0..1, global_bind_group);
}
fn draw_light_model_instanced(
&mut self,
model: &'b Model,
instances: Range<u32>,
camera_bind_group: &'b wgpu::BindGroup,
light_bind_group: &'b wgpu::BindGroup,
global_bind_group: &'b wgpu::BindGroup
) {
for mesh in &model.meshes {
self.draw_light_mesh_instanced(
mesh,
instances.clone(),
camera_bind_group,
light_bind_group,
global_bind_group
);
}
}

17
src/core/model.rs
View file

@ -69,6 +69,7 @@ pub trait DrawModel<'a> {
mesh: &'a Mesh,
material: &'a Material,
bind_groups: Vec<&'a wgpu::BindGroup>,
add_texture_binds: bool,
);
fn draw_mesh_instanced(
&mut self,
@ -76,18 +77,21 @@ pub trait DrawModel<'a> {
material: &'a Material,
instances: Range<u32>,
bind_groups: Vec<&'a wgpu::BindGroup>,
add_texture_binds: bool,
);
fn draw_model(
&mut self,
model: &'a Model,
bind_groups: Vec<&'a wgpu::BindGroup>,
add_texture_binds: bool,
);
fn draw_model_instanced(
&mut self,
model: &'a Model,
instances: Range<u32>,
bind_groups: Vec<&'a wgpu::BindGroup>,
add_texture_binds: bool,
);
}
@ -100,8 +104,9 @@ impl<'a, 'b> DrawModel<'b> for wgpu::RenderPass<'a>
mesh: &'b Mesh,
material: &'b Material,
bind_groups: Vec<&'a wgpu::BindGroup>,
add_texture_binds: bool,
) {
self.draw_mesh_instanced(mesh, material, 0..1, bind_groups);
self.draw_mesh_instanced(mesh, material, 0..1, bind_groups, add_texture_binds);
}
fn draw_mesh_instanced(
@ -110,13 +115,16 @@ impl<'a, 'b> DrawModel<'b> for wgpu::RenderPass<'a>
material: &'b Material,
instances: Range<u32>,
bind_groups: Vec<&'a wgpu::BindGroup>,
add_texture_binds: bool,
) {
self.set_vertex_buffer(0, mesh.vertex_buffer.slice(..));
self.set_index_buffer(mesh.index_buffer.slice(..), wgpu::IndexFormat::Uint32);
for (i, group) in bind_groups.iter().enumerate() {
self.set_bind_group(i as u32, group, &[]);
}
self.set_bind_group(bind_groups.len() as u32, &material.bind_group, &[]);
if add_texture_binds {
self.set_bind_group(bind_groups.len() as u32, &material.bind_group, &[]);
}
self.draw_indexed(0..mesh.num_elements, 0, instances);
}
@ -124,8 +132,9 @@ impl<'a, 'b> DrawModel<'b> for wgpu::RenderPass<'a>
&mut self,
model: &'b Model,
bind_groups: Vec<&'a wgpu::BindGroup>,
add_texture_binds: bool,
) {
self.draw_model_instanced(model, 0..1, bind_groups);
self.draw_model_instanced(model, 0..1, bind_groups, add_texture_binds);
}
fn draw_model_instanced(
@ -133,6 +142,7 @@ impl<'a, 'b> DrawModel<'b> for wgpu::RenderPass<'a>
model: &'b Model,
instances: Range<u32>,
bind_groups: Vec<&'a wgpu::BindGroup>,
add_texture_binds: bool,
) {
for mesh in &model.meshes {
let material = &model.materials[mesh.material];
@ -141,6 +151,7 @@ impl<'a, 'b> DrawModel<'b> for wgpu::RenderPass<'a>
material,
instances.clone(),
bind_groups.clone(),
add_texture_binds,
);
}
}

310
src/core/state.rs
View file

@ -38,21 +38,23 @@ pub struct State {
camera: Camera,
camera_uniform: CameraUniform,
camera_buffer: wgpu::Buffer,
camera_bind_group: wgpu::BindGroup,
global_bind_group: wgpu::BindGroup,
camera_controller: CameraController,
geom_instances: Vec<Instance>,
geom_instance_buffer: wgpu::Buffer,
fog_instances: Vec<Instance>,
fog_instance_buffer: wgpu::Buffer,
geometry_depth_texture: Texture,
light_depth_texture: Texture,
geom_model: Model,
fog_model: Model,
light_model: Model,
light_uniform: LightUniform,
light_buffer: wgpu::Buffer,
light_debug_pass: RenderPass,
light_bind_group: wgpu::BindGroup,
depth_bind_group: wgpu::BindGroup,
light_depth_bind_group: wgpu::BindGroup,
geometry_depth_bind_group: wgpu::BindGroup,
geometry_depth_bind_group_layout: wgpu::BindGroupLayout,
light_depth_pass: RenderPass,
light_depth_texture_target_views: [wgpu::TextureView; SHADOW_MAP_LAYERS as usize],
global_uniforms: GlobalUniforms,
@ -124,41 +126,87 @@ impl State {
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
});
let camera_uniform_size = mem::size_of::<CameraUniform>() as u64;
let camera_bind_group_layout =
let light_uniform = LightUniform::new([0.0, 0.0, 0.0], [1.0, 1.0, 1.0, 250000.0]);
let light_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Light UB"),
contents: bytemuck::cast_slice(&[light_uniform]),
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
});
let light_uniform_size = mem::size_of::<LightUniform>() as u64;
let global_uniforms = GlobalUniforms::default();
let global_uniforms_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Light Matrix UB"),
contents: bytemuck::cast_slice(&[global_uniforms]),
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
});
let global_uniform_size = mem::size_of::<GlobalUniforms>() as u64;
let global_bind_group_layout =
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
entries: &[wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: wgpu::BufferSize::new(camera_uniform_size),
entries: &[
// CameraUniform
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: wgpu::BufferSize::new(camera_uniform_size),
},
count: None,
},
count: None,
}],
// LightUniform
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: wgpu::BufferSize::new(light_uniform_size),
},
count: None,
},
// global_uniforms
wgpu::BindGroupLayoutEntry {
binding: 2,
visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: wgpu::BufferSize::new(global_uniform_size),
},
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(),
}],
layout: &global_bind_group_layout,
entries: &[
// CameraUniform
wgpu::BindGroupEntry {
binding: 0,
resource: camera_buffer.as_entire_binding(),
},
// light struct
wgpu::BindGroupEntry {
binding: 1,
resource: light_buffer.as_entire_binding(),
},
// global_uniforms
wgpu::BindGroupEntry {
binding: 2,
resource: global_uniforms_buffer.as_entire_binding(),
}
],
label: Some("camera_bind_group"),
});
let camera_controller = CameraController::new(400.0, 2.0);
let geometry_depth_texture = Texture::create_depth_texture(
&device,
"geometry_depth_texture",
None,
config.width,
config.height,
1,
wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
true,
);
let geometry_depth_texture = State::create_geometry_depth_texture(&device, &config);
let light_depth_texture = Texture::create_depth_texture(
&device,
@ -188,71 +236,7 @@ impl State {
.try_into()
.expect("failed to create light depth texture views");
let light_uniform = LightUniform::new([0.0, 0.0, 0.0], [1.0, 1.0, 1.0, 250000.0]);
let light_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Light UB"),
contents: bytemuck::cast_slice(&[light_uniform]),
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
});
let global_uniforms = GlobalUniforms::default();
let global_uniforms_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Light Matrix UB"),
contents: bytemuck::cast_slice(&[global_uniforms]),
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
});
let light_uniform_size = mem::size_of::<LightUniform>() as u64;
let light_matrix_uniform_size = mem::size_of::<GlobalUniforms>() as u64;
let light_bind_group_layout =
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
entries: &[
// LightUniform
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: wgpu::BufferSize::new(light_uniform_size),
},
count: None,
},
// matrix index, use shadowmaps
wgpu::BindGroupLayoutEntry {
binding: 1,
// TODO: remove fragment vis once no shadowmap uniform
visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: wgpu::BufferSize::new(light_matrix_uniform_size),
},
count: None,
},
],
label: Some("Light Bind Group Layout"),
});
let light_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
layout: &light_bind_group_layout,
entries: &[
// light struct
wgpu::BindGroupEntry {
binding: 0,
resource: light_buffer.as_entire_binding(),
},
// matrix index
wgpu::BindGroupEntry {
binding: 1,
resource: global_uniforms_buffer.as_entire_binding(),
},
],
label: Some("Light Bind Group"),
});
let depth_bind_group_layout =
let light_depth_bind_group_layout =
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
entries: &[
// light cubemap
@ -272,29 +256,12 @@ impl State {
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Comparison),
count: None,
},
// geometry depth
wgpu::BindGroupLayoutEntry {
binding: 2,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
multisampled: false,
view_dimension: wgpu::TextureViewDimension::D2,
sample_type: wgpu::TextureSampleType::Depth,
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 3,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
count: None,
},
],
label: Some("Depth Bind Group Layout"),
label: Some("Light Bind Group Layout"),
});
let depth_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
layout: &depth_bind_group_layout,
let light_depth_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
layout: &light_depth_bind_group_layout,
entries: &[
// light cubemap
wgpu::BindGroupEntry {
@ -305,20 +272,35 @@ impl State {
binding: 1,
resource: wgpu::BindingResource::Sampler(&light_depth_texture.sampler),
},
// geometry depth
wgpu::BindGroupEntry {
binding: 2,
resource: wgpu::BindingResource::TextureView(&geometry_depth_texture.view),
},
wgpu::BindGroupEntry {
binding: 3,
resource: wgpu::BindingResource::Sampler(&geometry_depth_texture.sampler),
},
],
label: Some("Depth Bind Group"),
label: Some("Light Bind Group"),
});
surface.configure(&device, &config);
let geometry_depth_bind_group_layout =
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
entries: &[
// geometry depth
wgpu::BindGroupLayoutEntry {
binding: 0,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Texture {
multisampled: false,
view_dimension: wgpu::TextureViewDimension::D2,
sample_type: wgpu::TextureSampleType::Depth,
},
count: None,
},
wgpu::BindGroupLayoutEntry {
binding: 1,
visibility: wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
count: None,
},
],
label: Some("Depth Bind Group Layout"),
});
let geometry_depth_bind_group = State::create_geometry_depth_bind_group(&device, &geometry_depth_bind_group_layout, &geometry_depth_texture);
let texture_bind_group_layout =
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
@ -433,8 +415,7 @@ impl State {
let light_depth_pass = RenderPass::new(
&device,
&[
&camera_bind_group_layout,
&light_bind_group_layout,
&global_bind_group_layout,
],
&[],
"depth.wgsl",
@ -451,9 +432,8 @@ impl State {
let geometry_pass = RenderPass::new(
&device,
&[
&camera_bind_group_layout,
&light_bind_group_layout,
&depth_bind_group_layout,
&global_bind_group_layout,
&light_depth_bind_group_layout,
&texture_bind_group_layout,
],
&[],
@ -470,7 +450,7 @@ impl State {
let light_debug_pass = RenderPass::new(
&device,
&[&camera_bind_group_layout, &light_bind_group_layout],
&[&global_bind_group_layout],
&[],
"light_debug.wgsl",
Some(config.format),
@ -486,10 +466,9 @@ impl State {
let fog_pass = RenderPass::new(
&device,
&[
&camera_bind_group_layout,
&light_bind_group_layout,
&depth_bind_group_layout,
&texture_bind_group_layout,
&global_bind_group_layout,
&light_depth_bind_group_layout,
&geometry_depth_bind_group_layout,
],
&[],
"fog.wgsl",
@ -514,21 +493,23 @@ impl State {
camera,
camera_uniform,
camera_buffer,
camera_bind_group,
global_bind_group: camera_bind_group,
camera_controller,
geom_instances,
geom_instance_buffer,
fog_instances,
fog_instance_buffer,
geometry_depth_texture,
light_depth_texture,
geom_model,
fog_model,
light_model,
light_uniform,
light_buffer,
light_debug_pass,
light_bind_group,
depth_bind_group,
light_depth_bind_group,
geometry_depth_bind_group,
geometry_depth_bind_group_layout,
light_depth_pass,
light_depth_texture_target_views,
global_uniforms,
@ -536,6 +517,37 @@ impl State {
}
}
pub fn create_geometry_depth_bind_group(device: &wgpu::Device, layout: &wgpu::BindGroupLayout, geometry_depth_texture: &Texture) -> wgpu::BindGroup {
device.create_bind_group(&wgpu::BindGroupDescriptor {
layout: layout,
entries: &[
// geometry depth
wgpu::BindGroupEntry {
binding: 0,
resource: wgpu::BindingResource::TextureView(&geometry_depth_texture.view),
},
wgpu::BindGroupEntry {
binding: 1,
resource: wgpu::BindingResource::Sampler(&geometry_depth_texture.sampler),
},
],
label: Some("Depth Bind Group"),
})
}
fn create_geometry_depth_texture(device: &wgpu::Device, config: &wgpu::SurfaceConfiguration) -> Texture {
Texture::create_depth_texture(
&device,
"geometry_depth_texture",
None,
config.width,
config.height,
1,
wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
true,
)
}
pub fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
if new_size.width > 0 && new_size.height > 0 {
self.size = new_size;
@ -545,16 +557,8 @@ impl State {
self.camera
.projection
.resize(new_size.width, new_size.height);
self.geometry_depth_texture = Texture::create_depth_texture(
&self.device,
"geometry_depth_texture",
None,
self.config.width,
self.config.height,
1,
wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
true,
);
self.geometry_depth_texture = State::create_geometry_depth_texture(&self.device, &self.config);
self.geometry_depth_bind_group = State::create_geometry_depth_bind_group(&self.device, &self.geometry_depth_bind_group_layout, &self.geometry_depth_texture);
}
}
@ -638,7 +642,8 @@ impl State {
light_depth_render_pass.draw_model_instanced(
&self.geom_model,
0..self.geom_instances.len() as u32,
[&self.camera_bind_group, &self.light_bind_group].into(),
[&self.global_bind_group].into(),
false,
);
}
@ -690,7 +695,8 @@ impl State {
geom_render_pass.draw_model_instanced(
&self.geom_model,
0..self.geom_instances.len() as u32,
[&self.camera_bind_group, &self.light_bind_group, &self.depth_bind_group].into(),
[&self.global_bind_group, &self.light_depth_bind_group].into(),
true,
);
}
geometry_encoder.pop_debug_group();
@ -723,8 +729,7 @@ impl State {
light_debug_render_pass.set_pipeline(&self.light_debug_pass.pipeline);
light_debug_render_pass.draw_light_model(
&self.light_model,
&self.camera_bind_group,
&self.light_bind_group,
&self.global_bind_group,
);
}
geometry_encoder.pop_debug_group();
@ -763,7 +768,8 @@ impl State {
fog_render_pass.draw_model_instanced(
&self.fog_model,
0..self.fog_instances.len() as u32,
[&self.camera_bind_group, &self.light_bind_group, &self.depth_bind_group].into(),
[&self.global_bind_group, &self.light_depth_bind_group, &self.geometry_depth_bind_group].into(),
false,
);
}
fog_encoder.pop_debug_group();