use crate::Scene;
use crate::content::identity::ShaderId;
use crate::shading::bind::BindingTier;
use crate::shading::programs::{GeometryForm, ProgramShader, caster_program, geometry_program};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum Program {
Geometry(GeometryForm),
Caster,
}
pub(super) struct ProgramSet {
source: Option<String>,
label: String,
geometry: Option<wgpu::ShaderModule>,
shadow_masked: Option<wgpu::ShaderModule>,
blended: Option<wgpu::ShaderModule>,
caster: Option<wgpu::ShaderModule>,
}
impl ProgramSet {
pub fn default_set() -> Self {
Self {
source: None,
label: "SGL material".into(),
geometry: None,
shadow_masked: None,
blended: None,
caster: None,
}
}
pub fn of(scene: &Scene, shader: ShaderId) -> Self {
let shader = scene
.shaders
.get(shader)
.expect("a shader a material names lives");
Self {
source: Some(shader.source.clone()),
label: format!("SGL material shader {}", shader.label),
..Self::default_set()
}
}
fn shader(&self) -> ProgramShader<'_> {
self.source
.as_deref()
.map_or(ProgramShader::Default, ProgramShader::Game)
}
pub fn module(
&mut self,
device: &wgpu::Device,
tier: BindingTier,
program: Program,
) -> &wgpu::ShaderModule {
let program = match program {
Program::Geometry(form) if !form.distinct(tier, self.shader()) => {
Program::Geometry(GeometryForm::Plain)
}
program => program,
};
let Self {
source,
label,
geometry,
shadow_masked,
blended,
caster,
} = self;
let shader = source
.as_deref()
.map_or(ProgramShader::Default, ProgramShader::Game);
let (slot, name) = match program {
Program::Geometry(GeometryForm::Plain) => (geometry, "geometry"),
Program::Geometry(GeometryForm::ShadowMask) => {
(shadow_masked, "geometry with the shadow mask")
}
Program::Geometry(GeometryForm::Blended) => (blended, "blended geometry"),
Program::Caster => (caster, "casters"),
};
slot.get_or_insert_with(|| {
let source = match program {
Program::Geometry(form) => geometry_program(form, tier, shader),
Program::Caster => caster_program(shader),
};
device.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some(&format!("{label} {name}")),
source: wgpu::ShaderSource::Wgsl(source.into()),
})
})
}
#[cfg(all(test, not(target_arch = "wasm32")))]
pub fn modules(&self) -> usize {
[
&self.geometry,
&self.shadow_masked,
&self.blended,
&self.caster,
]
.into_iter()
.filter(|module| module.is_some())
.count()
}
}