use super::variant::Alpha;
use crate::shading::gbuffer;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(crate) enum GeometryPass {
Forward,
GBuffer,
GBufferAnisotropy,
Lighting {
shadow_mask: bool,
},
Fused,
DirectionalShadow,
PairedShadow,
CaptureShadow,
LocalShadow,
Blended {
fsr2_masks: bool,
},
Receivers,
Fsr2Composition,
VolumeEntry,
VolumeExit,
VolumeSecondExit,
}
impl GeometryPass {
pub(super) fn caster(self) -> bool {
matches!(
self,
Self::DirectionalShadow | Self::PairedShadow | Self::CaptureShadow | Self::LocalShadow
)
}
pub(super) fn draws(self, alpha: Alpha) -> bool {
if self == Self::PairedShadow {
return alpha == Alpha::Opaque;
}
matches!(
self,
Self::Blended { .. }
| Self::Receivers
| Self::VolumeEntry
| Self::VolumeExit
| Self::VolumeSecondExit
) == (alpha == Alpha::Blend)
}
pub fn volume(self) -> bool {
matches!(
self,
Self::VolumeEntry | Self::VolumeExit | Self::VolumeSecondExit
)
}
pub fn pulled(self) -> bool {
!matches!(self, Self::CaptureShadow | Self::LocalShadow)
}
pub fn binds_caster_positions(self) -> bool {
matches!(self, Self::DirectionalShadow | Self::PairedShadow)
}
}
pub(crate) fn depth(pass: GeometryPass) -> (bool, wgpu::CompareFunction) {
use wgpu::CompareFunction::*;
match pass {
GeometryPass::Forward
| GeometryPass::DirectionalShadow
| GeometryPass::PairedShadow
| GeometryPass::CaptureShadow
| GeometryPass::LocalShadow
| GeometryPass::Receivers
| GeometryPass::VolumeEntry
| GeometryPass::VolumeExit
| GeometryPass::VolumeSecondExit => (true, Greater),
GeometryPass::GBuffer | GeometryPass::Fused => (true, GreaterEqual),
GeometryPass::GBufferAnisotropy
| GeometryPass::Lighting { .. }
| GeometryPass::Fsr2Composition => (false, Equal),
GeometryPass::Blended { .. } => (false, GreaterEqual),
}
}
pub(super) fn targets(pass: GeometryPass, anisotropy_inline: bool) -> Vec<wgpu::TextureFormat> {
use GeometryPass::*;
match pass {
Forward => vec![gbuffer::COLOR, gbuffer::MOTION],
GBuffer => {
let mut targets = vec![
gbuffer::NORMAL,
gbuffer::MATERIAL,
gbuffer::MOTION,
gbuffer::F0,
];
if anisotropy_inline {
targets.push(gbuffer::ANISOTROPY);
}
targets
}
GBufferAnisotropy => vec![gbuffer::ANISOTROPY],
Lighting { .. } => vec![
gbuffer::COLOR,
gbuffer::AMBIENT,
gbuffer::MOTION,
gbuffer::SOURCE_ID,
],
Fused => vec![
gbuffer::NORMAL,
gbuffer::MATERIAL,
gbuffer::MOTION,
gbuffer::F0,
gbuffer::COLOR,
gbuffer::AMBIENT,
gbuffer::SOURCE_ID,
gbuffer::ANISOTROPY,
],
DirectionalShadow | PairedShadow | CaptureShadow | LocalShadow => Vec::new(),
Blended { .. } => vec![gbuffer::COLOR],
Receivers => vec![gbuffer::RECEIVER, gbuffer::MOTION],
Fsr2Composition | VolumeEntry | VolumeExit | VolumeSecondExit => Vec::new(),
}
}
pub(super) fn attachments_fit(limits: &wgpu::Limits, formats: &[wgpu::TextureFormat]) -> bool {
let bytes = formats.iter().fold(0, |total: u32, format| {
total.next_multiple_of(format.target_component_alignment().unwrap())
+ format.target_pixel_byte_cost().unwrap()
});
formats.len() <= limits.max_color_attachments as usize
&& bytes <= limits.max_color_attachment_bytes_per_sample
}