Shader packs, clean room 39: shadow buffers, their samplers and shadowcomp

When the shadow pass runs, the pack gets real shadow buffers (spec 6.3):
shadowtex0 (cleared to 1.0 every frame), shadowtex1 (a copy, made only when
a program reads it) and shadowcolor0/1 (each with two sides, made only when
used, cleared to their ShadowClear colour, white by default), square at
shadowMapResolution within the device's limit.

Samplers: shadowtex0/watershadow, shadowtex1, `shadow` (shadowtex1 beside
watershadow) and the HW forms read the shadow map, through a linear depth
comparison when declared sampler2DShadow; shadowcolor/shadowcolor0/1 read
the colour buffers. In the shadow programs, buffer n is shadowcolor n and
colortex reads a stand-in. Without the shadow pass nothing changes: the
names read the stand-ins as before.

shadowcomp..shadowcomp99 run after the shadow pass and before prepare, each
drawing into the alt side of the shadowcolor buffers it writes and flipping
them after, as composite programs do with colortex (6.1.6). The shadow pass
itself draws nothing yet, so the map stays clear.

Clean-room: implemented from cleanroom/shader-packs-spec.md revision 1,
sections 2.1, 5.2 (samplers), 6.1.6 and 6.3; no other loader's code read.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-25 16:25:47 +01:00
parent 86d8d9e3a1
commit 6320718491
3 changed files with 397 additions and 30 deletions
+1
View File
@@ -73,6 +73,7 @@ pub mod pack_draw;
mod pack_entities;
mod pack_hand;
mod pack_post;
mod pack_shadow;
mod pack_sky;
mod pack_timing;
pub mod pack_uniforms;
+246 -30
View File
@@ -37,6 +37,10 @@ enum Source {
/// The block atlas (pack_atlas.rs), in gbuffers programs.
Atlas,
Lightmap,
/// `shadowtex0`/`shadowtex1` (6.3), with depth comparison (`sampler2DShadow`) or not.
ShadowDepth(usize, bool),
/// `shadowcolor0/1` read outside the shadow programs (in them they are `Color`).
ShadowColor(usize),
}
#[derive(Clone)]
@@ -63,13 +67,17 @@ enum SamplerKind {
impl SamplerKind {
fn of(source: Source, filtering: bool) -> Self {
match source {
Source::Color(_) | Source::Dummy if !filtering => Self::Nearest,
Source::Depth | Source::Depth1 => Self::Nearest,
Source::Color(_) | Source::ShadowColor(_) | Source::Dummy if !filtering => {
Self::Nearest
}
Source::Depth | Source::Depth1 | Source::ShadowDepth(_, false) => Self::Nearest,
Source::Noise => Self::Repeat,
Source::Shadow => Self::Comparison,
Source::Shadow | Source::ShadowDepth(_, true) => Self::Comparison,
// Blocks look as the game draws them: nearest texels.
Source::Atlas => Self::NearestRepeat,
Source::Color(_) | Source::Dummy | Source::Lightmap => Self::Linear,
Source::Color(_) | Source::ShadowColor(_) | Source::Dummy | Source::Lightmap => {
Self::Linear
}
}
}
@@ -158,6 +166,8 @@ struct Pass {
flip: u16,
/// Buffers sampled, for the bind group cache key.
reads: u16,
/// shadowcolor buffers sampled by a program of the other buffers.
shadow_reads: u16,
/// Buffers written.
written: u16,
/// Buffers whose mip chain is regenerated right before it (6.1.7).
@@ -168,9 +178,9 @@ struct Pass {
atlas: Option<wgpu::TextureView>,
/// Reads `mc_Entity`'s table (`PackPost::block_ids`).
ids: bool,
/// Bind groups by the sides read (low 16 bits) and the buffers whose mip chain is current
/// (high 16 bits).
groups: HashMap<u32, wgpu::BindGroup>,
/// Bind groups by the sides read (bits 0–15), the buffers whose mip chain is current (bits
/// 16–31) and the shadowcolor sides read (bits 32–33).
groups: HashMap<u64, wgpu::BindGroup>,
}
/// One side of a buffer with mipmaps.
@@ -258,6 +268,9 @@ pub struct PackPost {
hand: Option<(Pass, super::pack_hand::PackHand)>,
/// A program after translucent terrain reads `depthtex1`: it is copied before water.
depth1: bool,
/// The shadow buffers, when the shadow pass runs (2.5), and the `shadowcomp` programs.
shadow_targets: Option<super::pack_shadow::ShadowTargets>,
shadow_comp: Vec<Pass>,
/// Buffers with mipmaps (filterable ones a program asks them for).
mipped: u16,
/// Buffers whose mip chain matches their first level, this frame.
@@ -342,7 +355,37 @@ fn texture_format(f: Format, features: wgpu::Features) -> wgpu::TextureFormat {
}
}
fn source(name: &str) -> Source {
/// The texture behind sampler `name` in a program of the shadow buffers (`shadow_space`: buffer
/// n is shadowcolor n) or of the others, when the shadow pass runs (`shadow_pass`). `shadow` is
/// `shadowtex1` when the program also declares `watershadow` (6.3).
fn source(name: &str, shadow_space: bool, shadow_pass: bool, watershadow: bool) -> Source {
let shadow_color = match name {
"shadowcolor" | "shadowcolor0" => Some(0),
"shadowcolor1" => Some(1),
_ => None,
};
let shadow_depth = match name {
"shadowtex0" | "watershadow" | "shadowtex0HW" => Some(0),
"shadowtex1" | "shadowtex1HW" => Some(1),
"shadow" => Some(usize::from(watershadow)),
_ => None,
};
if shadow_pass {
if let Some(n) = shadow_depth {
return Source::ShadowDepth(n, name.ends_with("HW"));
}
if let Some(n) = shadow_color {
return if shadow_space {
Source::Color(n)
} else {
Source::ShadowColor(n)
};
}
}
if shadow_space && horizon_shaders::buffer_index(name).is_some() {
// colortex buffers are not this pass's.
return Source::Dummy;
}
match name {
"depthtex0" | "gdepthtex" => Source::Depth,
// The hand is drawn after the pack, so `depthtex2` (without it) is `depthtex1`.
@@ -606,11 +649,15 @@ pub(super) struct Geometry<'a> {
}
/// The pass of program `p`: a quad, or `geometry` drawn by the game. `None` (with a note) when
/// wgpu refuses it or it writes nothing.
/// wgpu refuses it or it writes nothing. `formats` are its buffers' (for a program of the shadow
/// buffers, buffer n is shadowcolor n); `shadow` the shadowcolor formats when the shadow pass
/// runs.
#[allow(clippy::too_many_arguments)]
fn build_pass(
device: &wgpu::Device,
p: horizon_shaders::PostProgram,
formats: &[wgpu::TextureFormat; BUFFERS],
shadow: Option<&[wgpu::TextureFormat; 2]>,
screen: wgpu::TextureFormat,
notes: &mut Vec<String>,
geometry: Option<&Geometry<'_>>,
@@ -639,6 +686,8 @@ fn build_pass(
let mut samplers = Vec::new();
let (mut kinds, mut slots) = (HashMap::new(), HashMap::new());
let mut reads = 0u16;
let mut shadow_reads = 0u16;
let watershadow = interface.samplers.iter().any(|s| s.name == "watershadow");
// A gbuffers pass draws into its buffers and the depth buffer: reading them as well would
// be a feedback loop (undefined in GL, refused by wgpu), so those read a blank texture.
let in_place = match geometry {
@@ -646,8 +695,10 @@ fn build_pass(
None => 0,
};
for s in &interface.samplers {
let mut src = source(&s.name);
let mut src = source(&s.name, p.group.shadow(), shadow.is_some(), watershadow);
let blank = match src {
// The shadow pass writes the shadow map.
Source::ShadowDepth(..) => p.group == Group::Shadow,
Source::Atlas => geometry.is_none(),
Source::Depth => geometry.is_some(),
// Translucent terrain reads the copy; opaque terrain would read itself.
@@ -660,14 +711,23 @@ fn build_pass(
Source::Color(n) => formats[n]
.sample_type(None, Some(features))
.unwrap_or(float),
Source::Depth | Source::Depth1 => wgpu::TextureSampleType::Float { filterable: false },
Source::ShadowColor(n) => shadow
.and_then(|f| f[n].sample_type(None, Some(features)))
.unwrap_or(float),
Source::Depth | Source::Depth1 | Source::ShadowDepth(..) => {
wgpu::TextureSampleType::Float { filterable: false }
}
// Unfilterable on WebGPU-level devices; the lightmap is sampled at texel centres.
Source::Lightmap => float,
_ => float,
};
let int = !matches!(sample_type, wgpu::TextureSampleType::Float { .. });
if s.ty == "sampler2DShadow" {
(src, sample_type) = (Source::Shadow, wgpu::TextureSampleType::Depth);
src = match src {
Source::ShadowDepth(n, _) => Source::ShadowDepth(n, true),
_ => Source::Shadow,
};
sample_type = wgpu::TextureSampleType::Depth;
}
let wanted = match s.ty.as_str() {
"sampler2DShadow" => true,
@@ -683,7 +743,9 @@ fn build_pass(
));
(src, sample_type) = (Source::Dummy, float);
}
if blank {
if blank && sample_type == wgpu::TextureSampleType::Depth {
src = Source::Shadow;
} else if blank {
// The blank texture is float: an integer sampler then fails the pipeline (a note).
src = Source::Dummy;
if int {
@@ -691,8 +753,10 @@ fn build_pass(
}
}
let filtering = sample_type == float;
if let Source::Color(n) = src {
reads |= 1 << n;
match src {
Source::Color(n) => reads |= 1 << n,
Source::ShadowColor(n) => shadow_reads |= 1 << n,
_ => {}
}
entries.push(texture_entry(s.binding, sample_type));
let kind = SamplerKind::of(src, filtering);
@@ -849,6 +913,7 @@ fn build_pass(
writes,
flip,
reads,
shadow_reads,
written,
mipmaps: p.mipmaps,
draw,
@@ -892,18 +957,32 @@ impl PackPost {
|flips: &[(u32, bool)]| flips.iter().filter(|f| f.1).fold(0u16, |m, f| m | 1 << f.0);
let mut used = 1u16;
let draws = DrawUniforms::new(device);
// The shadow buffers' formats when the shadow pass runs; their programs see them as
// buffers 0 and 1.
let shadow_formats: Option<[wgpu::TextureFormat; 2]> = post.shadow_pass.then(|| {
std::array::from_fn(|n| texture_format(shadow_config.colors[n].format, features))
});
let shadow_space: [wgpu::TextureFormat; BUFFERS] = std::array::from_fn(|i| {
shadow_formats
.filter(|_| i < 2)
.map_or(formats[i], |f| f[i])
});
let mut build = |p: horizon_shaders::PostProgram, geometry: Option<&Geometry<'_>>| {
let in_shadow = p.group.shadow();
let pass = build_pass(
device,
p,
&formats,
if in_shadow { &shadow_space } else { &formats },
shadow_formats.as_ref(),
screen,
&mut notes,
geometry,
&custom_names,
&draws.layout,
)?;
used |= pass.reads | pass.written | pass.flip;
if !in_shadow {
used |= pass.reads | pass.written | pass.flip;
}
Some(pass)
};
// Flat terrain reads `mc_Entity` from a table of the sprite layers.
@@ -1036,6 +1115,12 @@ impl PackPost {
.filter(|p| !skip.split(',').any(|s| s == p.name))
.filter_map(|p| build(p, None))
.collect();
let shadow_comp: Vec<Pass> = post
.shadow_comp
.into_iter()
.filter(|p| !skip.split(',').any(|s| s == p.name))
.filter_map(|p| build(p, None))
.collect();
if let Some(t) = &terrain {
notes.push(format!("terrain draws with {}", t.name));
}
@@ -1077,6 +1162,39 @@ impl PackPost {
.chain(&water)
.chain(weather.iter().take(1).flatten())
.any(|p| p.samplers.iter().any(|s| s.source == Source::Depth1));
let every_pass = || {
(passes
.iter()
.chain(&shadow_comp)
.chain(&terrain)
.chain(&water))
.chain(sky.iter().flat_map(|s| s.basic.iter().chain(&s.textured)))
.chain(entities.iter().flat_map(|e| e.passes.iter().flatten()))
.chain(&clouds)
.chain(weather.iter().flatten())
.chain(hand.iter().map(|h| &h.0))
};
let shadow_targets = shadow_formats.map(|f| {
let colors = every_pass().fold(0u16, |m, p| {
let own = if p.group.shadow() {
p.reads | p.written | p.flip
} else {
0
};
m | own | p.shadow_reads
});
let depth1 = every_pass()
.flat_map(|p| &p.samplers)
.any(|s| matches!(s.source, Source::ShadowDepth(1, _)));
let t =
super::pack_shadow::ShadowTargets::new(device, &shadow_config, f, colors, depth1);
notes.push(format!(
"shadow map {0}x{0}, shadowcolor buffers {colors:#b}{1}",
t.size,
if depth1 { ", shadowtex1" } else { "" }
));
t
});
// A clear only matters when a program reads the buffer before one writes all of it
// (composite passes cover their whole target, terrain does not); the others are skipped.
let mut cleared = Vec::new();
@@ -1215,6 +1333,8 @@ impl PackPost {
weather_generation: 0,
hand,
depth1,
shadow_targets,
shadow_comp,
mipped,
mips_valid: 0,
down,
@@ -1319,17 +1439,43 @@ impl PackPost {
queue.write_buffer(&pass.ubo, 0, &pass.block);
}
let targets = self.targets.as_ref().expect("resized");
let shadow = self.shadow_targets.as_ref();
let shadow_main = shadow.map_or(0, |s| s.main);
let shadow_space = pass.group.shadow();
// A chain is sampled only while it is current: a buffer written since its last chain
// reads its first level, never stale levels (6.1.7).
let current = self.mips_valid & self.mipped & pass.reads;
let key = u32::from(self.main & pass.reads) | u32::from(current) << 16;
// reads its first level, never stale levels (6.1.7). The shadow buffers have none.
let (main, current) = if shadow_space {
(shadow_main, 0)
} else {
(self.main, self.mips_valid & self.mipped & pass.reads)
};
let key = u64::from(main & pass.reads)
| u64::from(current) << 16
| u64::from(shadow_main & pass.shadow_reads) << 32;
let group = pass.groups.entry(key).or_insert_with(|| {
let mut entries = vec![wgpu::BindGroupEntry {
binding: 0,
resource: pass.ubo.as_entire_binding(),
}];
for s in &pass.samplers {
let shadow_color = |i: usize, side: usize| {
shadow.and_then(|t| t.color[i].as_ref()).map(|c| &c[side])
};
let texture = match s.source {
Source::Color(i) if shadow_space => {
shadow_color(i, usize::from(key & 1 << i != 0)).unwrap_or(&self.dummy)
}
Source::ShadowColor(i) => {
shadow_color(i, usize::from(key & 1 << (32 + i) != 0))
.unwrap_or(&self.dummy)
}
Source::ShadowDepth(i, _) => match shadow {
Some(t) => match (i, &t.depth1) {
(1, Some(d)) => &d.1,
_ => &t.depth.1,
},
None => &self.shadow.0,
},
Source::Color(i) => {
let side = usize::from(key & 1 << i != 0);
match (&targets.mips[i], &targets.color[i]) {
@@ -1366,7 +1512,7 @@ impl PackPost {
SamplerKind::Nearest => &self.nearest,
SamplerKind::Repeat => &self.repeat,
SamplerKind::NearestRepeat => &self.nearest_repeat,
SamplerKind::Comparison => &self.shadow.1,
SamplerKind::Comparison => shadow.map_or(&self.shadow.1, |t| &t.comparison),
};
entries.push(wgpu::BindGroupEntry {
binding: s.binding,
@@ -1399,15 +1545,20 @@ impl PackPost {
load: wgpu::LoadOp::Load,
store: wgpu::StoreOp::Store,
};
// The shadow pass draws into the shadow buffers and the shadow map.
let shadow = self.shadow_targets.as_ref().filter(|_| pass.group.shadow());
let mut attachments: Vec<Option<wgpu::RenderPassColorAttachment>> = Vec::new();
for &(location, buffer) in &pass.writes {
let l = location as usize;
if attachments.len() <= l {
attachments.resize(l + 1, None);
}
attachments[l] = targets.color[buffer]
.as_ref()
.and_then(|t| attach(&t[usize::from(self.main & 1 << buffer != 0)], load));
attachments[l] = match shadow {
Some(s) => s.color(buffer, false).and_then(|v| attach(v, load)),
None => targets.color[buffer]
.as_ref()
.and_then(|t| attach(&t[usize::from(self.main & 1 << buffer != 0)], load)),
};
}
let timestamp_writes = self.timing.as_mut().and_then(|t| t.writes(&pass.name));
encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
@@ -1415,7 +1566,7 @@ impl PackPost {
color_attachments: &attachments,
timestamp_writes,
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
view: &targets.depth,
view: shadow.map_or(&targets.depth, |s| &s.depth.1),
depth_ops: Some(wgpu::Operations {
load: wgpu::LoadOp::Load,
store: wgpu::StoreOp::Store,
@@ -1933,6 +2084,55 @@ impl PackPost {
/// Runs the pack over the world drawn into `world` (colour) and `world_depth`, then draws
/// the result onto `screen`.
#[allow(clippy::too_many_arguments)]
/// The shadow pass (2.1, passes 2 and 3): the shadow buffers cleared, then the `shadowcomp`
/// programs, each drawing into the "alt" side of what it writes and flipping it after.
fn run_shadow(
&mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
encoder: &mut wgpu::CommandEncoder,
) {
let Some(t) = &self.shadow_targets else {
return;
};
t.clear(encoder);
t.copy_depth1(encoder);
let size = [t.size; 2];
let mut comp = std::mem::take(&mut self.shadow_comp);
for pass in &mut comp {
let group = self.bind(device, queue, pass, size);
let t = self.shadow_targets.as_ref().expect("shadow pass");
let mut attachments: Vec<Option<wgpu::RenderPassColorAttachment>> = Vec::new();
for &(location, buffer) in &pass.writes {
let l = location as usize;
if attachments.len() <= l {
attachments.resize(l + 1, None);
}
// Overwritten whole.
let ops = wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),
store: wgpu::StoreOp::Store,
};
attachments[l] = t.color(buffer, true).and_then(|v| attach(v, ops));
}
{
let mut rp = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some(&pass.name),
color_attachments: &attachments,
timestamp_writes: self.timing.as_mut().and_then(|t| t.writes(&pass.name)),
..Default::default()
});
rp.set_pipeline(&pass.pipeline);
rp.set_bind_group(0, &group, &[]);
rp.draw(0..6, 0..1);
}
if let Some(t) = &mut self.shadow_targets {
t.main ^= pass.flip;
}
}
self.shadow_comp = comp;
}
pub fn run(
&mut self,
device: &wgpu::Device,
@@ -1978,6 +2178,10 @@ impl PackPost {
}
self.uniforms.update(frame, inputs, size);
self.uniforms.eval_custom(&mut self.custom);
if self.targets.is_none() {
return;
}
self.run_shadow(device, queue, encoder);
let Some(targets) = &self.targets else { return };
let main = |m: u16, i: usize| usize::from(m & 1 << i != 0);
let view = |m: u16, i: usize, alt: bool| {
@@ -2249,10 +2453,22 @@ mod tests {
#[test]
fn sampler_names() {
assert!(source("gaux1") == Source::Color(4));
assert!(source("gdepthtex") == Source::Depth);
assert!(source("depthtex2") == Source::Depth1);
assert!(source("noisetex") == Source::Noise);
assert!(source("shadowcolor0") == Source::Dummy);
let main = |n| source(n, false, false, false);
assert!(main("gaux1") == Source::Color(4));
assert!(main("gdepthtex") == Source::Depth);
assert!(main("depthtex2") == Source::Depth1);
assert!(main("noisetex") == Source::Noise);
// Without the shadow pass, the shadow buffers are stand-ins.
assert!(main("shadowcolor0") == Source::Dummy);
assert!(main("shadowtex0") == Source::Dummy);
// With it: shadowcolor n is buffer n of the shadow programs, `shadow` is shadowtex1
// beside `watershadow` (6.3), and colortex is not theirs.
assert!(source("shadowcolor", false, true, false) == Source::ShadowColor(0));
assert!(source("shadowcolor1", true, true, false) == Source::Color(1));
assert!(source("colortex1", true, true, false) == Source::Dummy);
assert!(source("shadow", false, true, false) == Source::ShadowDepth(0, false));
assert!(source("shadow", false, true, true) == Source::ShadowDepth(1, false));
assert!(source("watershadow", false, true, true) == Source::ShadowDepth(0, false));
assert!(source("shadowtex1HW", false, true, false) == Source::ShadowDepth(1, true));
}
}
@@ -0,0 +1,150 @@
//! A shader pack's shadow buffers (spec 6.3): the shadow map's depth (`shadowtex0`, and
//! `shadowtex1` without translucent geometry), and the colour buffers `shadowcolor0/1`, each
//! with two sides that `shadowcomp` programs flip as composite programs flip colortex (6.1.6).
//! Square, `shadowMapResolution` pixels.
/// What the shadow pass writes and the programs read.
pub(super) struct ShadowTargets {
pub size: u32,
/// `shadowtex0`, written by the shadow pass.
pub depth: (wgpu::Texture, wgpu::TextureView),
/// `shadowtex1`: a copy of `shadowtex0` taken before translucent terrain, when read.
pub depth1: Option<(wgpu::Texture, wgpu::TextureView)>,
/// Both sides of each shadowcolor buffer used.
pub color: [Option<[wgpu::TextureView; 2]>; 2],
/// The clear colour of each buffer cleared every frame.
pub clears: [Option<[f32; 4]>; 2],
/// Bit n set: B is shadowcolor n's "main".
pub main: u16,
/// Depth comparison for `sampler2DShadow` (hardware filtering): linear, as GL filters it.
pub comparison: wgpu::Sampler,
}
fn target(
device: &wgpu::Device,
label: &str,
size: u32,
format: wgpu::TextureFormat,
copy: wgpu::TextureUsages,
) -> (wgpu::Texture, wgpu::TextureView) {
let texture = device.create_texture(&wgpu::TextureDescriptor {
label: Some(label),
size: wgpu::Extent3d {
width: size,
height: size,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::RENDER_ATTACHMENT | copy,
view_formats: &[],
});
let view = texture.create_view(&Default::default());
(texture, view)
}
impl ShadowTargets {
/// The buffers of `shadow` the pack uses: `colors` (bit n: shadowcolor n), `depth1` when
/// some program reads `shadowtex1`. The resolution is kept within the device's limit.
pub fn new(
device: &wgpu::Device,
shadow: &horizon_shaders::Shadow,
formats: [wgpu::TextureFormat; 2],
colors: u16,
depth1: bool,
) -> Self {
let size = shadow
.resolution
.clamp(1, device.limits().max_texture_dimension_2d);
let copy = wgpu::TextureUsages::COPY_SRC | wgpu::TextureUsages::COPY_DST;
let depth = wgpu::TextureFormat::Depth32Float;
let color = std::array::from_fn(|n| {
(colors & 1 << n != 0).then(|| {
[0, 1].map(|side| {
let label = format!("Shader pack shadowcolor{n} {}", ["A", "B"][side]);
target(
device,
&label,
size,
formats[n],
wgpu::TextureUsages::empty(),
)
.1
})
})
});
Self {
size,
depth: target(device, "Shader pack shadowtex0", size, depth, copy),
depth1: depth1.then(|| target(device, "Shader pack shadowtex1", size, depth, copy)),
color,
clears: std::array::from_fn(|n| {
let b = &shadow.colors[n];
b.clear.then(|| b.clear_color.unwrap_or([1.0; 4]))
}),
main: 0,
comparison: device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("Shader pack shadow comparison"),
compare: Some(wgpu::CompareFunction::LessEqual),
mag_filter: wgpu::FilterMode::Linear,
min_filter: wgpu::FilterMode::Linear,
..Default::default()
}),
}
}
/// Side `alt` (of "main" and "alt") of shadowcolor `n`.
pub fn color(&self, n: usize, alt: bool) -> Option<&wgpu::TextureView> {
let side = usize::from(self.main & 1 << n != 0) ^ usize::from(alt);
self.color.get(n)?.as_ref().map(|c| &c[side])
}
/// Clears the shadow map and the shadowcolor buffers cleared every frame (6.3).
pub fn clear(&self, encoder: &mut wgpu::CommandEncoder) {
let attachments: Vec<_> = (0..2)
.filter_map(|n| {
let c = self.clears[n]?;
Some(Some(wgpu::RenderPassColorAttachment {
view: self.color(n, false)?,
depth_slice: None,
resolve_target: None,
ops: wgpu::Operations {
load: wgpu::LoadOp::Clear(wgpu::Color {
r: c[0].into(),
g: c[1].into(),
b: c[2].into(),
a: c[3].into(),
}),
store: wgpu::StoreOp::Store,
},
}))
})
.collect();
encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Shader pack shadow clear"),
color_attachments: &attachments,
depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
view: &self.depth.1,
depth_ops: Some(wgpu::Operations {
load: wgpu::LoadOp::Clear(1.0),
store: wgpu::StoreOp::Store,
}),
stencil_ops: None,
}),
..Default::default()
});
}
/// `shadowtex1`: the shadow map as it is now (before translucent geometry).
pub fn copy_depth1(&self, encoder: &mut wgpu::CommandEncoder) {
if let Some((copy, _)) = &self.depth1 {
encoder.copy_texture_to_texture(
self.depth.0.as_image_copy(),
copy.as_image_copy(),
self.depth.0.size(),
);
}
}
}