use crate::Scene;
use crate::content::identity::ShaderId;
use crate::shading::bind::{BindingTier, LitLayout};
use crate::shading::programs::*;
use crate::shading::{self, gbuffer};
use crate::view::targets::{composition_targets, mask_targets};
use std::collections::HashMap;
mod key;
mod pass;
mod programs;
mod retention;
mod variant;
pub(crate) use crate::shading::programs::CameraShadows;
pub(crate) use key::{LayerConstants, LitConstants};
use key::{PipelineKey, Specialisation};
pub(crate) use pass::{GeometryPass, depth};
use pass::{attachments_fit, targets};
use programs::{Program, ProgramSet};
pub(crate) use retention::PipelineSpecialisations;
pub(crate) use variant::{Alpha, Cull, Variant};
pub(crate) struct GeometryPipelines {
device: wgpu::Device,
lit: wgpu::PipelineLayout,
blended: wgpu::PipelineLayout,
shadow_masked: wgpu::PipelineLayout,
lit_screen_indirect: wgpu::PipelineLayout,
shadow_masked_screen_indirect: wgpu::PipelineLayout,
contact_shadowed: wgpu::PipelineLayout,
contact_shadowed_screen_indirect: wgpu::PipelineLayout,
shadow: wgpu::PipelineLayout,
pulled_shadow: wgpu::PipelineLayout,
programs: ProgramSet,
shader_programs: HashMap<ShaderId, ProgramSet>,
cache: HashMap<PipelineKey, wgpu::RenderPipeline>,
current: Specialisation,
previous: Option<Specialisation>,
pub anisotropy_inline: bool,
pub fused_supported: bool,
unclipped_depth: bool,
pub tier: BindingTier,
}
impl GeometryPipelines {
pub fn new(
device: &wgpu::Device,
lit: &LitLayout,
[
shadow,
scene,
blended,
shadow_mask,
screen_indirect,
shadow_mask_screen_indirect,
contact_shadow,
contact_shadow_screen_indirect,
positions,
]: [&wgpu::BindGroupLayout; 9],
) -> Self {
let tier = lit.tier;
let lit = &lit.layout;
let layout = |label, groups: &[&wgpu::BindGroupLayout]| {
device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
label: Some(label),
bind_group_layouts: &groups.iter().map(|&group| Some(group)).collect::<Vec<_>>(),
immediate_size: 0,
})
};
let limits = device.limits();
let material = &shading::bind::material(device, tier);
Self {
device: device.clone(),
lit: layout("lit scene geometry", &[lit, scene, material]),
blended: layout("blended scene geometry", &[lit, scene, material, blended]),
shadow_masked: layout(
"shadow-masked scene lighting",
&[lit, scene, material, shadow_mask],
),
lit_screen_indirect: layout(
"scene lighting with screen-space indirect light",
&[lit, scene, material, screen_indirect],
),
shadow_masked_screen_indirect: layout(
"shadow-masked scene lighting with screen-space indirect light",
&[lit, scene, material, shadow_mask_screen_indirect],
),
contact_shadowed: layout(
"contact-shadowed scene lighting",
&[lit, scene, material, contact_shadow],
),
contact_shadowed_screen_indirect: layout(
"contact-shadowed scene lighting with screen-space indirect light",
&[lit, scene, material, contact_shadow_screen_indirect],
),
shadow: layout("shadow casters", &[shadow, scene, material]),
pulled_shadow: layout(
"GPU-built cascade casters",
&[shadow, scene, material, positions],
),
programs: ProgramSet::default_set(),
shader_programs: HashMap::new(),
cache: HashMap::new(),
current: (LayerConstants::ALL, LitConstants::default(), false),
previous: None,
anisotropy_inline: attachments_fit(&limits, &targets(GeometryPass::GBuffer, true)),
fused_supported: attachments_fit(
&limits,
&targets(
GeometryPass::Fused {
screen_indirect: false,
},
true,
),
),
unclipped_depth: device
.features()
.contains(wgpu::Features::DEPTH_CLIP_CONTROL),
tier,
}
}
pub fn specialise(&mut self, layers: LayerConstants, scene: &Scene) {
let next = (
layers,
LitConstants::of(scene),
scene.materials.holds_transmissive(),
);
let changed = next != self.current;
if changed {
self.previous = Some(std::mem::replace(&mut self.current, next));
}
let shaders = self.shader_programs.len();
self.shader_programs
.retain(|&id, _| scene.shaders.get(id).is_ok_and(|shader| shader.users > 0));
if changed || self.shader_programs.len() != shaders {
self.cache.retain(|key, _| {
(key.specialised(next) || self.previous.is_some_and(|s| key.specialised(s)))
&& key
.shader
.is_none_or(|id| self.shader_programs.contains_key(&id))
});
}
}
pub fn with_pipeline<T>(
&mut self,
scene: &Scene,
pass: GeometryPass,
variant: Variant,
shader: Option<ShaderId>,
use_pipeline: impl FnOnce(&wgpu::RenderPipeline) -> T,
) -> T {
let (layers, lit, transmission) = self.current;
let key = PipelineKey::new(pass, variant, shader, (layers, lit), transmission);
if let Some(pipeline) = self.cache.get(&key) {
return use_pipeline(pipeline);
}
let pipeline = self.create(scene, key);
let result = use_pipeline(&pipeline);
self.cache.insert(key, pipeline);
result
}
#[cfg(all(test, not(target_arch = "wasm32")))]
pub fn shader_programs(&self) -> (usize, usize) {
(
self.shader_programs.values().map(ProgramSet::modules).sum(),
self.cache.keys().filter(|key| key.shader.is_some()).count(),
)
}
fn create(&mut self, scene: &Scene, key: PipelineKey) -> wgpu::RenderPipeline {
use GeometryPass::*;
let device = &self.device;
let masked = key.variant.alpha == Alpha::Mask;
let shaded = key.shader.is_some();
let vertex_buffers = &shading::vertex::GEOMETRY_BUFFERS;
let (program, layout, label) = match key.pass {
DirectionalShadow | PairedShadow => {
(Program::Caster, &self.pulled_shadow, "shadow caster")
}
CaptureShadow | LocalShadow => (Program::Caster, &self.shadow, "shadow caster"),
Blended { .. } => (
Program::Geometry(GeometryForm::Blended),
&self.blended,
"blended scene geometry",
),
Receivers => (
Program::Geometry(GeometryForm::Plain),
&self.lit,
"blended receivers",
),
TemporalComposition { .. } => (
Program::Geometry(GeometryForm::Plain),
&self.lit,
"temporal composition of moving surfaces",
),
VolumeEntry | VolumeExit => (
Program::Geometry(GeometryForm::Plain),
&self.lit,
"volume layer",
),
VolumeSecondExit => (
Program::Geometry(GeometryForm::Plain),
&self.blended,
"second exit volume layer",
),
Lighting {
shadows,
screen_indirect,
} => (
Program::Geometry(GeometryForm::Camera {
shadows,
screen_indirect,
}),
match (shadows, screen_indirect) {
(CameraShadows::Maps, false) => &self.lit,
(CameraShadows::ShadowMask, false) => &self.shadow_masked,
(CameraShadows::ContactMask, false) => &self.contact_shadowed,
(CameraShadows::Maps, true) => &self.lit_screen_indirect,
(CameraShadows::ShadowMask, true) => &self.shadow_masked_screen_indirect,
(CameraShadows::ContactMask, true) => &self.contact_shadowed_screen_indirect,
},
"scene lighting",
),
Fused { screen_indirect } => (
Program::Geometry(GeometryForm::Camera {
shadows: CameraShadows::Maps,
screen_indirect,
}),
if screen_indirect {
&self.lit_screen_indirect
} else {
&self.lit
},
"fused scene geometry and lighting",
),
_ => (
Program::Geometry(GeometryForm::Plain),
&self.lit,
"lit scene geometry",
),
};
let tier = self.tier;
let programs = match key.shader {
Some(id) => self
.shader_programs
.entry(id)
.or_insert_with(|| ProgramSet::of(scene, id)),
None => &mut self.programs,
};
let module = programs.module(device, tier, program);
let (vertex, fragment) = match key.pass {
DirectionalShadow if masked && shaded && !self.unclipped_depth => (
SHADOW_PULLED_SHADED_MASKED_UNCLIPPED_VS_ENTRY,
Some(SHADOW_SHADED_MASKED_UNCLIPPED_FS_ENTRY),
),
DirectionalShadow if masked && shaded => (
SHADOW_PULLED_SHADED_MASKED_VS_ENTRY,
Some(SHADOW_SHADED_MASKED_FS_ENTRY),
),
CaptureShadow if masked && shaded && !self.unclipped_depth => (
SHADOW_SHADED_MASKED_UNCLIPPED_VS_ENTRY,
Some(SHADOW_SHADED_MASKED_UNCLIPPED_FS_ENTRY),
),
CaptureShadow | LocalShadow if masked && shaded => (
SHADOW_SHADED_MASKED_VS_ENTRY,
Some(SHADOW_SHADED_MASKED_FS_ENTRY),
),
DirectionalShadow if masked && !self.unclipped_depth => (
SHADOW_PULLED_MASKED_UNCLIPPED_VS_ENTRY,
Some(SHADOW_MASKED_UNCLIPPED_FS_ENTRY),
),
DirectionalShadow if masked => {
(SHADOW_PULLED_MASKED_VS_ENTRY, Some(SHADOW_MASKED_FS_ENTRY))
}
DirectionalShadow if !self.unclipped_depth => (
SHADOW_PULLED_UNCLIPPED_VS_ENTRY,
Some(SHADOW_UNCLIPPED_FS_ENTRY),
),
DirectionalShadow => (SHADOW_PULLED_VS_ENTRY, None),
PairedShadow if !self.unclipped_depth => (
SHADOW_PAIRED_UNCLIPPED_VS_ENTRY,
Some(SHADOW_UNCLIPPED_FS_ENTRY),
),
PairedShadow => (SHADOW_PAIRED_VS_ENTRY, None),
CaptureShadow if masked && !self.unclipped_depth => (
SHADOW_MASKED_UNCLIPPED_VS_ENTRY,
Some(SHADOW_MASKED_UNCLIPPED_FS_ENTRY),
),
CaptureShadow | LocalShadow if masked => {
(SHADOW_MASKED_VS_ENTRY, Some(SHADOW_MASKED_FS_ENTRY))
}
Forward => (SOURCE_VS_ENTRY, Some(FS_ENTRY)),
GBuffer if self.anisotropy_inline => (SOURCE_VS_ENTRY, Some(STABLE_FS_ENTRY)),
GBuffer => (SOURCE_VS_ENTRY, Some(STABLE_LEGACY_FS_ENTRY)),
GBufferAnisotropy => (SOURCE_VS_ENTRY, Some(ANISOTROPY_FS_ENTRY)),
Lighting { .. } => (SOURCE_VS_ENTRY, Some(SOURCE_FS_ENTRY)),
Fused { .. } => (SOURCE_VS_ENTRY, Some(FUSED_OPAQUE_FS_ENTRY)),
CaptureShadow if !self.unclipped_depth => {
(SHADOW_UNCLIPPED_VS_ENTRY, Some(SHADOW_UNCLIPPED_FS_ENTRY))
}
CaptureShadow | LocalShadow => (SHADOW_VS_ENTRY, None),
Blended {
temporal_masks: false,
} => (SOURCE_VS_ENTRY, Some(BLENDED_FS_ENTRY)),
Blended {
temporal_masks: true,
} => (SOURCE_VS_ENTRY, Some(BLENDED_MASKED_FS_ENTRY)),
Receivers => (SOURCE_VS_ENTRY, Some(RECEIVER_FS_ENTRY)),
TemporalComposition { .. } => (SOURCE_VS_ENTRY, Some(TEMPORAL_COMPOSITION_FS_ENTRY)),
VolumeEntry => (SOURCE_VS_ENTRY, Some(VOLUME_ENTRY_FS_ENTRY)),
VolumeExit => (SOURCE_VS_ENTRY, Some(VOLUME_EXIT_FS_ENTRY)),
VolumeSecondExit => (SOURCE_VS_ENTRY, Some(VOLUME_SECOND_EXIT_FS_ENTRY)),
};
let unclipped_depth = matches!(key.pass, DirectionalShadow | PairedShadow | CaptureShadow)
&& self.unclipped_depth;
let blend = matches!(key.pass, Blended { .. })
.then_some(wgpu::BlendState::PREMULTIPLIED_ALPHA_BLENDING);
let mut targets: Vec<_> = targets(key.pass, self.anisotropy_inline)
.into_iter()
.map(|format| {
Some(wgpu::ColorTargetState {
format,
blend,
write_mask: wgpu::ColorWrites::ALL,
})
})
.collect();
if key.pass
== (Blended {
temporal_masks: true,
})
{
targets.extend(mask_targets());
}
if matches!(key.pass, TemporalComposition { .. }) {
targets.extend(composition_targets());
}
let constants = key.constants();
let (depth_write, depth_compare) = depth(key.pass);
device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
label: Some(label),
layout: Some(layout),
vertex: wgpu::VertexState {
module,
entry_point: Some(vertex),
compilation_options: wgpu::PipelineCompilationOptions {
constants: &constants,
..Default::default()
},
buffers: if key.pass.pulled() {
&vertex_buffers[..1]
} else {
vertex_buffers
},
},
fragment: fragment.map(|fragment| wgpu::FragmentState {
module,
entry_point: Some(fragment),
compilation_options: wgpu::PipelineCompilationOptions {
constants: &constants,
..Default::default()
},
targets: &targets,
}),
primitive: wgpu::PrimitiveState {
cull_mode: key.variant.cull.face(),
unclipped_depth,
..Default::default()
},
depth_stencil: Some(wgpu::DepthStencilState {
format: gbuffer::DEPTH,
depth_write_enabled: Some(depth_write),
depth_compare: Some(depth_compare),
stencil: Default::default(),
bias: Default::default(),
}),
multisample: Default::default(),
multiview_mask: None,
cache: None,
})
}
}
#[cfg(all(test, not(target_arch = "wasm32")))]
mod primary_depth_precision_tests;
#[cfg(all(test, not(target_arch = "wasm32")))]
mod specialisation_tests;