use super::FrameViews;
use crate::EnvironmentId;
use crate::scene::probes::UploadedProbes;
use crate::shading;
use crate::shading::bind::group0;
use crate::{Scene, shading::uniforms::FrameUniform};
use bytemuck::Zeroable;
pub(crate) struct ShadowMaps {
pub directional: wgpu::TextureView,
pub local_atlas: wgpu::TextureView,
pub local_layers: wgpu::TextureView,
pub local_records: wgpu::Buffer,
pub sampler: wgpu::Sampler,
}
#[derive(Clone, Copy)]
pub(crate) struct FogVolume<'a> {
pub view: &'a wgpu::TextureView,
pub sampler: &'a wgpu::Sampler,
}
#[derive(Clone, Copy)]
pub(crate) struct LocalShadows<'a> {
pub atlas: &'a wgpu::TextureView,
pub records: &'a wgpu::Buffer,
}
struct SceneGroups {
resources: u64,
environment: Option<EnvironmentId>,
clusters: [wgpu::Buffer; 3],
local_records: wgpu::Buffer,
shadow_maps: [wgpu::TextureView; 3],
fog: wgpu::TextureView,
dynamic_gi: wgpu::TextureView,
camera_lit: wgpu::BindGroup,
ray_hit_lit: wgpu::BindGroup,
volume_lit: wgpu::BindGroup,
camera_unlit: wgpu::BindGroup,
}
pub(crate) struct FrameBindings {
pub lit: wgpu::BindGroupLayout,
pub unlit: wgpu::BindGroupLayout,
pub shadow: wgpu::BindGroupLayout,
pub scene: wgpu::BindGroupLayout,
pub material: wgpu::BindGroupLayout,
pub blended: wgpu::BindGroupLayout,
pub shadow_mask: wgpu::BindGroupLayout,
pub caster_positions: wgpu::BindGroupLayout,
pub frame: wgpu::Buffer,
pub empty_probes: UploadedProbes,
pub shadow_maps: ShadowMaps,
fog: (wgpu::TextureView, wgpu::Sampler),
dynamic_gi: wgpu::TextureView,
camera_view: wgpu::Buffer,
cascades: [wgpu::BindGroup; super::cascades::MAX_SHADOW_CASCADES],
groups: Option<SceneGroups>,
}
impl FrameBindings {
pub fn new(
device: &wgpu::Device,
lit: wgpu::BindGroupLayout,
views: &FrameViews,
shadow_maps: ShadowMaps,
fog: FogVolume<'_>,
dynamic_gi: &wgpu::TextureView,
) -> Self {
let shadow = shading::bind::shadow(device);
let frame = crate::scene::buffer(
device,
"camera frame",
bytemuck::bytes_of(&FrameUniform::zeroed()),
wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
);
let shadow_group = |label, view: &wgpu::Buffer| {
device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some(label),
layout: &shadow,
entries: &shading::bind::uniforms(view, &frame),
})
};
let cascades = std::array::from_fn(|index| {
shadow_group("directional shadow cascade", &views.cascades[index].buffer)
});
Self {
lit,
unlit: shading::bind::unlit(device),
shadow,
scene: shading::bind::scene(device),
material: shading::bind::material(device),
blended: shading::bind::blended(device),
shadow_mask: shading::bind::shadow_mask(device),
caster_positions: shading::bind::caster_positions(device),
frame,
empty_probes: UploadedProbes::empty(device),
shadow_maps,
fog: (fog.view.clone(), fog.sampler.clone()),
dynamic_gi: dynamic_gi.clone(),
camera_view: views.camera.buffer.clone(),
cascades,
groups: None,
}
}
#[allow(clippy::too_many_arguments)]
pub fn refresh(
&mut self,
device: &wgpu::Device,
scene: &Scene,
environment: Option<EnvironmentId>,
views: &FrameViews,
shadows: ShadowMaps,
fog: FogVolume<'_>,
dynamic_gi: &wgpu::TextureView,
) {
self.shadow_maps = shadows;
self.fog = (fog.view.clone(), fog.sampler.clone());
self.dynamic_gi = dynamic_gi.clone();
let environment = scene.environments.live(environment);
let clusters = [
views.clusters.buffer().clone(),
views.ray_lists.buffer().clone(),
views.volume_lists.buffer().clone(),
];
let local_records = self.shadow_maps.local_records.clone();
let maps = &self.shadow_maps;
let shadow_maps = [
maps.directional.clone(),
maps.local_atlas.clone(),
maps.local_layers.clone(),
];
if self.groups.as_ref().is_some_and(|groups| {
groups.resources == scene.resources
&& groups.environment == environment
&& groups.clusters == clusters
&& groups.local_records == local_records
&& groups.shadow_maps == shadow_maps
&& groups.fog == self.fog.0
&& groups.dynamic_gi == self.dynamic_gi
}) {
return;
}
let probes = scene.specular_probes().unwrap_or(&self.empty_probes);
let camera_lit = self.lit_group(
device,
scene,
environment,
[&self.camera_view, &self.frame],
probes,
&clusters[0],
self.local_shadows(),
&self.dynamic_gi,
);
let ray_hit_lit = self.lit_group(
device,
scene,
environment,
[&self.camera_view, &self.frame],
probes,
&clusters[1],
self.static_local_shadows(&self.shadow_maps.local_records),
&self.dynamic_gi,
);
let volume_lit = self.lit_group(
device,
scene,
environment,
[&self.camera_view, &self.frame],
probes,
&clusters[2],
self.static_local_shadows(&self.shadow_maps.local_records),
&self.dynamic_gi,
);
let camera_unlit =
self.unlit_group(device, scene, environment, &self.camera_view, &self.frame);
self.groups = Some(SceneGroups {
resources: scene.resources,
environment,
clusters,
local_records,
shadow_maps,
fog: self.fog.0.clone(),
dynamic_gi: self.dynamic_gi.clone(),
camera_lit,
ray_hit_lit,
volume_lit,
camera_unlit,
});
}
fn groups(&self) -> &SceneGroups {
self.groups
.as_ref()
.expect("FrameBindings::refresh before drawing")
}
pub fn camera_lit(&self) -> &wgpu::BindGroup {
&self.groups().camera_lit
}
pub fn ray_hit_lit(&self) -> &wgpu::BindGroup {
&self.groups().ray_hit_lit
}
pub fn volume_lit(&self) -> &wgpu::BindGroup {
&self.groups().volume_lit
}
pub fn camera_unlit(&self) -> &wgpu::BindGroup {
&self.groups().camera_unlit
}
pub fn fog(&self) -> FogVolume<'_> {
FogVolume {
view: &self.fog.0,
sampler: &self.fog.1,
}
}
pub fn cascade(&self, index: usize) -> &wgpu::BindGroup {
&self.cascades[index]
}
pub fn local_shadows(&self) -> LocalShadows<'_> {
LocalShadows {
atlas: &self.shadow_maps.local_atlas,
records: &self.shadow_maps.local_records,
}
}
pub fn static_local_shadows<'a>(&'a self, records: &'a wgpu::Buffer) -> LocalShadows<'a> {
LocalShadows {
atlas: &self.shadow_maps.local_layers,
records,
}
}
#[allow(clippy::too_many_arguments)]
pub fn lit_group(
&self,
device: &wgpu::Device,
scene: &Scene,
environment: Option<EnvironmentId>,
[view, frame]: [&wgpu::Buffer; 2],
probes: &UploadedProbes,
clusters: &wgpu::Buffer,
local: LocalShadows<'_>,
dynamic_gi: &wgpu::TextureView,
) -> wgpu::BindGroup {
let environments = &scene.environments;
let baked = &scene.static_lighting;
let texture = |binding, view| wgpu::BindGroupEntry {
binding,
resource: wgpu::BindingResource::TextureView(view),
};
let [view_entry, frame_entry] = shading::bind::uniforms(view, frame);
device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("scene lighting and local environment"),
layout: &self.lit,
entries: &[
view_entry,
frame_entry,
texture(group0::STATIC_IRRADIANCE_ATLAS, &baked.atlas.irradiance),
texture(group0::STATIC_DIRECTION_ATLAS, &baked.atlas.direction),
texture(group0::STATIC_LIGHTMAP, &baked.lightmap.irradiance),
texture(group0::STATIC_LIGHTMAP_DIRECTION, &baked.lightmap.direction),
wgpu::BindGroupEntry {
binding: group0::BAKED_SAMPLER,
resource: wgpu::BindingResource::Sampler(&baked.sampler),
},
texture(
group0::DIRECTIONAL_SHADOW_MAP,
&self.shadow_maps.directional,
),
texture(group0::LOCAL_SHADOW_ATLAS, local.atlas),
wgpu::BindGroupEntry {
binding: group0::LOCAL_SHADOWS,
resource: local.records.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: group0::SHADOW_SAMPLER,
resource: wgpu::BindingResource::Sampler(&self.shadow_maps.sampler),
},
texture(
group0::ENVIRONMENT_MAP,
&environments.frame(environment).pmrem,
),
wgpu::BindGroupEntry {
binding: group0::ENVIRONMENT_SAMPLER,
resource: wgpu::BindingResource::Sampler(&environments.sampler),
},
texture(group0::LOOKUP_TABLES, &scene.lookup_tables),
wgpu::BindGroupEntry {
binding: group0::LIGHTS,
resource: scene.lights.buffer().as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: group0::CLUSTERS,
resource: clusters.as_entire_binding(),
},
wgpu::BindGroupEntry {
binding: group0::DECALS,
resource: scene.decals.buffer().as_entire_binding(),
},
texture(group0::DECAL_ATLAS, &scene.decals.atlas.view),
wgpu::BindGroupEntry {
binding: group0::DECAL_SAMPLER,
resource: wgpu::BindingResource::Sampler(&scene.decals.sampler),
},
texture(group0::BAKED, &probes.view),
wgpu::BindGroupEntry {
binding: group0::COLLECTION,
resource: probes.metadata.as_entire_binding(),
},
texture(group0::FOG_VOLUME, &self.fog.0),
wgpu::BindGroupEntry {
binding: group0::FOG_SAMPLER,
resource: wgpu::BindingResource::Sampler(&self.fog.1),
},
texture(group0::DYNAMIC_GI_PROBES, dynamic_gi),
texture(group0::IRRADIANCE_VOLUME, scene.irradiance_cells.view()),
],
})
}
pub fn unlit_group(
&self,
device: &wgpu::Device,
scene: &Scene,
environment: Option<EnvironmentId>,
view: &wgpu::Buffer,
frame: &wgpu::Buffer,
) -> wgpu::BindGroup {
let environments = &scene.environments;
let environment = environments.frame(environment);
let texture = |binding, view| wgpu::BindGroupEntry {
binding,
resource: wgpu::BindingResource::TextureView(view),
};
let [view_entry, frame_entry] = shading::bind::uniforms(view, frame);
device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("sky and transient frame"),
layout: &self.unlit,
entries: &[
view_entry,
frame_entry,
texture(group0::BACKDROP_MAP, &environment.backdrop),
texture(group0::ENVIRONMENT_MAP, &environment.pmrem),
wgpu::BindGroupEntry {
binding: group0::ENVIRONMENT_SAMPLER,
resource: wgpu::BindingResource::Sampler(&environments.sampler),
},
texture(group0::FOG_VOLUME, &self.fog.0),
wgpu::BindGroupEntry {
binding: group0::FOG_SAMPLER,
resource: wgpu::BindingResource::Sampler(&self.fog.1),
},
],
})
}
pub fn shadow_group(
&self,
device: &wgpu::Device,
view: &wgpu::Buffer,
frame: &wgpu::Buffer,
) -> wgpu::BindGroup {
device.create_bind_group(&wgpu::BindGroupDescriptor {
label: Some("static capture shadow cascade"),
layout: &self.shadow,
entries: &shading::bind::uniforms(view, frame),
})
}
}