pub(crate) mod effects;
pub(crate) mod heat;
pub(crate) mod mist;
pub(crate) mod transmission;
pub(crate) mod volumes;
use crate::shading::bind::{self, BindingTier, BlendedTrace};
use crate::view::cached_group::CachedGroup;
use crate::view::frame::FrameContext;
use crate::view::pipelines::GeometryPass;
use crate::view::targets::{SharedTargets, attachment};
pub(crate) enum Beauty<'a> {
Incident(&'a wgpu::TextureView),
Composite {
reflections: Option<&'a wgpu::TextureView>,
},
}
pub(crate) struct Transparent {
effects: effects::Effects,
mist: mist::Mist,
heat: heat::Heat,
depth_group: wgpu::BindGroup,
no_reflections: wgpu::TextureView,
blended: [BlendedGroup; 2],
transmission: transmission::Transmission,
volumes: volumes::Volumes,
tier: BindingTier,
}
struct BlendedGroup {
group: CachedGroup,
trace: wgpu::Buffer,
written: Option<BlendedTrace>,
}
impl Transparent {
pub fn new(
device: &wgpu::Device,
unlit: &wgpu::BindGroupLayout,
blended: &wgpu::BindGroupLayout,
targets: &SharedTargets,
tier: BindingTier,
) -> Self {
let effects = effects::Effects::new(device, unlit);
let group = |label| BlendedGroup {
group: CachedGroup::new(blended.clone()),
trace: crate::counters::buffer(
device,
&wgpu::BufferDescriptor {
label: Some(label),
size: size_of::<BlendedTrace>() as u64,
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
},
),
written: None,
};
Self {
depth_group: effects.depth_group(device, &targets.depth),
effects,
mist: mist::Mist::new(device, unlit),
heat: heat::Heat::new(device),
no_reflections: crate::view::targets::target(
device,
"no screen-space reflections",
[1, 1],
crate::shading::gbuffer::COLOR,
),
blended: [
group("blended incident trace"),
group("blended composite trace"),
],
transmission: transmission::Transmission::new(device),
volumes: volumes::Volumes::new(device, blended),
tier,
}
}
pub fn encode_receivers(&self, ctx: &mut FrameContext<'_>) -> bool {
let targets: &SharedTargets = ctx.targets;
let Some(surface) = &targets.surface else {
return false;
};
if !ctx.effective.receivers || !ctx.views.blended.holds_receivers(ctx.scene) {
return false;
}
ctx.encoder.copy_texture_to_texture(
targets.depth.texture().as_image_copy(),
surface.depth.texture().as_image_copy(),
targets.depth.texture().size(),
);
let mut pass = ctx.encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("blended receivers"),
color_attachments: &[
attachment(&surface.receivers),
loaded(attachment(&targets.motion), true),
],
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
view: &surface.depth,
depth_ops: Some(wgpu::Operations {
load: wgpu::LoadOp::Load,
store: wgpu::StoreOp::Store,
}),
stencil_ops: None,
}),
timestamp_writes: ctx.timing.and_then(|t| t.render_pass("receivers")),
..Default::default()
});
pass.set_bind_group(0, ctx.bindings.camera_lit(), &[]);
ctx.views.blended.draw(
ctx.scene,
ctx.pipelines,
&ctx.views.instances,
&mut pass,
GeometryPass::Receivers,
);
true
}
pub fn encode_volumes(&mut self, ctx: &mut FrameContext<'_>) -> bool {
if !ctx.effective.volume_paths {
if self.volumes.release() {
for blended in &mut self.blended {
blended.group.forget();
}
}
return false;
}
self.volumes.encode(ctx, &self.no_reflections)
}
pub fn resize(&mut self, device: &wgpu::Device, targets: &SharedTargets) {
self.depth_group = self.effects.depth_group(device, &targets.depth);
}
pub fn encode(&mut self, ctx: &mut FrameContext<'_>, beauty: Beauty<'_>) {
let targets: &SharedTargets = ctx.targets;
let (beauty, fsr2_masks, (trace, reflections)) = match beauty {
Beauty::Incident(view) => (view, None, (0, None)),
Beauty::Composite { reflections } => (
&targets.composite,
ctx.effective.fsr2.then_some(&targets.fsr2_masks),
(1, reflections),
),
};
let moving = fsr2_masks.filter(|_| ctx.scene.materials.holds_moving_surfaces());
if let Some(masks) = moving {
Self::encode_composition(ctx, masks);
}
let blended = !ctx.views.blended.is_empty();
if blended {
let copy = (trace == 1
&& self.tier == BindingTier::Extended
&& ctx.views.blended.holds_transmissive(ctx.scene))
.then(|| {
self.transmission
.encode(ctx.device, ctx.encoder, &targets.composite, ctx.timing)
.clone()
});
let group = Self::blended_group(
ctx,
&mut self.blended[trace],
&self.no_reflections,
(reflections, copy.as_ref(), self.volumes.held()),
self.tier,
);
Self::encode_blended(ctx, beauty, fsr2_masks, moving.is_some(), group);
}
let cleared = moving.is_some() || blended;
let draw = ctx.effective.effects;
if draw || (fsr2_masks.is_some() && !cleared) {
let mut color = attachment(beauty).unwrap();
color.ops.load = wgpu::LoadOp::Load;
let mut attachments = vec![Some(color)];
attachments.extend(
fsr2_masks
.into_iter()
.flatten()
.map(|mask| loaded(attachment(mask), cleared)),
);
let mut pass = ctx.encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("additive effects"),
color_attachments: &attachments,
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
view: &targets.depth,
depth_ops: None,
stencil_ops: None,
}),
timestamp_writes: ctx.timing.and_then(|t| t.render_pass("transparent")),
..Default::default()
});
if draw {
self.effects.draw(
&mut pass,
ctx.bindings.camera_unlit(),
&self.depth_group,
&ctx.scene.transient,
fsr2_masks.is_some(),
);
}
}
if ctx.effective.atmosphere {
self.mist.encode(
ctx.encoder,
ctx.bindings.camera_unlit(),
&ctx.scene.transient,
beauty,
&targets.depth,
fsr2_masks,
ctx.timing,
"transparent",
);
}
}
fn blended_group<'a>(
ctx: &FrameContext<'_>,
blended: &'a mut BlendedGroup,
no_reflections: &wgpu::TextureView,
(reflections, copy, volumes): (
Option<&wgpu::TextureView>,
Option<&wgpu::TextureView>,
Option<&volumes::Layers>,
),
tier: BindingTier,
) -> &'a wgpu::BindGroup {
let traced = ctx.effective.screen_space.zip(reflections);
let mut values = traced.map_or_else(BlendedTrace::default, |(ssr, _)| BlendedTrace {
cutoff: ssr.cutoff,
fade: ssr.fade,
..BlendedTrace::default()
});
values.transmission = u32::from(copy.is_some());
values.volumes = u32::from(volumes.is_some());
if blended.written != Some(values) {
crate::counters::write_buffer(
ctx.queue,
&blended.trace,
0,
bytemuck::bytes_of(&values),
);
blended.written = Some(values);
}
let reflections = traced.map_or(no_reflections, |(_, view)| view);
let texture = wgpu::BindingResource::TextureView;
let mut entries = vec![
(bind::blended::REFLECTIONS, texture(reflections)),
(bind::blended::SURFACE_DEPTH, texture(ctx.surface.depth)),
(bind::blended::TRACE, blended.trace.as_entire_binding()),
];
if bind::blended::tier(bind::blended::TRANSMISSION) <= tier {
entries.push((
bind::blended::TRANSMISSION,
texture(copy.unwrap_or(no_reflections)),
));
}
if bind::blended::tier(bind::blended::SCENE_DEPTH) <= tier {
entries.push((bind::blended::SCENE_DEPTH, texture(&ctx.targets.depth)));
}
if bind::blended::tier(bind::blended::VOLUME_ENTRY) <= tier {
let layer = |held: fn(&volumes::Layers) -> &wgpu::TextureView| {
texture(volumes.map_or(&ctx.targets.depth, held))
};
entries.extend([
(bind::blended::VOLUME_ENTRY, layer(|layers| &layers.entry)),
(bind::blended::VOLUME_EXIT, layer(|layers| &layers.exit)),
(
bind::blended::VOLUME_SECOND_EXIT,
layer(|layers| &layers.second_exit),
),
]);
}
blended
.group
.get(ctx.device, "blended reflections", &entries)
}
fn encode_composition(ctx: &mut FrameContext<'_>, masks: &[wgpu::TextureView; 2]) {
let attachments = masks.each_ref().map(attachment);
let started = crate::counters::Moment::now();
let mut pass = ctx.encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("FSR2 composition of moving surfaces"),
color_attachments: &attachments,
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
view: &ctx.targets.depth,
depth_ops: None,
stencil_ops: None,
}),
timestamp_writes: ctx.timing.and_then(|t| t.render_pass("FSR2 composition")),
..Default::default()
});
pass.set_bind_group(0, ctx.bindings.camera_lit(), &[]);
let scene = ctx.scene;
ctx.views.camera.list.draw_materials(
scene,
ctx.pipelines,
&mut pass,
GeometryPass::Fsr2Composition,
&|material| scene.drawn_material(material).surface_moves(),
);
drop(pass);
ctx.views.camera.recorded_since(started);
}
fn encode_blended(
ctx: &mut FrameContext<'_>,
beauty: &wgpu::TextureView,
fsr2_masks: Option<&[wgpu::TextureView; 2]>,
cleared: bool,
group: &wgpu::BindGroup,
) {
let color = loaded(attachment(beauty), true);
let mut attachments = vec![color];
attachments.extend(
fsr2_masks
.into_iter()
.flatten()
.map(|mask| loaded(attachment(mask), cleared)),
);
let mut pass = ctx.encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("blended surfaces"),
color_attachments: &attachments,
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
view: &ctx.targets.depth,
depth_ops: None,
stencil_ops: None,
}),
timestamp_writes: ctx.timing.and_then(|t| t.render_pass("blended")),
..Default::default()
});
pass.set_bind_group(0, ctx.bindings.camera_lit(), &[]);
pass.set_bind_group(3, group, &[]);
let kind = GeometryPass::Blended {
fsr2_masks: fsr2_masks.is_some(),
};
ctx.views.blended.draw(
ctx.scene,
ctx.pipelines,
&ctx.views.instances,
&mut pass,
kind,
);
}
pub fn encode_heat(&mut self, ctx: &mut FrameContext<'_>, color: &wgpu::TextureView) {
self.heat.encode(
ctx.device,
ctx.queue,
ctx.encoder,
&ctx.scene.transient,
&ctx.values.view.view_projection,
ctx.sizes.scene,
color,
&ctx.targets.depth,
ctx.timing,
);
}
}
#[cfg(all(test, not(target_arch = "wasm32")))]
mod blended_tests;
#[cfg(all(test, not(target_arch = "wasm32")))]
mod composition_tests;
#[cfg(all(test, not(target_arch = "wasm32")))]
mod effects_tests;
#[cfg(all(test, not(target_arch = "wasm32")))]
mod receiver_tests;
#[cfg(all(test, not(target_arch = "wasm32")))]
mod transmission_tests;
fn loaded(
mut target: Option<wgpu::RenderPassColorAttachment<'_>>,
load: bool,
) -> Option<wgpu::RenderPassColorAttachment<'_>> {
if load {
target.as_mut().unwrap().ops.load = wgpu::LoadOp::Load;
}
target
}