Files
2026-11-10 20:22:40 -05:00

903 lines
45 KiB
Rust
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
use texturecraft_compose::{DisplayKind, ImageRes};
use texturecraft_geom::glam::Vec3;
use texturecraft_geom::{OrbitCamera, primitives};
use texturecraft_render::headless::Headless;
use texturecraft_render::renderer::TAA_SAMPLES;
use texturecraft_render::{BakeVisualization, Frame, Shade, ViewKind};
/// The UI's key light (`viewport::shade`).
const LIGHT: [f32; 4] = [0.5, 0.8, 0.4, 2.5];
struct Img {
w: u32,
px: Vec<u8>,
}
/// Two renders of the same image: equal within one 8-bit level per channel (software
/// adapters such as llvmpipe round some shader paths differently from hardware).
#[track_caller]
fn assert_same(a: &Img, b: &Img, msg: &str) {
assert_eq!(a.px.len(), b.px.len(), "{msg}: sizes differ");
let worst = a.px.iter().zip(&b.px).map(|(x, y)| x.abs_diff(*y)).max().unwrap_or(0);
assert!(worst <= 1, "{msg}: pixels differ by up to {worst} levels");
}
impl Img {
fn at(&self, x: u32, y: u32) -> [u8; 3] {
let i = ((y * self.w + x) * 4) as usize;
[self.px[i], self.px[i + 1], self.px[i + 2]]
}
fn luma(&self, x: u32, y: u32) -> f32 {
let [r, g, b] = self.at(x, y);
0.2126 * r as f32 + 0.7152 * g as f32 + 0.0722 * b as f32
}
/// Mean luma over a rectangle.
fn mean(&self, x0: u32, y0: u32, x1: u32, y1: u32) -> f32 {
let mut sum = 0.0;
for y in y0..y1 {
for x in x0..x1 {
sum += self.luma(x, y);
}
}
sum / ((x1 - x0) * (y1 - y0)) as f32
}
}
/// The id `setup` uploads the material ball under
const MESH_ID: u64 = 1;
/// A headless renderer with the material ball framed in a 480×360 view (None without a GPU).
fn setup() -> Option<(Headless, Frame)> {
let Ok(mut h) = Headless::new() else {
eprintln!("skipping: no GPU adapter");
return None;
};
eprintln!("headless adapter: {:?}", h.device.adapter_info());
let mesh = primitives::material_ball();
h.renderer.set_mesh(&h.device, &h.queue, &mesh, MESH_ID);
h.renderer.set_texture_sets(&h.device, &h.queue, &[((256, 256), 0), ((256, 256), 1)], 2);
let mut cam = OrbitCamera { yaw: 0.6, pitch: 0.25, ..OrbitCamera::default() };
let (lo, hi) = mesh.bounds();
cam.frame(lo, hi);
let frame =
Frame { view_id: 1, size: [480, 360], kind: ViewKind::Scene, camera: cam, shade: Shade::default(), visible: vec![true, true], overlay: Vec::new() };
Some((h, frame))
}
fn render(h: &mut Headless, frame: &Frame, name: &str) -> Img {
let (w, hgt, px) = h.render(frame).expect("readback");
assert_eq!((w, hgt), (frame.size[0], frame.size[1]));
if let Ok(dir) = std::env::var("TC_SNAPSHOT_DIR") {
image::save_buffer(format!("{dir}/{name}.png"), &px, w, hgt, image::ColorType::Rgba8).expect("save snapshot");
}
Img { w, px }
}
fn shaded(frame: &Frame, f: impl FnOnce(&mut Shade)) -> Frame {
let mut out = frame.clone();
f(&mut out.shade);
out
}
#[test]
fn renders_the_material_ball() {
let Some((mut h, frame)) = setup() else { return };
let img = render(&mut h, &frame, "headless_ball");
assert_ne!(img.at(240, 140), img.at(5, 5), "mesh should differ from background");
// UV view of set 0.
let uv = Frame { view_id: 2, kind: ViewKind::Uv { ts: 0, zoom: 1.0, pan: [0.0, 0.0] }, ..frame.clone() };
let uv_img = render(&mut h, &uv, "headless_uv");
assert_eq!(uv_img.px.len(), img.px.len());
let wire = render(&mut h, &shaded(&uv, |s| s.wireframe = true), "headless_uv_wire");
assert_ne!(wire.px, uv_img.px, "the UV wireframe draws");
}
#[test]
fn exposure_brightens_the_material_but_not_data_views() {
let Some((mut h, frame)) = setup() else { return };
let base = render(&mut h, &frame, "exposure_0");
let bright = render(&mut h, &shaded(&frame, |s| s.exposure_ev = 1.0), "exposure_plus1");
let (b0, b1) = (base.mean(200, 100, 280, 180), bright.mean(200, 100, 280, 180));
assert!(b1 > b0 + 10.0, "exposure +1 brightens the ball ({b0} → {b1})");
assert_eq!(base.at(5, 5), bright.at(5, 5), "the flat backdrop ignores exposure");
let ch = shaded(&frame, |s| {
s.view_mode = 1;
s.channel = 0;
});
let a = render(&mut h, &ch, "channel_base_color");
let b = render(&mut h, &shaded(&ch, |s| s.exposure_ev = 2.0), "channel_base_color_ev2");
assert_eq!(a.px, b.px, "data views ignore exposure");
// Default base color 188 (sRGB) shows unchanged in the channel view.
let [r, ..] = a.at(240, 140);
assert!(r.abs_diff(188) <= 1, "base color channel shows the raw value, got {r}");
}
#[test]
fn post_effects() {
let Some((mut h, frame)) = setup() else { return };
let base = render(&mut h, &frame, "post_off");
// Strengths without the master switch change nothing.
let gated = render(
&mut h,
&shaded(&frame, |s| {
s.vignette = 1.0;
s.bloom = 1.0;
s.grain = 1.0;
s.sharpen = 1.0;
}),
"post_gated",
);
assert_eq!(base.px, gated.px, "effects are off without post_effects");
let on = |f: fn(&mut Shade)| {
shaded(&frame, |s| {
s.post_effects = true;
f(s);
})
};
let vignette = render(&mut h, &on(|s| s.vignette = 1.0), "post_vignette");
assert!(vignette.mean(0, 0, 20, 20) < base.mean(0, 0, 20, 20) - 5.0, "vignette darkens the corners");
assert!((vignette.luma(240, 180) - base.luma(240, 180)).abs() < 1.5, "vignette keeps the center");
// A bright environment and +2 EV so highlights pass the bloom threshold.
let hot = |s: &mut Shade| {
s.exposure_ev = 2.0;
s.env_opacity = 1.0;
};
let hot_base = render(&mut h, &shaded(&frame, hot), "post_hot");
let bloom = render(
&mut h,
&on(|s| {
s.exposure_ev = 2.0;
s.env_opacity = 1.0;
s.bloom = 1.0;
}),
"post_bloom",
);
assert!(bloom.mean(0, 0, 480, 360) > hot_base.mean(0, 0, 480, 360) + 0.5, "bloom adds light");
let sharpen = render(&mut h, &on(|s| s.sharpen = 1.0), "post_sharpen");
assert_ne!(sharpen.px, base.px, "sharpen changes edges");
let grain = render(&mut h, &on(|s| s.grain = 1.0), "post_grain");
assert_ne!(grain.px, base.px, "grain adds noise");
let all = render(
&mut h,
&on(|s| {
s.bloom = 0.6;
s.vignette = 0.5;
s.sharpen = 0.4;
s.grain = 0.3;
}),
"post_all",
);
assert_eq!(all.px.len(), base.px.len());
}
/// The shadow pass draws the displaced (dense) mesh when the view displaces: with flat height it
/// casts the same shadows as the plain mesh.
#[test]
fn displaced_shadows_match_flat_height() {
let Some((mut h, frame)) = setup() else { return };
let lit = shaded(&frame, |s| {
s.light = LIGHT;
s.shadows = true;
});
let plain = render(&mut h, &lit, "shadows_plain");
let displaced = render(&mut h, &shaded(&lit, |s| s.displacement = true), "shadows_displaced");
let off = plain.px.chunks(4).zip(displaced.px.chunks(4)).filter(|(a, b)| a.iter().zip(*b).any(|(x, y)| x.abs_diff(*y) > 8)).count();
assert!(off < 480 * 360 / 100, "{off} pixels differ");
}
#[test]
fn shadows_darken_the_key_light() {
let Some((mut h, frame)) = setup() else { return };
let lit = shaded(&frame, |s| s.light = LIGHT);
let a = render(&mut h, &lit, "shadows_off");
let b = render(&mut h, &shaded(&lit, |s| s.shadows = true), "shadows_on");
let (mut darker, mut brighter) = (0, 0);
for y in 0..360 {
for x in 0..480 {
let d = b.luma(x, y) - a.luma(x, y);
darker += (d < -8.0) as u32;
brighter += (d > 2.0) as u32;
}
}
assert!(darker > 1000, "the ball shadows its pedestal ({darker} darker pixels)");
assert_eq!(brighter, 0, "shadows never brighten");
// From above, where the pedestal top shows the ball's shadow.
let mut top = shaded(&lit, |s| s.shadows = true);
top.camera.pitch = 0.9;
render(&mut h, &top, "shadows_on_top");
// Rotating the environment turns the key light and its shadow.
let turned = render(
&mut h,
&shaded(&lit, |s| {
s.shadows = true;
s.env_rotation_deg = 120.0;
}),
"shadows_env_rotated",
);
assert_ne!(turned.px, b.px);
}
#[test]
fn wireframe_3d_overlays_the_mesh() {
let Some((mut h, frame)) = setup() else { return };
let a = render(&mut h, &frame, "wire3d_off");
let b = render(&mut h, &shaded(&frame, |s| s.wireframe_3d = true), "wire3d_on");
assert_ne!(a.mean(200, 100, 280, 180), b.mean(200, 100, 280, 180), "edges draw over the ball");
assert_eq!(a.at(5, 5), b.at(5, 5), "the background stays clean");
}
#[test]
fn bake_visualization_draws_the_high_poly_and_the_cage() {
// A high poly inside the material ball, a cage around it, and how far a color must lead the others to count as that color
const HIGH_POLY_RADIUS_PER_SIZE: f32 = 0.3;
const CAGE_SCALE: f32 = 2.5;
const HIGH_POLY_ID: u64 = 7;
const CAGE_TOPOLOGY: u64 = 1;
const CAGE_EDGES: [[u32; 2]; 2] = [[0, 1], [1, 2]];
const COLOR_LEAD: i32 = 30;
let Some((mut h, frame)) = setup() else { return };
let ball = primitives::material_ball();
let (low_min, low_max) = ball.bounds();
let ball_center = (low_min + low_max) * 0.5;
let mut high = primitives::sphere((low_max - low_min).max_element() * HIGH_POLY_RADIUS_PER_SIZE, 32, 16);
for position in &mut high.positions {
*position += ball_center;
}
h.renderer.set_bake_high(&h.device, &h.queue, Some(&high), HIGH_POLY_ID).unwrap();
let corners: Vec<Vec3> = high.indices.iter().map(|index| (high.positions[*index as usize] - ball_center) * CAGE_SCALE + ball_center).collect();
h.renderer.set_bake_cage(&h.device, &h.queue, 0, Some((&corners, &CAGE_EDGES)), CAGE_TOPOLOGY);
let bake = BakeVisualization { high_poly: false, cage: false, uv_seams: false, low_poly: true, only_set: None };
let center = (frame.size[0] / 2, frame.size[1] / 2);
let only = |h: &mut Headless, parts: BakeVisualization, name: &str| render(h, &shaded(&frame, |s| s.bake = Some(parts)), name);
let low_only = only(&mut h, bake, "bake_low_only");
let hidden = only(&mut h, BakeVisualization { low_poly: false, ..bake }, "bake_low_hidden");
let high_poly = only(&mut h, BakeVisualization { low_poly: false, high_poly: true, ..bake }, "bake_high_poly");
let caged = only(&mut h, BakeVisualization { cage: true, ..bake }, "bake_cage");
assert_same(&low_only, &render(&mut h, &frame, "bake_off"), "every part off draws only the low poly");
let background = render(&mut h, &Frame { visible: vec![false, false], ..frame.clone() }, "bake_background");
assert_same(&hidden, &background, "without the low poly only the background is left");
let [red, green, blue] = high_poly.at(center.0, center.1).map(i32::from);
assert!(blue > red + COLOR_LEAD && blue > green, "the high poly inside the low poly draws blue: {:?}", [red, green, blue]);
let ([low_red, low_green, low_blue], [caged_red, caged_green, caged_blue]) = (low_only.at(center.0, center.1), caged.at(center.0, center.1));
assert!(
caged_blue < low_blue && caged_red >= caged_blue && caged_green >= caged_blue,
"the cage tints the ball tan: {:?} → {:?}",
[low_red, low_green, low_blue],
[caged_red, caged_green, caged_blue]
);
// Vertices the bake's rays miss turn red
h.renderer.set_bake_high_missed(&h.queue, HIGH_POLY_ID, &vec![1.0; high.positions.len()]);
let missed = only(&mut h, BakeVisualization { low_poly: false, high_poly: true, ..bake }, "bake_high_missed");
let [red, green, blue] = missed.at(center.0, center.1).map(i32::from);
assert!(red > blue + COLOR_LEAD && red > green + COLOR_LEAD, "missed vertices draw red: {:?}", [red, green, blue]);
// Show for selected texture set only: the other set's low poly and the cage of set 0 drop out
let first_set = only(&mut h, BakeVisualization { cage: true, only_set: Some(0), ..bake }, "bake_only_first_set");
let second_set = only(&mut h, BakeVisualization { cage: true, only_set: Some(1), ..bake }, "bake_only_second_set");
assert_ne!(first_set.px, caged.px, "the second set's low poly is left out");
assert_ne!(second_set.px, caged.px, "the first set's low poly and cage are left out");
assert_ne!(first_set.px, second_set.px);
// UV seams draw over the low poly
h.renderer.set_uv_seams(&h.device, &h.queue, MESH_ID, &ball.uv_seam_edges());
let seams = only(&mut h, BakeVisualization { uv_seams: true, ..bake }, "bake_uv_seams");
assert_ne!(seams.px, low_only.px, "the seams show");
// A new distance with the same topology only moves the corners
let grown: Vec<Vec3> = corners.iter().map(|corner| (*corner - ball_center) * 2.0 + ball_center).collect();
h.renderer.set_bake_cage(&h.device, &h.queue, 0, Some((&grown, &CAGE_EDGES)), CAGE_TOPOLOGY);
let bigger = only(&mut h, BakeVisualization { cage: true, ..bake }, "bake_cage_grown");
assert_ne!(caged.px, bigger.px, "the cage grew");
}
#[test]
fn oversized_bake_high_poly_leaves_the_view_renderable() {
let Some((mut headless, frame)) = setup() else { return };
let high = primitives::sphere(0.5, 16, 8);
headless.renderer.set_bake_high(&headless.device, &headless.queue, Some(&high), 1).unwrap();
let limit = headless.device.limits().max_buffer_size;
// The viewport vertex contains position, normal, tangent and UV: twelve f32 values
let vertex_count = limit as usize / (12 * std::mem::size_of::<f32>()) + 1;
let oversized = texturecraft_geom::Mesh { positions: vec![Vec3::ZERO; vertex_count], ..Default::default() };
let error = headless.renderer.set_bake_high(&headless.device, &headless.queue, Some(&oversized), 2).unwrap_err();
assert!(error.contains("GPU buffer limit"), "{error}");
headless.renderer.set_bake_high_missed(&headless.queue, 2, &[]);
let bake = BakeVisualization { high_poly: true, cage: false, uv_seams: false, low_poly: false, only_set: None };
let cleared = render(&mut headless, &shaded(&frame, |shade| shade.bake = Some(bake)), "bake_oversized_cleared");
let background = render(&mut headless, &Frame { visible: vec![false, false], ..frame.clone() }, "bake_oversized_background");
assert_same(&cleared, &background, "an oversized replacement must not leave the previous high poly visible");
headless.renderer.set_bake_high(&headless.device, &headless.queue, Some(&high), 3).unwrap();
let recovered = render(&mut headless, &shaded(&frame, |shade| shade.bake = Some(bake)), "bake_oversized_recovered");
assert_ne!(recovered.px, background.px, "a later valid high poly still draws");
}
#[test]
fn bake_low_poly_visibility_also_filters_its_wireframe() {
let Some((mut headless, frame)) = setup() else { return };
let bake = BakeVisualization { high_poly: false, cage: false, uv_seams: false, low_poly: false, only_set: None };
let hidden = shaded(&frame, |shade| {
shade.bake = Some(bake);
shade.wireframe_3d = true;
shade.highlight = Some(texturecraft_render::SetHighlight { set: 0, color: [1.0, 0.5, 0.0] });
});
let background = render(&mut headless, &Frame { visible: vec![false, false], ..frame.clone() }, "bake_wire_background");
let hidden_wire = render(&mut headless, &hidden, "bake_wire_hidden");
assert_same(&hidden_wire, &background, "hiding the project mesh also hides its wireframe and highlight");
for texture_set in [0, 1] {
let selected = shaded(&hidden, |shade| {
shade.bake = Some(BakeVisualization { low_poly: true, only_set: Some(texture_set), ..bake });
shade.highlight = Some(texturecraft_render::SetHighlight { set: 1 - texture_set, color: [1.0, 0.5, 0.0] });
});
let expected = Frame { visible: vec![texture_set == 0, texture_set == 1], ..selected.clone() };
let actual = render(&mut headless, &selected, &format!("bake_wire_selected_{texture_set}"));
let expected = render(&mut headless, &expected, &format!("bake_wire_expected_{texture_set}"));
assert_same(&actual, &expected, "the wireframe and highlight respect the selected texture set");
}
}
#[test]
fn ortho_background_matches_perspective() {
let Some((mut h, frame)) = setup() else { return };
let env = shaded(&frame, |s| s.env_opacity = 1.0);
let persp = render(&mut h, &env, "env_perspective");
let ortho = render(&mut h, &Frame { camera: OrbitCamera { ortho: true, ..env.camera }, ..env.clone() }, "env_ortho");
for (x, y) in [(5, 5), (474, 5), (5, 354), (474, 354), (240, 5)] {
assert_eq!(persp.at(x, y), ortho.at(x, y), "background at {x},{y}");
}
assert_ne!(ortho.at(5, 5), ortho.at(240, 5), "the environment varies across the view");
}
/// Frame cost at 1920×1080: `cargo test -p texturecraft-render --release -- --ignored --nocapture`.
#[test]
#[ignore]
fn bench_1080p() {
let Some((mut h, frame)) = setup() else { return };
h.renderer.set_texture_sets(&h.device, &h.queue, &[((2048, 2048), 0), ((2048, 2048), 1)], 2);
let frame = Frame { size: [1920, 1080], ..frame };
let run = |h: &mut Headless, frame: &Frame| {
for _ in 0..5 {
h.render(frame);
}
let t = std::time::Instant::now();
for _ in 0..100 {
let mut enc = h.device.create_command_encoder(&Default::default());
h.renderer.prepare(&h.device, &h.queue, &mut enc, frame);
h.queue.submit([enc.finish()]);
let _ = h.device.poll(texturecraft_render::wgpu::PollType::Wait { submission_index: None, timeout: None });
}
t.elapsed().as_secs_f64() * 1000.0 / 100.0
};
println!("adapter: {}", h.adapter_name);
println!("default: {:.3} ms/frame", run(&mut h, &frame));
let effects = shaded(&frame, |s| {
s.post_effects = true;
s.bloom = 0.5;
s.vignette = 0.5;
s.sharpen = 0.5;
s.grain = 0.5;
});
println!("post effects: {:.3} ms/frame", run(&mut h, &effects));
let shadows = shaded(&frame, |s| {
s.light = LIGHT;
s.shadows = true;
});
println!("shadows (cached map): {:.3} ms/frame", run(&mut h, &shadows));
let wire = shaded(&frame, |s| s.wireframe_3d = true);
println!("3D wireframe: {:.3} ms/frame", run(&mut h, &wire));
let all = shaded(&effects, |s| {
s.light = LIGHT;
s.shadows = true;
s.wireframe_3d = true;
});
println!("everything: {:.3} ms/frame", run(&mut h, &all));
println!("parallax occlusion: {:.3} ms/frame", run(&mut h, &shaded(&frame, |s| s.parallax = true)));
println!("depth of field: {:.3} ms/frame", run(&mut h, &shaded(&frame, |s| s.dof = Some([0.0, 0.1]))));
println!("subsurface blur: {:.3} ms/frame", run(&mut h, &shaded(&frame, |s| s.sss_blur = Some([0.1, 0.04, 0.025]))));
let both = shaded(&frame, |s| {
s.dof = Some([0.0, 0.1]);
s.sss_blur = Some([0.1, 0.04, 0.025]);
});
println!("depth of field + subsurface blur: {:.3} ms/frame", run(&mut h, &both));
println!("displacement (dense copy): {:.3} ms/frame", run(&mut h, &shaded(&frame, |s| s.displacement = true)));
println!("screen-space refraction: {:.3} ms/frame", run(&mut h, &shaded(&frame, |s| s.refraction = true)));
// Every extra lobe painted (full-size lobe textures), with the key light.
fill_res(&mut h, 2048, &[0, 1], DisplayKind::Lobes, &[255, 25, 200, 60]);
fill_res(&mut h, 2048, &[0, 1], DisplayKind::Sheen, &[200, 150, 255, 200]);
fill_res(&mut h, 2048, &[0, 1], DisplayKind::Emissive, &[0, 0, 0, 200]);
println!("all lobes: {:.3} ms/frame", run(&mut h, &frame));
println!("all lobes + key light: {:.3} ms/frame", run(&mut h, &shaded(&frame, |s| s.light = LIGHT)));
let taa = shaded(&frame, |s| s.taa = true);
h.render(&taa);
let t = std::time::Instant::now();
for _ in 1..TAA_SAMPLES {
let mut enc = h.device.create_command_encoder(&Default::default());
h.renderer.prepare(&h.device, &h.queue, &mut enc, &taa);
h.queue.submit([enc.finish()]);
let _ = h.device.poll(texturecraft_render::wgpu::PollType::Wait { submission_index: None, timeout: None });
}
println!("TAA accumulation: {:.3} ms/sample", t.elapsed().as_secs_f64() * 1000.0 / f64::from(TAA_SAMPLES - 1));
// Shadow map re-rendered every frame (light moving).
let t = std::time::Instant::now();
for i in 0..100 {
let f = shaded(&shadows, |s| s.env_rotation_deg = i as f32);
let mut enc = h.device.create_command_encoder(&Default::default());
h.renderer.prepare(&h.device, &h.queue, &mut enc, &f);
h.queue.submit([enc.finish()]);
let _ = h.device.poll(texturecraft_render::wgpu::PollType::Wait { submission_index: None, timeout: None });
}
println!("shadows, light moving: {:.3} ms/frame", t.elapsed().as_secs_f64() * 1000.0 / 100.0);
}
/// Fill the height texture of both 256² sets: `f(x, y)` → (height, F0 r, g, b).
fn upload_height(h: &mut Headless, f: impl Fn(u32, u32) -> [f32; 4]) {
for ts in 0..2 {
for (tx, ty) in (0..16).map(|i| (i % 4, i / 4)) {
let bytes: Vec<u8> = (0..64 * 64).flat_map(|i| f(tx * 64 + i % 64, ty * 64 + i / 64)).flat_map(|v| half::f16::from_f32(v).to_le_bytes()).collect();
h.renderer.upload_tile(&h.device, &h.queue, ts, DisplayKind::Height, tx, ty, &bytes);
}
}
}
/// Mean of red minus blue over the ball.
fn warmth(img: &Img) -> f32 {
let mut sum = 0.0;
for y in 100..180 {
for x in 200..280 {
let [r, _, b] = img.at(x, y);
sum += r as f32 - b as f32;
}
}
sum / 6400.0
}
#[test]
fn imported_hdr_environment_lights_the_ball() {
let Some((mut h, frame)) = setup() else { return };
let base = render(&mut h, &frame, "env_default");
// A procedural HDR: a hot orange sky over a dim blue ground (values far above 1).
let (w, hh) = (256u32, 128u32);
let rgba = (0..w * hh).map(|i| if i / w < hh / 2 { [12.0, 4.0, 1.0, 1.0] } else { [0.02, 0.05, 0.2, 1.0] }).collect();
let sky = ImageRes { width: w, height: hh, rgba, srgb: false };
h.renderer.set_environment(&h.device, &h.queue, "resource:sky.hdr", Some(&sky));
let lit = render(&mut h, &frame, "env_hdr_resource");
assert_ne!(lit.px, base.px, "the imported environment changes the lighting");
assert!(warmth(&lit) > warmth(&base) + 10.0, "the orange sky tints the ball");
assert!(lit.mean(200, 100, 280, 180) > 20.0, "lit, finite shading (NaNs would render black)");
h.renderer.set_environment(&h.device, &h.queue, "Studio Soft", None);
assert_eq!(render(&mut h, &frame, "env_default_again").px, base.px, "built-ins come back");
}
#[test]
fn specular_glossiness_takes_f0_from_the_specular_color() {
let Some((mut h, frame)) = setup() else { return };
upload_height(&mut h, |_, _| [0.0, 1.0, 0.6, 0.1]);
let mr = render(&mut h, &frame, "shader_metal_rough");
let sg = render(&mut h, &shaded(&frame, |s| s.spec_gloss = true), "shader_spec_gloss_gold");
assert!(warmth(&sg) > warmth(&mr) + 10.0, "a gold F0 tints the reflections ({} vs {})", warmth(&sg), warmth(&mr));
assert!(sg.mean(200, 100, 280, 180) > 20.0);
}
#[test]
fn parallax_follows_the_height_channel() {
let Some((mut h, frame)) = setup() else { return };
let pom = shaded(&frame, |s| s.parallax = true);
// A flat height field: parallax changes nothing.
let (off, on) = (render(&mut h, &frame, "parallax_flat_off"), render(&mut h, &pom, "parallax_flat_on"));
assert!(off.px.iter().zip(&on.px).all(|(a, b)| a.abs_diff(*b) <= 2), "flat heights keep the UVs");
upload_height(&mut h, |x, y| [if (x / 16 + y / 16) % 2 == 0 { 0.8 } else { -0.8 }, 0.04, 0.04, 0.04]);
let (off, on) = (render(&mut h, &frame, "parallax_off"), render(&mut h, &pom, "parallax_on"));
assert_ne!(off.px, on.px, "a checker height field shifts the textures");
assert!(on.mean(200, 100, 280, 180) > 20.0);
}
#[test]
fn idle_accumulation_converges_then_stops() {
let Some((mut h, frame)) = setup() else { return };
let taa = shaded(&frame, |s| s.taa = true);
let first = render(&mut h, &taa, "taa_first");
assert_eq!(first.px, render(&mut h, &frame, "taa_off").px, "the first sample is the plain frame");
render(&mut h, &taa, "taa_first_again");
for _ in 1..TAA_SAMPLES {
assert!(h.renderer.accumulating(1));
render(&mut h, &taa, "taa_sample");
}
assert!(!h.renderer.accumulating(1), "converged after {TAA_SAMPLES} samples");
let last = render(&mut h, &taa, "taa_converged");
assert_ne!(last.px, first.px, "jittered samples smooth the edges");
assert_eq!(render(&mut h, &taa, "taa_idle").px, last.px, "a converged view keeps its image");
render(&mut h, &shaded(&taa, |s| s.env_rotation_deg = 30.0), "taa_changed");
assert!(h.renderer.accumulating(1), "a change restarts accumulation");
}
// ---- Extra lobes (clear coat, sheen, anisotropy, subsurface scattering) -----------------------
/// Fill a display texture of texture sets `sets` (256², see `setup`) with one texel.
fn fill(h: &mut Headless, sets: &[usize], kind: DisplayKind, texel: &[u8]) {
fill_res(h, 256, sets, kind, texel);
}
fn fill_res(h: &mut Headless, res: u32, sets: &[usize], kind: DisplayKind, texel: &[u8]) {
let bytes = texel.repeat(64 * 64);
let n = res / 64;
for &ts in sets {
for (tx, ty) in (0..n * n).map(|i| (i % n, i / n)) {
h.renderer.upload_tile(&h.device, &h.queue, ts, kind, tx, ty, &bytes);
}
}
}
/// Pixels showing texture sets `sets`: those a change of their base color reaches. Leaves the
/// base color at its default.
fn mesh_mask(h: &mut Headless, frame: &Frame, sets: &[usize]) -> Vec<bool> {
fill(h, sets, DisplayKind::BaseColor, &[255, 0, 0, 255]);
let a = render(h, frame, "mask_red");
fill(h, sets, DisplayKind::BaseColor, &[0, 255, 0, 255]);
let b = render(h, frame, "mask_green");
fill(h, sets, DisplayKind::BaseColor, &DisplayKind::BaseColor.default_texel());
a.px.chunks(4).zip(b.px.chunks(4)).map(|(x, y)| x != y).collect()
}
/// Mean of `f(x, y)` over the pixels in `region`.
fn region_mean(region: &[bool], f: impl Fn(u32, u32) -> f32) -> f32 {
let (mut sum, mut n) = (0.0, 0.0);
for (i, _) in region.iter().enumerate().filter(|(_, r)| **r) {
sum += f(i as u32 % 480, i as u32 / 480);
n += 1.0;
}
sum / f32::max(n, 1.0)
}
/// Mesh pixels within `r` pixels of the silhouette (`near`), or farther from it.
fn rim(mask: &[bool], r: usize, near: bool) -> Vec<bool> {
let (w, h) = (480, mask.len() / 480);
let edge = |x: usize, y: usize| (y.saturating_sub(r)..(y + r + 1).min(h)).any(|yy| (x.saturating_sub(r)..(x + r + 1).min(w)).any(|xx| !mask[yy * w + xx]));
(0..mask.len()).map(|i| mask[i] && edge(i % w, i / w) == near).collect()
}
/// Σ|∂luma/∂y| / Σ|∂luma/∂x| inside `mask`: above 1 where the shading streaks sideways.
fn gradient_ratio(img: &Img, mask: &[bool]) -> f32 {
let (mut gx, mut gy) = (0.0, 0.0);
for y in 0..359 {
for x in 0..479 {
let at = |dx: u32, dy: u32| mask[((y + dy) * 480 + x + dx) as usize];
if at(0, 0) && at(1, 0) && at(0, 1) {
gx += (img.luma(x + 1, y) - img.luma(x, y)).abs();
gy += (img.luma(x, y + 1) - img.luma(x, y)).abs();
}
}
}
gy / f32::max(gx, 1e-3)
}
#[test]
fn lobe_channels_at_their_defaults_change_nothing() {
let Some((mut h, frame)) = setup() else { return };
let lit = shaded(&frame, |s| s.light = LIGHT);
let base = render(&mut h, &lit, "lobes_absent");
// Paint every lobe, then go back to the defaults: full-size textures shade like the placeholders.
fill(&mut h, &[0, 1], DisplayKind::Lobes, &[255, 200, 255, 90]);
fill(&mut h, &[0, 1], DisplayKind::Sheen, &[255, 0, 0, 255]);
fill(&mut h, &[0, 1], DisplayKind::Emissive, &[0, 0, 0, 255]);
fill(&mut h, &[0, 1], DisplayKind::Extra, &[255, 0, 255, 0]);
assert_ne!(render(&mut h, &lit, "lobes_painted").px, base.px);
for k in [DisplayKind::Lobes, DisplayKind::Sheen, DisplayKind::Emissive, DisplayKind::Extra] {
fill(&mut h, &[0, 1], k, &k.default_texel());
}
assert_same(&render(&mut h, &lit, "lobes_defaults"), &base, "default lobes change nothing");
}
#[test]
fn clear_coat_adds_a_sharp_highlight_over_a_rough_base() {
let Some((mut h, frame)) = setup() else { return };
let lit = shaded(&frame, |s| s.light = LIGHT);
let mask = mesh_mask(&mut h, &lit, &[0, 1]);
fill(&mut h, &[0, 1], DisplayKind::Orm, &[255, 255, 0, 128]);
let rough = render(&mut h, &lit, "coat_off");
fill(&mut h, &[0, 1], DisplayKind::Lobes, &[255, 13, 0, 0]);
let coated = render(&mut h, &lit, "coat_on");
let peak = |img: &Img| (0..mask.len()).filter(|i| mask[*i]).map(|i| img.luma(i as u32 % 480, i as u32 / 480)).fold(0.0, f32::max);
let (p0, p1) = (peak(&rough), peak(&coated));
assert!(p1 > p0 + 25.0, "the coat adds a highlight: peak {p0} -> {p1}");
// Elsewhere a thin layer of reflection replaces a little of the base.
let (m0, m1) = (region_mean(&mask, |x, y| rough.luma(x, y)), region_mean(&mask, |x, y| coated.luma(x, y)));
assert!((m1 - m0).abs() < 15.0, "mean {m0} -> {m1}");
}
#[test]
fn sheen_brightens_grazing_angles() {
let Some((mut h, frame)) = setup() else { return };
let mask = mesh_mask(&mut h, &frame, &[0, 1]);
fill(&mut h, &[0, 1], DisplayKind::BaseColor, &[30, 30, 30, 255]);
let plain = render(&mut h, &frame, "sheen_off");
fill(&mut h, &[0, 1], DisplayKind::Sheen, &[255, 255, 255, 255]);
let velvet = render(&mut h, &frame, "sheen_on");
let gain = |region: &[bool]| region_mean(region, |x, y| velvet.luma(x, y) - plain.luma(x, y));
let (g_edge, g_inner) = (gain(&rim(&mask, 4, true)), gain(&rim(&mask, 25, false)));
assert!(g_edge > 10.0 && g_edge > 1.5 * g_inner, "rim +{g_edge}, facing +{g_inner}");
}
#[test]
fn anisotropy_stretches_highlights_along_the_tangent() {
let Some((mut h, frame)) = setup() else { return };
let lit = shaded(&frame, |s| s.light = LIGHT);
let ball = mesh_mask(&mut h, &lit, &[0]);
// A smooth metal ball.
fill(&mut h, &[0], DisplayKind::Orm, &[255, 90, 255, 128]);
let iso = gradient_ratio(&render(&mut h, &lit, "aniso_off"), &ball);
fill(&mut h, &[0], DisplayKind::Lobes, &[0, 25, 255, 0]);
let along_u = gradient_ratio(&render(&mut h, &lit, "aniso_along_u"), &ball);
fill(&mut h, &[0], DisplayKind::Lobes, &[0, 25, 255, 128]);
let along_v = gradient_ratio(&render(&mut h, &lit, "aniso_along_v"), &ball);
// The tangent (+u) runs around the ball, across the screen: angle 0 streaks the reflections
// sideways, a quarter turn (angle 0.5) up and down.
assert!(along_u > 1.15 * iso && along_v < 0.6 * iso, "vertical/horizontal gradients: isotropic {iso}, angle 0 {along_u}, angle 0.5 {along_v}");
}
#[test]
fn subsurface_scattering_softens_the_terminator() {
let Some((mut h, frame)) = setup() else { return };
let lit = shaded(&frame, |s| s.light = LIGHT);
let mask = mesh_mask(&mut h, &lit, &[0, 1]);
fill(&mut h, &[0, 1], DisplayKind::BaseColor, &[230, 230, 230, 255]);
let lambert = render(&mut h, &lit, "sss_off");
fill(&mut h, &[0, 1], DisplayKind::Emissive, &[0, 0, 0, 255]);
let skin = render(&mut h, &lit, "sss_on");
// Quartiles of the Lambert shading: the shadowed side brightens and warms, contrast drops.
let luma_of = |i: usize| lambert.luma(i as u32 % 480, i as u32 / 480);
let mut lumas: Vec<f32> = (0..mask.len()).filter(|i| mask[*i]).map(luma_of).collect();
lumas.sort_by(f32::total_cmp);
let (q1, q3) = (lumas[lumas.len() / 4], lumas[lumas.len() * 3 / 4]);
let dark: Vec<bool> = (0..mask.len()).map(|i| mask[i] && luma_of(i) <= q1).collect();
let bright: Vec<bool> = (0..mask.len()).map(|i| mask[i] && luma_of(i) >= q3).collect();
let luma = |img: &Img, region: &[bool]| region_mean(region, |x, y| img.luma(x, y));
let warm = |img: &Img| region_mean(&dark, |x, y| img.at(x, y)[0] as f32 - img.at(x, y)[2] as f32);
assert!(luma(&skin, &dark) > luma(&lambert, &dark) + 3.0, "shadow side {} -> {}", luma(&lambert, &dark), luma(&skin, &dark));
assert!(luma(&skin, &bright) - luma(&skin, &dark) < luma(&lambert, &bright) - luma(&lambert, &dark), "contrast drops");
assert!(warm(&skin) > warm(&lambert) + 2.0, "the scatter color tints the falloff ({} -> {})", warm(&lambert), warm(&skin));
}
// ---- Transmission, coat normal, depth of field, subsurface blur --------------------------------
/// A base color checker (8-texel squares) on both sets, for detail to blur.
fn checker(h: &mut Headless) {
for ts in 0..2 {
for (tx, ty) in (0..16).map(|i| (i % 4, i / 4)) {
let bytes: Vec<u8> =
(0..64 * 64).flat_map(|i| if ((i % 64) / 8 + (i / 64) / 8) % 2 == 0 { [230, 230, 230, 255] } else { [20, 20, 20, 255] }).collect();
h.renderer.upload_tile(&h.device, &h.queue, ts, DisplayKind::BaseColor, tx, ty, &bytes);
}
}
}
/// Σ|∂luma/∂x| over `mask`: how much detail the image shows there.
fn detail(img: &Img, mask: &[bool]) -> f32 {
(0..mask.len())
.filter(|i| mask[*i] && i % 480 < 479 && mask[i + 1])
.map(|i| (img.luma(i as u32 % 480 + 1, i as u32 / 480) - img.luma(i as u32 % 480, i as u32 / 480)).abs())
.sum()
}
/// Mean |luma difference| over a square of side 2r around (x, y).
fn patch_diff(a: &Img, b: &Img, (x, y): (u32, u32), r: u32) -> f32 {
let mut sum = 0.0;
for yy in y - r..y + r {
for xx in x - r..x + r {
sum += (a.luma(xx, yy) - b.luma(xx, yy)).abs();
}
}
sum / (4 * r * r) as f32
}
/// View depth of the mesh under the view's center pixel.
fn center_depth(frame: &Frame) -> f32 {
let mesh = primitives::material_ball();
let bvh = texturecraft_geom::Bvh::new(&mesh);
let cam = frame.camera;
let ray = cam.ray(texturecraft_geom::glam::Vec2::ZERO, frame.size[0] as f32 / frame.size[1] as f32);
let hit = bvh.closest(ray.origin, ray.dir, f32::MAX).expect("the ball is in the middle");
(ray.origin + ray.dir * hit.t - cam.eye()).dot(cam.forward())
}
#[test]
fn depth_of_field_blurs_away_from_the_focus_plane() {
let Some((mut h, frame)) = setup() else { return };
let mask = mesh_mask(&mut h, &frame, &[0, 1]);
checker(&mut h);
let sharp = render(&mut h, &frame, "dof_off");
let dof = |focus: f32, aperture: f32| shaded(&frame, |s| s.dof = Some([focus, aperture]));
assert_same(&render(&mut h, &dof(0.0, 0.0), "dof_pinhole"), &sharp, "a pinhole lens changes nothing");
let z = center_depth(&frame);
let focused = render(&mut h, &dof(z, 0.15), "dof_focused");
let center = (frame.size[0] / 2, frame.size[1] / 2);
assert!(patch_diff(&focused, &sharp, center, 5) < 3.0, "the focus plane stays sharp: {}", patch_diff(&focused, &sharp, center, 5));
let far = render(&mut h, &dof(z * 10.0, 0.3), "dof_far_focus");
let (d_sharp, d_far) = (detail(&sharp, &mask), detail(&far, &mask));
assert!(d_far < 0.5 * d_sharp, "out of focus, the checker blurs: detail {d_sharp} -> {d_far}");
assert!(patch_diff(&far, &sharp, center, 5) > 5.0);
// Focused on the ball, it keeps more of its detail than focused far behind it.
assert!(detail(&focused, &mask) > d_far);
// Idle accumulation averages frames with the sampling spiral turned each time.
let taa = shaded(&dof(z * 10.0, 0.3), |s| s.taa = true);
assert_eq!(render(&mut h, &taa, "dof_taa_first").px, far.px, "the first sample is the plain frame");
for _ in 1..TAA_SAMPLES {
render(&mut h, &taa, "dof_taa_sample");
}
assert!(!h.renderer.accumulating(1));
assert_ne!(render(&mut h, &taa, "dof_taa_converged").px, far.px);
}
#[test]
fn subsurface_blur_spreads_only_scattering_light() {
let Some((mut h, frame)) = setup() else { return };
let lit = shaded(&frame, |s| s.light = LIGHT);
let mask = mesh_mask(&mut h, &lit, &[0, 1]);
checker(&mut h);
let plain = render(&mut h, &lit, "sss_blur_off");
let blur = shaded(&lit, |s| s.sss_blur = Some([0.06, 0.024, 0.015]));
assert_same(&render(&mut h, &blur, "sss_blur_no_weight"), &plain, "nothing scatters without the scattering weight");
fill(&mut h, &[0, 1], DisplayKind::Emissive, &[0, 0, 0, 255]);
let wrap = render(&mut h, &lit, "sss_wrap_only");
let blurred = render(&mut h, &blur, "sss_blur_on");
let (d0, d1) = (detail(&wrap, &mask), detail(&blurred, &mask));
assert!(d1 < 0.85 * d0, "the scattering light blurs the checker: detail {d0} -> {d1}");
// On a plain color the blur only moves light around the smooth shading (the checker's mean
// display value rises: averaging happens before the sRGB curve).
fill(&mut h, &[0, 1], DisplayKind::BaseColor, &[150, 150, 150, 255]);
let mean = |img: &Img| region_mean(&mask, |x, y| img.luma(x, y));
let (m0, m1) = (mean(&render(&mut h, &lit, "sss_plain_wrap")), mean(&render(&mut h, &blur, "sss_plain_blur")));
assert!((m1 - m0).abs() < 2.0, "the blur moves light, it adds none: {m0} -> {m1}");
}
/// An environment that is bright only around `dir` (world space, rotation 0).
fn spot_environment(dir: texturecraft_geom::glam::Vec3) -> ImageRes {
let (w, hh) = (256u32, 128u32);
let rgba = (0..w * hh)
.map(|i| {
let d = texturecraft_render::ibl::dir_of(((i % w) as f32 + 0.5) / w as f32, ((i / w) as f32 + 0.5) / hh as f32);
if d.dot(dir) > 0.5 { [6.0, 6.0, 6.0, 1.0] } else { [0.02, 0.02, 0.02, 1.0] }
})
.collect();
ImageRes { width: w, height: hh, rgba, srgb: false }
}
#[test]
fn transmission_shows_the_environment_behind_the_surface() {
let Some((mut h, frame)) = setup() else { return };
h.renderer.set_environment(&h.device, &h.queue, "resource:behind.hdr", Some(&spot_environment(frame.camera.forward())));
fill(&mut h, &[0, 1], DisplayKind::BaseColor, &[255, 255, 255, 255]);
fill(&mut h, &[0, 1], DisplayKind::Orm, &[255, 10, 0, 128]);
let center = (frame.size[0] / 2, frame.size[1] / 2);
let opaque = render(&mut h, &frame, "glass_off");
fill(&mut h, &[0, 1], DisplayKind::Extra, &[128, 128, 255, 0]);
let glass = render(&mut h, &frame, "glass_on");
let luma = |img: &Img| img.mean(center.0 - 4, center.1 - 4, center.0 + 4, center.1 + 4);
assert!(luma(&glass) > luma(&opaque) + 60.0, "the bright environment behind shows through: {} -> {}", luma(&opaque), luma(&glass));
}
#[test]
fn coat_normal_turns_the_coat_reflection() {
let Some((mut h, frame)) = setup() else { return };
let lit = shaded(&frame, |s| s.light = LIGHT);
let mask = mesh_mask(&mut h, &lit, &[0, 1]);
fill(&mut h, &[0, 1], DisplayKind::Lobes, &[255, 13, 0, 0]);
let flat = render(&mut h, &lit, "coat_normal_flat");
fill(&mut h, &[0, 1], DisplayKind::Extra, &[128, 128, 0, 0]);
assert_same(&render(&mut h, &lit, "coat_normal_default"), &flat, "the flat coat normal changes nothing");
fill(&mut h, &[0, 1], DisplayKind::Extra, &[230, 128, 0, 0]);
let tilted = render(&mut h, &lit, "coat_normal_tilted");
let diff = region_mean(&mask, |x, y| (tilted.luma(x, y) - flat.luma(x, y)).abs());
assert!(diff > 2.0, "a tilted coat normal moves the coat highlight: {diff}");
}
// ---- Displacement and screen-space refraction --------------------------------------------------
#[test]
fn displacement_moves_the_silhouette_by_the_height_channel() {
let Some((mut h, frame)) = setup() else { return };
let disp = shaded(&frame, |s| s.displacement = true);
// Flat heights: the dense copy draws the same surface (but for a few outline pixels where
// the split edges cover other MSAA samples).
let (off, on) = (render(&mut h, &frame, "disp_flat_off"), render(&mut h, &disp, "disp_flat_on"));
let moved = off.px.chunks(4).zip(on.px.chunks(4)).filter(|(a, b)| a.iter().zip(b.iter()).any(|(x, y)| x.abs_diff(*y) > 2)).count();
assert!(moved < 40, "flat heights leave the surface where it was ({moved} pixels differ)");
let area = |h: &mut Headless, f: &Frame| mesh_mask(h, f, &[0, 1]).iter().filter(|m| **m).count();
let base = area(&mut h, &frame);
upload_height(&mut h, |_, _| [0.5, 0.04, 0.04, 0.04]);
render(&mut h, &disp, "disp_raised");
let grown = area(&mut h, &disp);
assert!(grown > base + base / 50, "raised heights grow the silhouette: {base} -> {grown} pixels");
upload_height(&mut h, |_, _| [-0.5, 0.04, 0.04, 0.04]);
render(&mut h, &disp, "disp_lowered");
let shrunk = area(&mut h, &disp);
assert!(shrunk + base / 50 < base, "lowered heights shrink it: {base} -> {shrunk} pixels");
assert_eq!(area(&mut h, &frame), base, "without displacement heights only shade");
// A checker of heights reaches the shading and the outline.
upload_height(&mut h, |x, y| [if (x / 16 + y / 16) % 2 == 0 { 0.6 } else { -0.6 }, 0.04, 0.04, 0.04]);
let bumpy = render(&mut h, &shaded(&disp, |s| s.light = LIGHT), "disp_checker");
assert!(bumpy.mean(200, 100, 280, 180) > 20.0, "lit, finite shading");
}
#[test]
fn refraction_shows_the_scene_behind_transmissive_surfaces() {
let Some((mut h, frame)) = setup() else { return };
let refr = shaded(&frame, |s| s.refraction = true);
// The ball away from its outline (outline pixels mix in the pedestal behind them).
let ball = rim(&mesh_mask(&mut h, &frame, &[0]), 2, false);
assert_same(&render(&mut h, &refr, "refr_opaque"), &render(&mut h, &frame, "refr_opaque_off"), "without transmission nothing changes");
// A clear glass ball (set 0) on its pedestal (set 1), painted red, then green.
fill(&mut h, &[0], DisplayKind::BaseColor, &[255, 255, 255, 255]);
fill(&mut h, &[0], DisplayKind::Orm, &[255, 10, 0, 128]);
fill(&mut h, &[0], DisplayKind::Extra, &[128, 128, 255, 0]);
let seen = |h: &mut Headless, f: &Frame, name: &str| {
fill(h, &[1], DisplayKind::BaseColor, &[255, 0, 0, 255]);
let red = render(h, f, &format!("{name}_red"));
fill(h, &[1], DisplayKind::BaseColor, &[0, 255, 0, 255]);
let green = render(h, f, &format!("{name}_green"));
(0..ball.len()).filter(|i| ball[*i] && red.at(*i as u32 % 480, *i as u32 / 480) != green.at(*i as u32 % 480, *i as u32 / 480)).count()
};
assert_eq!(seen(&mut h, &frame, "refr_env"), 0, "refracting only the environment, the pedestal never shows through");
let through = seen(&mut h, &refr, "refr_scene");
let total = ball.iter().filter(|b| **b).count();
println!("refraction: the pedestal shows through {through} of {total} ball pixels");
assert!(through > total / 20, "the pedestal shows through the glass: {through} of {total} pixels");
// Rough glass blurs what it shows: fewer sharp edges across the ball.
fill(&mut h, &[1], DisplayKind::BaseColor, &[255, 0, 0, 255]);
checker(&mut h);
fill(&mut h, &[0], DisplayKind::BaseColor, &[255, 255, 255, 255]);
let clear = render(&mut h, &refr, "refr_clear_checker");
fill(&mut h, &[0], DisplayKind::Orm, &[255, 200, 0, 128]);
let frosted = render(&mut h, &refr, "refr_frosted_checker");
assert!(detail(&frosted, &ball) < detail(&clear, &ball), "frosted glass blurs the scene behind");
}
/// Kinds in [`DisplayKind::ALL`] order with each set's display texture widths, then the aux width.
fn widths(h: &Headless) -> Vec<Vec<u32>> {
h.renderer.display_textures().iter().map(|s| s.iter().map(|t| t.width()).collect()).collect()
}
#[test]
fn texture_sets_take_no_gpu_memory_until_painted() {
// A mesh with many materials (one texture set each) must not reserve full-size textures
// for every set up front: that ran a 4 GB GPU out of memory, and wgpu's handler aborted.
let Some((mut h, _)) = setup() else { return };
let sets: Vec<((u32, u32), usize)> = (0..40).map(|m| ((2048, 2048), m)).collect();
h.renderer.set_texture_sets(&h.device, &h.queue, &sets, 40);
assert!(widths(&h).iter().flatten().all(|w| *w == 1), "every display texture starts as a 1×1 placeholder");
assert!((0..40).all(|ts| h.renderer.aux_size(ts) == Some(1)), "so does every aux texture");
// A neutral tile changes nothing; the first painted one allocates that kind alone.
let kind = DisplayKind::BaseColor;
let neutral = kind.default_texel().repeat(64 * 64);
h.renderer.upload_tile(&h.device, &h.queue, 3, kind, 0, 0, &neutral);
assert_eq!(widths(&h)[3][0], 1);
h.renderer.upload_tile(&h.device, &h.queue, 3, kind, 0, 0, &[200, 30, 30, 255].repeat(64 * 64));
let w = widths(&h);
assert_eq!(w[3][0], 2048, "the painted kind is full size");
assert!(w[3][1..].iter().all(|w| *w == 1) && w[2].iter().all(|w| *w == 1), "nothing else was allocated");
// The aux texture is allocated by its first upload, at the set's aux size only.
h.renderer.upload_aux(&h.device, &h.queue, 3, 512, &[0; 512 * 512 * 4]);
assert_eq!(h.renderer.aux_size(3), Some(1), "a wrong aux size is ignored");
h.renderer.upload_aux(&h.device, &h.queue, 3, 2048, &[90; 2048 * 2048 * 4]);
assert_eq!(h.renderer.aux_size(3), Some(2048));
assert!(h.renderer.take_memory_failures().is_empty());
}
#[test]
fn painted_placeholders_render_like_full_textures() {
// A set painted in one kind renders that paint whether the other kinds are placeholders.
let Some((mut h, frame)) = setup() else { return };
let before = render(&mut h, &frame, "placeholders");
fill(&mut h, &[0, 1], DisplayKind::BaseColor, &[220, 40, 40, 255]);
let red = render(&mut h, &frame, "painted_base_color");
let (w, hgt) = (frame.size[0], frame.size[1]);
let [r0, g0, _] = before.at(w / 2, hgt / 2);
let [r1, g1, _] = red.at(w / 2, hgt / 2);
assert!(r1 > r0 && g1 < g0, "the painted base color shows: {:?} → {:?}", before.at(w / 2, hgt / 2), red.at(w / 2, hgt / 2));
}