SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Viewport: draw faded and see-through bodies from their plans with OIT (#7423)
Jackson Ourslandefa2cae0b407
diff --git a/assets/shaders/viewport.wgsl b/assets/shaders/viewport.wgslindex 7980b295f6..d4c0c46ad1 100644--- a/assets/shaders/viewport.wgsl+++ b/assets/shaders/viewport.wgsl@@ -37,6 +37,15 @@ fn clipped(p: vec3<f32>) -> bool {return length(u.clip.xyz) > 0.5 && dot(u.clip.xyz, p) > u.clip.w;}@group(0) @binding(0) var<uniform> u: U;+// The scene's colours, 2048 entries to a row: an R32Uint texture rather than a storage buffer,+// so the viewport draws on WebGL2 (which has no storage buffers) as well.+@group(0) @binding(1) var pal: texture_2d<u32>;++/// The colour at palette entry `i`, as byte/255 (the old Unorm8x4 conversion, bit for bit).+fn palette(i: u32) -> vec4<f32> {+ let v = textureLoad(pal, vec2<i32>(i32(i & 2047u), i32(i >> 11u)), 0).x;+ return vec4<f32>(f32(v & 255u), f32((v >> 8u) & 255u), f32((v >> 16u) & 255u), f32((v >> 24u) & 255u)) / 255.0;+}fn to_linear(c: vec3<f32>) -> vec3<f32> {return select(c, pow((c + vec3<f32>(0.055)) / vec3<f32>(1.055), vec3<f32>(2.4)), c > vec3<f32>(0.04045));@@ -57,11 +66,11 @@ struct TOut {};@vertex-fn vs_tri(@location(0) p: vec3<f32>, @location(1) n: vec3<f32>, @location(2) c: vec4<f32>) -> TOut {+fn vs_tri(@location(0) p: vec3<f32>, @location(1) n: vec3<f32>, @location(2) c: u32) -> TOut {var o: TOut;o.pos = u.vp * vec4<f32>(p, 1.0);o.n = n;- o.c = c;+ o.c = palette(c);o.wp = p;return o;}@@ -76,14 +85,14 @@ fn vs_tri_inst(@location(3) r0: vec4<f32>,@location(4) r1: vec4<f32>,@location(5) r2: vec4<f32>,- @location(6) c: vec4<f32>,+ @location(6) c: u32,) -> TOut {let q = vec4<f32>(p, 1.0);let wp = vec3<f32>(dot(r0, q), dot(r1, q), dot(r2, q));var o: TOut;o.pos = u.vp * vec4<f32>(wp, 1.0);o.n = vec3<f32>(dot(r0.xyz, n), dot(r1.xyz, n), dot(r2.xyz, n));- o.c = c;+ o.c = palette(c);o.wp = wp;return o;}@@ -106,14 +115,14 @@ fn vs_tri_inst_flat(@location(3) r0: vec4<f32>,@location(4) r1: vec4<f32>,@location(5) r2: vec4<f32>,- @location(6) c: vec4<f32>,+ @location(6) c: u32,) -> FOut {let q = vec4<f32>(p, 1.0);let wp = vec3<f32>(dot(r0, q), dot(r1, q), dot(r2, q));var o: FOut;o.pos = u.vp * vec4<f32>(wp, 1.0);o.rp = wp - u.eye.xyz;- o.c = c;+ o.c = palette(c);return o;}@@ -546,7 +555,7 @@ fn lifted_z(p: vec3<f32>, c: vec4<f32>, px: f32, half: vec2<f32>) -> f32 {}@vertex-fn vs_line(@builtin(vertex_index) vi: u32, @location(0) a: vec3<f32>, @location(1) b: vec3<f32>, @location(2) c: vec4<f32>, @location(3) wbits: u32) -> LOut {+fn vs_line(@builtin(vertex_index) vi: u32, @location(0) a: vec3<f32>, @location(1) b: vec3<f32>, @location(2) c: u32, @location(3) wbits: u32) -> LOut {var pa = a;var pb = b;var ca = u.vp * vec4<f32>(a, 1.0);@@ -596,7 +605,8 @@ fn vs_line(@builtin(vertex_index) vi: u32, @location(0) a: vec3<f32>, @location(}var o: LOut;o.pos = vec4<f32>(base.xy + off / half * base.w, z, base.w);- o.c = vec4<f32>(c.rgb, c.a * (wa / wd));+ let col = palette(c);+ o.c = vec4<f32>(col.rgb, col.a * (wa / wd));o.wp = select(pa, pb, t > 0.5);return o;}diff --git a/crates/gpu/src/capture.rs b/crates/gpu/src/capture.rsindex 25c99daa11..225c9923e7 100644--- a/crates/gpu/src/capture.rs+++ b/crates/gpu/src/capture.rs@@ -76,7 +76,7 @@ impl Capturer {let samples =if samples > 1 && flags(FORMAT).sample_count_supported(samples) && flags(depth).sample_count_supported(samples) { samples } else { 1 };let scopes = error_scopes(&device);- let renderer = Renderer::new(&device, GpuTarget { format: FORMAT, depth: Some(depth), samples, tess: false }, None);+ let renderer = Renderer::new(&device, GpuTarget { format: FORMAT, depth: Some(depth), samples, tess: false, oit: false }, None);let background = background_pipeline(&device, samples, depth);caught(scopes).map_or(Ok(()), |e| Err(GpuError::Pipeline(e)))?;let max_side = device.limits().max_texture_dimension_2d.min(MAX_SIDE);@@ -417,7 +417,7 @@ pub fn scene_geometry(scene: &Scene) -> GpuScene {let faces: HashMap<u32, Rgb> = m.face_colors.iter().copied().collect();let mesh = &m.mesh;for (ti, t) in mesh.triangles.iter().enumerate() {- let col = c4(mesh.tri_face.get(ti).and_then(|f| faces.get(f)).copied().unwrap_or(m.color));+ let col = sc.color(c4(mesh.tri_face.get(ti).and_then(|f| faces.get(f)).copied().unwrap_or(m.color)));let [Some(a), Some(b), Some(c)] = t.map(|k| mesh.positions.get(k as usize).copied()) else { continue };let flat = (b - a).cross(c - a).normalized().unwrap_or(Vec3::Z);for (k, p) in t.iter().zip([a, b, c]) {@@ -430,15 +430,17 @@ pub fn scene_geometry(scene: &Scene) -> GpuScene {}}}- let c4 = |c: Rgb, a: f32| [c.0, c.1, c.2, (a.clamp(0.0, 1.0) * 255.0).round() as u8];+ let alpha = |a: f32| (a.clamp(0.0, 1.0) * 255.0).round() as u8;for l in &scene.grid {+ let col = sc.color([l.color.0, l.color.1, l.color.2, alpha(l.alpha)]);for w in l.points.windows(2) {- sc.under_line(w[0].to_f32(), w[1].to_f32(), c4(l.color, l.alpha), l.width as f32);+ sc.under_line(w[0].to_f32(), w[1].to_f32(), col, l.width as f32);}}for l in &scene.lines {+ let col = sc.color([l.color.0, l.color.1, l.color.2, alpha(l.alpha)]);for w in l.points.windows(2) {- sc.line(w[0].to_f32(), w[1].to_f32(), c4(l.color, l.alpha), l.width as f32, l.on_top);+ sc.line(w[0].to_f32(), w[1].to_f32(), col, l.width as f32, l.on_top);}}sc@@ -567,9 +569,10 @@ mod tests {})}- /// The alpha of a triangle `scene_geometry` wrote (the last byte of its first vertex).- fn alpha(bytes: &[u8]) -> Option<u8> {- bytes.get(TRI_SIZE - 1).copied()+ /// The colour of a triangle `scene_geometry` wrote (its first vertex's palette entry).+ fn color(scene: &GpuScene, bytes: &[u8]) -> Option<[u8; 4]> {+ let index = bytes.get(TRI_SIZE - 4..TRI_SIZE)?.try_into().ok().map(u32::from_le_bytes)?;+ scene.palette.get(crate::view::PaletteIndex(index))}/// A body the design draws see-through goes into the scene's glass, at its own alpha, and@@ -582,17 +585,19 @@ mod tests {let solid = geometry(1.0);assert_eq!((solid.tris.len(), solid.glass.len()), (3 * TRI_SIZE, 0));- assert_eq!(alpha(&solid.tris), Some(255), "a solid body is drawn opaque");+ assert_eq!(color(&solid, &solid.tris), Some([200, 30, 30, 255]), "a solid body is drawn opaque");let glass = geometry(0.3);assert_eq!((glass.tris.len(), glass.glass.len()), (0, 3 * TRI_SIZE), "a see-through body is glass, not a solid triangle");- assert_eq!(alpha(&glass.glass), Some(77), "0.3 of 255");+ assert_eq!(color(&glass, &glass.glass).map(|c| c[3]), Some(77), "0.3 of 255");// The threshold and the floor are the viewport's: an appearance a hair under 1 stays// solid, and opacity 0 still leaves a trace rather than vanishing.let almost = geometry(0.9995);assert_eq!((almost.tris.len(), almost.glass.len()), (3 * TRI_SIZE, 0), "an appearance a hair under 1 is still solid");- assert_eq!(alpha(&geometry(0.0).glass), Some(13), "0.05 of 255");+ assert_eq!(color(&almost, &almost.tris).map(|c| c[3]), Some(255));+ let trace = geometry(0.0);+ assert_eq!(color(&trace, &trace.glass).map(|c| c[3]), Some(13), "0.05 of 255");}/// A face with a colour of its own is drawn in that colour, and takes its body's opacity:@@ -602,7 +607,6 @@ mod tests {let mesh = SceneMesh { mesh: sheet(), color: Rgb(200, 30, 30), face_colors: vec![(0, Rgb(0, 255, 0))], opacity: 0.5 };let sc = scene_geometry(&Scene { meshes: vec![mesh], ..Default::default() });assert_eq!(sc.tris.len(), 0);- let first = sc.glass.get(TRI_SIZE - 4..TRI_SIZE);- assert_eq!(first, Some(&[0, 255, 0, 128][..]), "the face's own colour at the body's alpha");+ assert_eq!(color(&sc, &sc.glass), Some([0, 255, 0, 128]), "the face's own colour at the body's alpha");}}diff --git a/crates/gpu/src/view.rs b/crates/gpu/src/view.rsindex 31dc62ae5e..28c6b76969 100644--- a/crates/gpu/src/view.rs+++ b/crates/gpu/src/view.rs@@ -23,15 +23,105 @@ mod oit;#[cfg(not(target_arch = "wasm32"))]pub use msaa_check::MsaaCheck;-/// Triangle vertex: position (3 × f32), normal (3 × f32), sRGB colour (4 × u8).+/// Triangle vertex: position (3 × f32), normal (3 × f32), palette index (u32).pub const TRI_SIZE: usize = 28;pub const PBR_SIZE: usize = pbr::VERTEX_SIZE;-/// Line instance: a, b (3 × f32 each), colour (4 × u8), width in pixels (f32).+/// Line instance: a, b (3 × f32 each), palette index (u32), width in pixels (f32).pub const LINE_SIZE: usize = 32;/// Placement of an [`InstancedMesh`]: the rows of its rigid move (3 × 4 f32; a point's x, y and z-/// are each row's dot product with (p, 1)), then its colour (4 × u8).+/// are each row's dot product with (p, 1)), then its palette index (u32).pub const INSTANCE_SIZE: usize = 52;+/// An index into a scene's [`Palette`]. Deliberately not convertible from a colour: every+/// producer must go through a palette, and the compiler should say so.+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]+#[repr(transparent)]+pub struct PaletteIndex(pub u32);++/// How many palette entries fit on one texel row: the shader reads `x = i & 2047`,+/// `y = i >> 11`. A power of two keeps the lookup a shift and a mask.+pub const PALETTE_WIDTH: u32 = 2048;+/// Most palette entries a scene may carry (2048 × 512): the palette is an `R32Uint` texture+/// (`downlevel_defaults`/WebGL2 have no storage buffers in the vertex stage).+pub const MAX_PALETTE: usize = 1 << 20;++/// sRGB RGBA bytes, looked up in the shader by [`PaletteIndex`].+///+/// The first [`Palette::stable_len`] entries are stable for a scene: cached block bytes keep+/// referring to them, so appearance edits only change their values. Entries after that are+/// interned per build for ephemeral geometry (grids, highlights, sketch, previews).+#[derive(Clone, Debug, Default)]+pub struct Palette {+ entries: Vec<[u8; 4]>,+ lookup: std::collections::HashMap<[u8; 4], u32>,+ stable_len: usize,+}++impl Palette {+ /// A palette whose entries are all stable (the model scene's body/face slots).+ pub fn with_stable(entries: Vec<[u8; 4]>) -> Palette {+ Palette { stable_len: entries.len(), entries, lookup: std::collections::HashMap::new() }+ }++ /// Where the stable entries end and the per-build interned ones begin.+ pub fn stable_len(&self) -> usize {+ self.stable_len+ }++ pub fn entries(&self) -> &[[u8; 4]] {+ &self.entries+ }++ pub fn len(&self) -> usize {+ self.entries.len()+ }++ pub fn is_empty(&self) -> bool {+ self.entries.is_empty()+ }++ /// The colour at `i`, if the palette has it.+ pub fn get(&self, i: PaletteIndex) -> Option<[u8; 4]> {+ self.entries.get(i.0 as usize).copied()+ }++ /// Set an entry's colour; `false` when the index is out of range. Stable entries are updated+ /// in place (what appearance and theme edits do); interned entries keep their lookup current.+ pub fn set(&mut self, i: PaletteIndex, rgba: [u8; 4]) -> bool {+ let at = i.0 as usize;+ let ephemeral = at >= self.stable_len;+ let Some(slot) = self.entries.get_mut(at) else { return false };+ if ephemeral {+ self.lookup.remove(slot);+ }+ *slot = rgba;+ if ephemeral {+ self.lookup.insert(rgba, i.0);+ }+ true+ }++ /// A colour's index in the per-build section, appended when it is new. At [`MAX_PALETTE`]+ /// the first entry stands in: far past what any real scene interns, and never a panic.+ pub fn intern(&mut self, rgba: [u8; 4]) -> PaletteIndex {+ if let Some(&i) = self.lookup.get(&rgba) {+ return PaletteIndex(i);+ }+ if self.entries.len() >= MAX_PALETTE {+ return PaletteIndex(0);+ }+ let i = u32::try_from(self.entries.len()).unwrap_or(0);+ self.entries.push(rgba);+ self.lookup.insert(rgba, i);+ PaletteIndex(i)+ }++ /// The palette as the shader's `R32Uint` texels (rgba bytes packed little-endian).+ pub fn texels(&self) -> Vec<u32> {+ self.entries.iter().map(|[r, g, b, a]| u32::from_le_bytes([*r, *g, *b, *a])).collect()+ }+}+/// The width slot of a lifted line ([`GpuScene::lifted_line`]): the top bit set (a plain line's/// width is a positive `f32`, whose top bit is clear), the width in eighths of a pixel (7 bits,/// up to 15.9 px), and the two faces' normals in octahedral form (6 bits a component). The@@ -64,12 +154,15 @@ fn octahedral6(n: [f32; 3]) -> u32 {/// whole-body highlight colours (`uniform_bytes`).const UNIFORM_SIZE: u64 = 416;-/// A body drawn from its display plan, evaluated on the GPU: the plan, and a colour per face-/// (the plan's face numbering; faces past the end take the last colour).+/// A body drawn from its display plan, evaluated on the GPU: the plan, and a palette index per+/// face (the plan's face numbering; faces past the end take the last index).#[derive(Clone)]pub struct PlannedBody {pub plan: Arc<solidcraft_geom::tess::TessPlan>,- pub face_colors: Vec<[u8; 4]>,+ pub face_colors: Vec<PaletteIndex>,+ /// How the whole body is drawn: opaque with the model, or faded or see-through blended+ /// order-independently (only on a renderer that does that: [`GpuTarget::oit`]).+ pub class: TriClass,}/// What the viewport's last frame drew, counted as it was drawn (the performance overlay, #2548).@@ -84,6 +177,23 @@ pub struct DrawStats {pub supersampled: bool,}+/// What the last scene change uploaded to the GPU, in bytes: what an edit costs beyond the CPU+/// work of building the scene. Counted per scene ([`Renderer::uploads`]).+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]+pub struct UploadStats {+ /// Triangle vertices, index lists and lines: of the blocks and of the scene's own lists, and+ /// the triangles shared by instanced meshes.+ pub geometry: u64,+ /// Placements of instanced meshes.+ pub placements: u64,+ /// Palette rows written.+ pub palette: u64,+ /// Planned bodies' per-vertex palette indices.+ pub planned: u64,+ /// Vertices of planned bodies evaluated again on the GPU (chunks whose plans changed).+ pub evaluated: u64,+}+/// The renderer's last [`DrawStats`], shared with the UI that shows them.pub type DrawStatsHandle = Arc<Mutex<DrawStats>>;@@ -296,12 +406,12 @@ pub struct InstancedMesh {}impl InstancedMesh {- /// Add a placement: `rows` of its rigid move (see [`INSTANCE_SIZE`]) and its colour.- pub fn place(&mut self, rows: [[f32; 4]; 3], color: [u8; 4]) {+ /// Add a placement: `rows` of its rigid move (see [`INSTANCE_SIZE`]) and its palette index.+ pub fn place(&mut self, rows: [[f32; 4]; 3], color: PaletteIndex) {for v in rows.iter().flatten() {self.instances.extend_from_slice(&v.to_le_bytes());}- self.instances.extend_from_slice(&color);+ self.instances.extend_from_slice(&color.0.to_le_bytes());}/// Its triangles at every placement, as the GPU draws them, appended to `out` (laid out as@@ -311,14 +421,14 @@ impl InstancedMesh {for inst in self.instances.as_chunks::<INSTANCE_SIZE>().0 {let row = |r: usize| [f(inst, 16 * r), f(inst, 16 * r + 4), f(inst, 16 * r + 8), f(inst, 16 * r + 12)];let rows = [row(0), row(1), row(2)];- let color = inst.get(48..52).unwrap_or(&[0; 4]);+ let index = inst.get(48..52).and_then(|b| b.try_into().ok()).map_or(0, u32::from_le_bytes);for (p, n) in self.tris.corners().flatten() {let moved = rows.map(|r| r[0] * p[0] + r[1] * p[1] + r[2] * p[2] + r[3]);let turned = rows.map(|r| r[0] * n[0] + r[1] * n[1] + r[2] * n[2]);for x in moved.iter().chain(&turned) {out.extend_from_slice(&x.to_le_bytes());}- out.extend_from_slice(color);+ out.extend_from_slice(&index.to_le_bytes());}}}@@ -333,6 +443,8 @@ impl InstancedMesh {/// highlight scene (hover, selection, the origin widget) changes often and is small.#[derive(Default, Clone)]pub struct GpuScene {+ /// The colours every vertex, line and instance index into.+ pub palette: Arc<Palette>,/// Opaque triangles. A zero normal draws the colour flat (unlit).pub tris: Vec<u8>,/// Opaque product PBR vertices; linear base color and explicit optical parameters.@@ -379,6 +491,10 @@ pub struct GpuScene {pub hover_blocks: Vec<BlockTris>,/// Whole selected bodies, as `hover_blocks`, in the selection colour.pub selected_blocks: Vec<BlockTris>,+ /// Whole highlighted bodies the model builds in its blocks but does not draw opaque (faded+ /// context, see-through): every one of their vertices drawn again, in this scene's palette,+ /// whose entries for their faces hold the highlight colour. No triangle is copied.+ pub recoloured: Vec<BlockTris>,/// Whole hovered bodies the model draws as placements of shared triangles: those meshes with/// the body's highlight colour on each placement.pub hover_instanced: Vec<InstancedMesh>,@@ -392,13 +508,25 @@ pub struct GpuScene {}impl GpuScene {+ /// A scene whose palette starts with `palette`'s stable entries (the model scene).+ pub fn with_palette(palette: Palette) -> GpuScene {+ GpuScene { palette: Arc::new(palette), ..Default::default() }+ }++ /// Intern an ephemeral colour (grid, highlight, sketch, preview) into this scene's palette.+ pub fn color(&mut self, rgba: [u8; 4]) -> PaletteIndex {+ Arc::make_mut(&mut self.palette).intern(rgba)+ }+/// The blocks' geometry moved into the scene's own lists, in drawing order (for tests that/// count what the scene holds).pub fn merged(mut self) -> GpuScene {- let mut out = GpuScene { glass: std::mem::take(&mut self.glass), ..Default::default() };+ let palette = self.palette.clone();+ let mut out = GpuScene { glass: std::mem::take(&mut self.glass), palette: palette.clone(), ..Default::default() };for block in std::mem::take(&mut self.blocks) {- out.tris.extend_from_slice(&block.bytes.tris);- out.trans.extend_from_slice(&block.bytes.trans);+ append_runs(&block.bytes.vertices, &block.bytes.opaque, &mut out.tris);+ append_runs(&block.bytes.vertices, &block.bytes.glass, &mut out.glass);+ append_runs(&block.bytes.vertices, &block.bytes.faded, &mut out.trans);out.lines.extend_from_slice(&block.bytes.lines);out.hidden.extend_from_slice(&block.bytes.hidden);}@@ -413,10 +541,32 @@ impl GpuScene {out.trans.append(&mut self.trans);out.lines.append(&mut self.lines);out.hidden.append(&mut self.hidden);- GpuScene { tris: out.tris, trans: out.trans, glass: out.glass, lines: out.lines, hidden: out.hidden, ..self }+ let palette = std::mem::replace(&mut self.palette, palette);+ GpuScene { palette, tris: out.tris, trans: out.trans, glass: out.glass, lines: out.lines, hidden: out.hidden, ..self }+ }+}++/// A class's triangles as `TRI_SIZE` vertex records: its runs of the block's vertices, in order.+fn append_runs(vertices: &[u8], runs: &[std::ops::Range<u32>], out: &mut Vec<u8>) {+ for r in runs {+ let (a, b) = (r.start as usize * TRI_SIZE, r.end as usize * TRI_SIZE);+ if let Some(v) = vertices.get(a..b) {+ out.extend_from_slice(v);+ }}}+/// The part of `runs` (sorted, not overlapping) inside `within`.+pub fn runs_within(runs: &[std::ops::Range<u32>], within: std::ops::Range<u32>) -> Vec<std::ops::Range<u32>> {+ let first = runs.partition_point(|r| r.end <= within.start);+ runs[first..]+ .iter()+ .take_while(|r| r.start < within.end)+ .map(|r| r.start.max(within.start)..r.end.min(within.end))+ .filter(|r| !r.is_empty())+ .collect()+}+/// A run of the model's bodies in the scene: their triangles and edges, and a key that names/// exactly this content (the viewport keeps the bytes while the key comes back).#[derive(Clone)]@@ -425,24 +575,142 @@ pub struct SceneBlock {pub bytes: Arc<BlockBytes>,}-/// A whole highlighted body the model builds on the CPU: its triangles in a model scene block,-/// as vertices of the block's triangle buffer.+/// A whole highlighted body the model builds on the CPU: its triangles in a model scene block.#[derive(Clone, Debug)]pub struct BlockTris {/// The block's key ([`SceneBlock::key`]).pub block: u64,- /// The body's vertices in it.- pub tris: std::ops::Range<u32>,+ /// The body's opaque triangles: runs of the block's vertices (a block too large for one+ /// vertex buffer draws from copies instead; its highlights are then skipped).+ pub tris: Vec<std::ops::Range<u32>>,+ /// All of the body's vertices in the block's canonical vertex stream.+ pub vertices: std::ops::Range<u32>,}-/// A block's geometry, laid out as in [`GpuScene`].-#[derive(Default)]+/// How a built triangle is drawn: opaque, see-through (glass), or faded context.+#[derive(Clone, Copy, PartialEq, Eq, Debug)]+pub enum TriClass {+ Opaque,+ Glass,+ Faded,+}++/// A block's geometry: one canonical triangle vertex stream (`TRI_SIZE` bytes a vertex, three a+/// triangle) and, per draw class, the runs of that stream the class draws. A colour or opacity+/// edit changes no vertex; an opacity class change changes only the runs, which are drawn+/// straight from the vertex buffer (no index buffer to upload).+#[derive(Default, Clone)]pub struct BlockBytes {- pub tris: Vec<u8>,- pub trans: Vec<u8>,- pub glass: Vec<u8>,- pub lines: Vec<u8>,- pub hidden: Vec<u8>,+ pub vertices: Arc<Vec<u8>>,+ pub opaque: Arc<Vec<std::ops::Range<u32>>>,+ pub glass: Arc<Vec<std::ops::Range<u32>>>,+ pub faded: Arc<Vec<std::ops::Range<u32>>>,+ pub lines: Arc<Vec<u8>>,+ pub hidden: Arc<Vec<u8>>,+}++impl BlockBytes {+ /// The runs of `class`.+ pub fn runs(&self, class: TriClass) -> &Arc<Vec<std::ops::Range<u32>>> {+ match class {+ TriClass::Opaque => &self.opaque,+ TriClass::Glass => &self.glass,+ TriClass::Faded => &self.faded,+ }+ }+}++/// Add a triangle starting at vertex `at` to `runs`, extending the last run when it ends there.+pub fn extend_runs(runs: &mut Vec<std::ops::Range<u32>>, at: u32) {+ let end = at.saturating_add(3);+ match runs.last_mut() {+ Some(last) if last.end == at => last.end = end,+ _ => runs.push(at..end),+ }+}++/// Builds a [`BlockBytes`], writing each triangle's vertices once and filing it by class.+#[derive(Default)]+pub struct BlockBuilder {+ vertices: Vec<u8>,+ opaque: Vec<std::ops::Range<u32>>,+ glass: Vec<std::ops::Range<u32>>,+ faded: Vec<std::ops::Range<u32>>,+ lines: Vec<u8>,+ hidden: Vec<u8>,+}++impl BlockBuilder {+ /// Room for `triangles` more triangles, so a block of large bodies is written without+ /// reallocating (and copying) its vertex stream as it grows.+ pub fn reserve_triangles(&mut self, triangles: usize) {+ let _ = self.vertices.try_reserve_exact(triangles.saturating_mul(3 * TRI_SIZE));+ }++ /// Add a triangle (three positions and normals, one palette index) under `class`.+ pub fn triangle(&mut self, p: [[f32; 3]; 3], n: [[f32; 3]; 3], c: PaletteIndex, class: TriClass) {+ let at = u32::try_from(self.vertices.len() / TRI_SIZE).unwrap_or(u32::MAX);+ let mut record = [0u8; 3 * TRI_SIZE];+ for ((out, p), n) in record.as_chunks_mut::<TRI_SIZE>().0.iter_mut().zip(p).zip(n) {+ let words = [p[0].to_bits(), p[1].to_bits(), p[2].to_bits(), n[0].to_bits(), n[1].to_bits(), n[2].to_bits(), c.0];+ for (w, slot) in words.iter().zip(out.as_chunks_mut::<4>().0) {+ *slot = w.to_le_bytes();+ }+ }+ self.vertices.extend_from_slice(&record);+ let runs = match class {+ TriClass::Opaque => &mut self.opaque,+ TriClass::Glass => &mut self.glass,+ TriClass::Faded => &mut self.faded,+ };+ extend_runs(runs, at);+ }++ /// The runs of `class` that fall within `vertices` (a body's share of the block).+ pub fn runs_within(&self, class: TriClass, vertices: std::ops::Range<u32>) -> Vec<std::ops::Range<u32>> {+ let runs = match class {+ TriClass::Opaque => &self.opaque,+ TriClass::Glass => &self.glass,+ TriClass::Faded => &self.faded,+ };+ runs_within(runs, vertices)+ }++ /// A depth-tested line, or one only shown where the model hides it.+ pub fn line(&mut self, a: [f32; 3], b: [f32; 3], c: PaletteIndex, width: f32) {+ let out = &mut self.lines;+ for v in a.iter().chain(&b) {+ out.extend_from_slice(&v.to_le_bytes());+ }+ out.extend_from_slice(&c.0.to_le_bytes());+ out.extend_from_slice(&width.to_le_bytes());+ }++ pub fn hidden_line(&mut self, a: [f32; 3], b: [f32; 3], c: PaletteIndex, width: f32) {+ let out = &mut self.hidden;+ for v in a.iter().chain(&b) {+ out.extend_from_slice(&v.to_le_bytes());+ }+ out.extend_from_slice(&c.0.to_le_bytes());+ out.extend_from_slice(&width.to_le_bytes());+ }++ /// How many vertices the block holds so far.+ pub fn vertices_len(&self) -> usize {+ self.vertices.len() / TRI_SIZE+ }++ /// The block, frozen for the scene and the GPU cache.+ pub fn freeze(self) -> Arc<BlockBytes> {+ Arc::new(BlockBytes {+ vertices: Arc::new(self.vertices),+ opaque: Arc::new(self.opaque),+ glass: Arc::new(self.glass),+ faded: Arc::new(self.faded),+ lines: Arc::new(self.lines),+ hidden: Arc::new(self.hidden),+ })+ }}impl GpuScene {@@ -453,72 +721,72 @@ impl GpuScene {self.pbr.extend_from_slice(&value.to_le_bytes());}}- pub fn tri(&mut self, p: [f32; 3], n: [f32; 3], c: [u8; 4]) {+ pub fn tri(&mut self, p: [f32; 3], n: [f32; 3], c: PaletteIndex) {for v in p.iter().chain(&n) {self.tris.extend_from_slice(&v.to_le_bytes());}- self.tris.extend_from_slice(&c);+ self.tris.extend_from_slice(&c.0.to_le_bytes());}/// A vertex of the ground-plane shadow (see [`GpuScene::shadow`]).- pub fn shadow_tri(&mut self, p: [f32; 3], c: [u8; 4]) {+ pub fn shadow_tri(&mut self, p: [f32; 3], c: PaletteIndex) {for v in p.iter().chain(&[0.0; 3]) {self.shadow.extend_from_slice(&v.to_le_bytes());}- self.shadow.extend_from_slice(&c);+ self.shadow.extend_from_slice(&c.0.to_le_bytes());}- pub fn trans_tri(&mut self, p: [f32; 3], n: [f32; 3], c: [u8; 4]) {+ pub fn trans_tri(&mut self, p: [f32; 3], n: [f32; 3], c: PaletteIndex) {for v in p.iter().chain(&n) {self.trans.extend_from_slice(&v.to_le_bytes());}- self.trans.extend_from_slice(&c);+ self.trans.extend_from_slice(&c.0.to_le_bytes());}/// A line shown only where the model hides it.- pub fn hidden_line(&mut self, a: [f32; 3], b: [f32; 3], c: [u8; 4], width: f32) {+ pub fn hidden_line(&mut self, a: [f32; 3], b: [f32; 3], c: PaletteIndex, width: f32) {for v in a.iter().chain(&b) {self.hidden.extend_from_slice(&v.to_le_bytes());}- self.hidden.extend_from_slice(&c);+ self.hidden.extend_from_slice(&c.0.to_le_bytes());self.hidden.extend_from_slice(&width.to_le_bytes());}- pub fn glass_tri(&mut self, p: [f32; 3], n: [f32; 3], c: [u8; 4]) {+ pub fn glass_tri(&mut self, p: [f32; 3], n: [f32; 3], c: PaletteIndex) {for v in p.iter().chain(&n) {self.glass.extend_from_slice(&v.to_le_bytes());}- self.glass.extend_from_slice(&c);+ self.glass.extend_from_slice(&c.0.to_le_bytes());}- pub fn ghost_tri(&mut self, p: [f32; 3], n: [f32; 3], c: [u8; 4]) {+ pub fn ghost_tri(&mut self, p: [f32; 3], n: [f32; 3], c: PaletteIndex) {for v in p.iter().chain(&n) {self.ghost.extend_from_slice(&v.to_le_bytes());}- self.ghost.extend_from_slice(&c);+ self.ghost.extend_from_slice(&c.0.to_le_bytes());}- pub fn xray_tri(&mut self, p: [f32; 3], n: [f32; 3], c: [u8; 4]) {+ pub fn xray_tri(&mut self, p: [f32; 3], n: [f32; 3], c: PaletteIndex) {for v in p.iter().chain(&n) {self.xray.extend_from_slice(&v.to_le_bytes());}- self.xray.extend_from_slice(&c);+ self.xray.extend_from_slice(&c.0.to_le_bytes());}/// A line under everything (see [`GpuScene::under`]).- pub fn under_line(&mut self, a: [f32; 3], b: [f32; 3], c: [u8; 4], width: f32) {+ pub fn under_line(&mut self, a: [f32; 3], b: [f32; 3], c: PaletteIndex, width: f32) {for v in a.iter().chain(&b) {self.under.extend_from_slice(&v.to_le_bytes());}- self.under.extend_from_slice(&c);+ self.under.extend_from_slice(&c.0.to_le_bytes());self.under.extend_from_slice(&width.to_le_bytes());}/// A translucent triangle of a plane a section does not cut (see [`GpuScene::guide_trans`]).- pub fn guide_tri(&mut self, p: [f32; 3], c: [u8; 4]) {+ pub fn guide_tri(&mut self, p: [f32; 3], c: PaletteIndex) {for v in p.iter().chain(&[0.0; 3]) {self.guide_trans.extend_from_slice(&v.to_le_bytes());}- self.guide_trans.extend_from_slice(&c);+ self.guide_trans.extend_from_slice(&c.0.to_le_bytes());}/// A depth-tested line a section does not cut (see [`GpuScene::guide_lines`]).- pub fn guide_line(&mut self, a: [f32; 3], b: [f32; 3], c: [u8; 4], width: f32) {+ pub fn guide_line(&mut self, a: [f32; 3], b: [f32; 3], c: PaletteIndex, width: f32) {for v in a.iter().chain(&b) {self.guide_lines.extend_from_slice(&v.to_le_bytes());}- self.guide_lines.extend_from_slice(&c);+ self.guide_lines.extend_from_slice(&c.0.to_le_bytes());self.guide_lines.extend_from_slice(&width.to_le_bytes());}/// A thick highlight along an edge (a selected or hovered edge with its halo), lit like a@@ -526,19 +794,19 @@ impl GpuScene {/// steeply the faces beside it are seen (`normals`: theirs along the segment; zero when/// unknown), so a face seen at a grazing angle no longer buries part of the band (it showed as/// a thin wedge instead of a line). See [`lifted_width`] for how this travels.- pub fn lifted_line(&mut self, a: [f32; 3], b: [f32; 3], c: [u8; 4], width: f32, normals: [[f32; 3]; 2]) {+ pub fn lifted_line(&mut self, a: [f32; 3], b: [f32; 3], c: PaletteIndex, width: f32, normals: [[f32; 3]; 2]) {for v in a.iter().chain(&b) {self.lines.extend_from_slice(&v.to_le_bytes());}- self.lines.extend_from_slice(&c);+ self.lines.extend_from_slice(&c.0.to_le_bytes());self.lines.extend_from_slice(&lifted_width(width, normals).to_le_bytes());}- pub fn line(&mut self, a: [f32; 3], b: [f32; 3], c: [u8; 4], width: f32, on_top: bool) {+ pub fn line(&mut self, a: [f32; 3], b: [f32; 3], c: PaletteIndex, width: f32, on_top: bool) {let out = if on_top { &mut self.overlay } else { &mut self.lines };for v in a.iter().chain(&b) {out.extend_from_slice(&v.to_le_bytes());}- out.extend_from_slice(&c);+ out.extend_from_slice(&c.0.to_le_bytes());out.extend_from_slice(&width.to_le_bytes());}}@@ -723,6 +991,7 @@ pub fn analysis_uniform(mode: Option<solidcraft_render::AnalysisMode>, access: O/// Vertices (or line instances) on the GPU, in as many buffers as the device's buffer size/// limit needs: a large import's triangles can exceed one buffer (#883).+#[derive(Clone)]struct Batch {/// Each buffer and its vertex (instance) count.parts: Vec<(wgpu::Buffer, u32)>,@@ -734,6 +1003,8 @@ struct Batch {struct PlannedDraw {mesh: Arc<crate::GpuMesh>,colors: wgpu::Buffer,+ /// Its bodies' class: a chunk holds bodies of one class.+ class: TriClass,/// The address of each plan in the chunk, in `mesh.parts` order: a whole-body highlight/// finds the evaluated triangles of the body it lights.plans: Vec<usize>,@@ -915,15 +1186,148 @@ impl LevelDraw {}}-/// A scene block on the GPU, with the bytes it was uploaded from.+/// Most runs a class draws one by one; a class broken into more (faces of their own opacity all+/// over a body) is drawn through an index buffer instead, in one call.+const MAX_RUNS: usize = 64;++/// One class's triangles on the GPU: runs of the block's vertex buffer (no buffer of their own),+/// an index buffer for a fragmented class, or copies of its triangles when the block is too large+/// for one vertex buffer.+#[derive(Clone)]+enum ClassGpu {+ Runs(Arc<Vec<std::ops::Range<u32>>>),+ Indexed { indices: wgpu::Buffer, count: u32 },+ Unindexed(Batch),+}++/// A scene block on the GPU, with the bytes it was uploaded from. Each artifact is kept while+/// its `Arc` comes back, so an opacity class change uploads nothing for a class drawn by runs.struct BlockGpu {bytes: Arc<BlockBytes>,- tris: Option<Batch>,- trans: Option<Batch>,+ vertices: Option<wgpu::Buffer>,+ opaque: Option<ClassGpu>,+ glass: Option<ClassGpu>,+ faded: Option<ClassGpu>,lines: Option<Batch>,hidden: Option<Batch>,}+fn class_gpu(+ device: &wgpu::Device,+ fits: bool,+ vertices: &[u8],+ runs: &Arc<Vec<std::ops::Range<u32>>>,+ old: Option<(&ClassGpu, &Arc<Vec<std::ops::Range<u32>>>)>,+ same_vertices: bool,+ uploaded: &mut u64,+) -> Option<ClassGpu> {+ if runs.is_empty() {+ return None;+ }+ let same_runs = old.is_some_and(|(_, old_runs)| Arc::ptr_eq(old_runs, runs));+ if !fits {+ if let (Some((ClassGpu::Unindexed(batch), _)), true) = (old, same_vertices && same_runs) {+ return Some(ClassGpu::Unindexed(batch.clone()));+ }+ let mut bytes = Vec::new();+ append_runs(vertices, runs, &mut bytes);+ *uploaded += bytes.len() as u64;+ return upload(device, "sc_block_class", &bytes, TRI_SIZE).map(ClassGpu::Unindexed);+ }+ if runs.len() <= MAX_RUNS {+ return Some(ClassGpu::Runs(runs.clone()));+ }+ if let (Some((ClassGpu::Indexed { indices, count }, _)), true) = (old, same_runs) {+ return Some(ClassGpu::Indexed { indices: indices.clone(), count: *count });+ }+ let bytes: Vec<u8> = runs.iter().flat_map(|r| r.clone()).flat_map(|i| i.to_le_bytes()).collect();+ *uploaded += bytes.len() as u64;+ let count = u32::try_from(bytes.len() / 4).unwrap_or(u32::MAX);+ let indices = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {+ label: Some("sc_block_indices"),+ contents: &bytes,+ usage: wgpu::BufferUsages::INDEX,+ });+ Some(ClassGpu::Indexed { indices, count })+}++impl BlockGpu {+ fn update(device: &wgpu::Device, old: Option<BlockGpu>, bytes: Arc<BlockBytes>, uploaded: &mut u64) -> BlockGpu {+ let fits = bytes.vertices.len() as u64 <= device.limits().max_buffer_size;+ let same_vertices = old.as_ref().is_some_and(|o| Arc::ptr_eq(&o.bytes.vertices, &bytes.vertices));+ let vertices = if !fits || bytes.vertices.is_empty() {+ None+ } else if same_vertices {+ old.as_ref().and_then(|o| o.vertices.clone())+ } else {+ *uploaded += bytes.vertices.len() as u64;+ Some(device.create_buffer_init(&wgpu::util::BufferInitDescriptor {+ label: Some("sc_block_vertices"),+ contents: &bytes.vertices,+ usage: wgpu::BufferUsages::VERTEX,+ }))+ };+ let mut class = |class: TriClass| {+ let old_pair = old.as_ref().and_then(|o| o.class(class).map(|c| (c, o.bytes.runs(class))));+ class_gpu(device, fits, &bytes.vertices, bytes.runs(class), old_pair, same_vertices, uploaded)+ };+ let (opaque, glass, faded) = (class(TriClass::Opaque), class(TriClass::Glass), class(TriClass::Faded));+ let keep = |old: Option<&BlockGpu>, pick: fn(&BlockBytes) -> &Arc<Vec<u8>>, old_lines: fn(&BlockGpu) -> Option<&Batch>| {+ old.filter(|o| Arc::ptr_eq(pick(&o.bytes), pick(&bytes))).and_then(old_lines).cloned()+ };+ let mut fresh = |data: &[u8], label: &str| {+ *uploaded += data.len() as u64;+ upload(device, label, data, LINE_SIZE)+ };+ let lines = keep(old.as_ref(), |b| &b.lines, |b| b.lines.as_ref()).or_else(|| fresh(&bytes.lines, "sc_block_lines"));+ let hidden = keep(old.as_ref(), |b| &b.hidden, |b| b.hidden.as_ref()).or_else(|| fresh(&bytes.hidden, "sc_block_hidden"));+ BlockGpu { bytes, vertices, opaque, glass, faded, lines, hidden }+ }++ fn class(&self, class: TriClass) -> Option<&ClassGpu> {+ match class {+ TriClass::Opaque => self.opaque.as_ref(),+ TriClass::Glass => self.glass.as_ref(),+ TriClass::Faded => self.faded.as_ref(),+ }+ }++ /// Draw `class`'s triangles with the pipeline already set (`tally`: what is counted).+ fn draw(&self, pass: &mut wgpu::RenderPass<'_>, class: TriClass, tally: &Tally) {+ match self.class(class) {+ Some(ClassGpu::Runs(runs)) => {+ let Some(vertices) = &self.vertices else { return };+ pass.set_vertex_buffer(0, vertices.slice(..));+ for r in runs.iter() {+ pass.draw(r.clone(), 0..1);+ tally.triangles(r.len() as u32, 1);+ }+ }+ Some(ClassGpu::Indexed { indices, count }) => {+ let Some(vertices) = &self.vertices else { return };+ pass.set_vertex_buffer(0, vertices.slice(..));+ pass.set_index_buffer(indices.slice(..), wgpu::IndexFormat::Uint32);+ pass.draw_indexed(0..*count, 0, 0..1);+ tally.triangles(*count, 1);+ }+ Some(ClassGpu::Unindexed(batch)) => {+ for (buffer, count) in &batch.parts {+ pass.set_vertex_buffer(0, buffer.slice(..));+ pass.draw(0..*count, 0..1);+ tally.triangles(*count, 1);+ }+ }+ None => {}+ }+ }+}++/// The group 0 bind of the scene that owns the data being drawn: its palette (and the shared+/// uniform), or the one-entry stand-in for draws that read no colours.+fn scene_bind<'a>(scene: &'a Batches, fallback: &'a wgpu::BindGroup) -> &'a wgpu::BindGroup {+ scene.palette.as_ref().map_or(fallback, |p| &p.bind)+}+/// The blocks' buffers, then the scene's own, as one batch (the blocks' buffers are shared,/// not copied).fn joined<'a>(blocks: impl Iterator<Item = &'a Option<Batch>>, own: Option<Batch>) -> Option<Batch> {@@ -933,6 +1337,133 @@ fn joined<'a>(blocks: impl Iterator<Item = &'a Option<Batch>>, own: Option<Batch(!parts.is_empty()).then_some(Batch { parts, chunk })}+/// A scene's palette on the GPU: an `R32Uint` texture, [`PALETTE_WIDTH`] entries to a row.+struct PaletteGpu {+ palette: Arc<Palette>,+ /// Held for the bind group, which views it.+ _texture: wgpu::Texture,+ bind: wgpu::BindGroup,+ rows: u32,+ entries: Vec<[u8; 4]>,+}++fn palette_texture(device: &wgpu::Device, rows: u32) -> wgpu::Texture {+ device.create_texture(&wgpu::TextureDescriptor {+ label: Some("sc_palette"),+ size: wgpu::Extent3d { width: PALETTE_WIDTH, height: rows.max(1), depth_or_array_layers: 1 },+ mip_level_count: 1,+ sample_count: 1,+ dimension: wgpu::TextureDimension::D2,+ format: wgpu::TextureFormat::R32Uint,+ usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,+ view_formats: &[],+ })+}++/// Rows `first..last` of `entries` as the texture's texels (zero past the end).+fn palette_bytes(entries: &[[u8; 4]], first: u32, last: u32) -> Vec<u8> {+ let width = PALETTE_WIDTH as usize;+ let mut out = Vec::with_capacity((last - first) as usize * width * 4);+ for row in first..last {+ for col in 0..PALETTE_WIDTH {+ let i = row as usize * width + col as usize;+ let texel = entries.get(i).map_or(0, |[r, g, b, a]| u32::from_le_bytes([*r, *g, *b, *a]));+ out.extend_from_slice(&texel.to_le_bytes());+ }+ }+ out+}++fn palette_rows(entries: &[[u8; 4]]) -> u32 {+ u32::try_from(entries.len().div_ceil(PALETTE_WIDTH as usize)).unwrap_or(1).max(1)+}++impl PaletteGpu {+ fn new(+ device: &wgpu::Device,+ queue: &wgpu::Queue,+ uniform: &wgpu::Buffer,+ bgl: &wgpu::BindGroupLayout,+ palette: Arc<Palette>,+ written: &mut u64,+ ) -> PaletteGpu {+ let entries = palette.entries().to_vec();+ let rows = palette_rows(&entries);+ let texture = palette_texture(device, rows);+ let bytes = palette_bytes(&entries, 0, rows);+ *written += bytes.len() as u64;+ queue.write_texture(+ wgpu::TexelCopyTextureInfo { texture: &texture, mip_level: 0, origin: wgpu::Origin3d::ZERO, aspect: wgpu::TextureAspect::All },+ &bytes,+ wgpu::TexelCopyBufferLayout { offset: 0, bytes_per_row: Some(PALETTE_WIDTH * 4), rows_per_image: Some(rows) },+ wgpu::Extent3d { width: PALETTE_WIDTH, height: rows, depth_or_array_layers: 1 },+ );+ let view = texture.create_view(&Default::default());+ let bind = device.create_bind_group(&wgpu::BindGroupDescriptor {+ label: Some("sc_palette"),+ layout: bgl,+ entries: &[+ wgpu::BindGroupEntry { binding: 0, resource: uniform.as_entire_binding() },+ wgpu::BindGroupEntry { binding: 1, resource: wgpu::BindingResource::TextureView(&view) },+ ],+ });+ PaletteGpu { palette, _texture: texture, bind, rows, entries }+ }++ /// Bring the texture up to `palette`, writing only the rows whose entries changed (or the+ /// whole texture when it must grow). The bind group is rebuilt only then.+ fn update(+ &mut self,+ device: &wgpu::Device,+ queue: &wgpu::Queue,+ uniform: &wgpu::Buffer,+ bgl: &wgpu::BindGroupLayout,+ palette: Arc<Palette>,+ written: &mut u64,+ ) {+ if Arc::ptr_eq(&self.palette, &palette) {+ return;+ }+ let entries = palette.entries().to_vec();+ let rows = palette_rows(&entries);+ if rows != self.rows {+ *self = PaletteGpu::new(device, queue, uniform, bgl, palette, written);+ return;+ }+ let width = PALETTE_WIDTH as usize;+ let same = |row: u32| {+ let base = row as usize * width;+ (0..width).all(|c| self.entries.get(base + c).copied().unwrap_or_default() == entries.get(base + c).copied().unwrap_or_default())+ };+ let mut row = 0u32;+ while row < rows {+ if same(row) {+ row += 1;+ continue;+ }+ let first = row;+ while row < rows && !same(row) {+ row += 1;+ }+ let bytes = palette_bytes(&entries, first, row);+ *written += bytes.len() as u64;+ queue.write_texture(+ wgpu::TexelCopyTextureInfo {+ texture: &self._texture,+ mip_level: 0,+ origin: wgpu::Origin3d { x: 0, y: first, z: 0 },+ aspect: wgpu::TextureAspect::All,+ },+ &bytes,+ wgpu::TexelCopyBufferLayout { offset: 0, bytes_per_row: Some(PALETTE_WIDTH * 4), rows_per_image: Some(row - first) },+ wgpu::Extent3d { width: PALETTE_WIDTH, height: row - first, depth_or_array_layers: 1 },+ );+ }+ self.entries = entries;+ self.palette = palette;+ }+}+/// Planned bodies end a GPU chunk one time in this many (by their plan's address), and a chunk/// holds at most [`MAX_CHUNK_BODIES`]: a scene of a thousand bodies takes a few dozen dispatches/// once, and a changed body re-evaluates a few dozen bodies, not all of them.@@ -941,8 +1472,17 @@ const MAX_CHUNK_BODIES: usize = 128;#[derive(Default)]struct Batches {- /// The scene blocks on the GPU, by key.+ /// What the last scene taken uploaded.+ uploads: UploadStats,+ /// The blocks' see-through triangles the global glass stream was assembled from (block key,+ /// vertices and glass runs, by address), when it holds nothing else: an edit that changes+ /// neither leaves the sorted stream as it is.+ glass_from: Option<Vec<(u64, usize, usize)>>,+ /// The scene's palette texture and its group 0 bind (uniform + palette).+ palette: Option<PaletteGpu>,+ /// The scene blocks on the GPU, by key, and their drawing order.blocks: std::collections::HashMap<u64, BlockGpu>,+ block_order: Vec<u64>,key: Option<u64>,tris: Option<Batch>,pbr: Option<Batch>,@@ -968,6 +1508,8 @@ struct Batches {/// Whole highlighted bodies redrawn from the scene's blocks, by block key and vertex range.hover_blocks: Vec<BlockTris>,selected_blocks: Vec<BlockTris>,+ /// Whole faded or see-through bodies redrawn from the model's blocks in this scene's palette.+ recoloured: Vec<BlockTris>,/// Whole highlighted bodies drawn as placements of the scene's shared triangles.hover_instanced: Vec<InstancedDraw>,selected_instanced: Vec<InstancedDraw>,@@ -982,11 +1524,32 @@ struct Batches {impl Batches {/// Upload a new scene. Planned bodies not yet on the GPU are evaluated there: their/// dispatches go into `encoder`, ahead of this frame's render pass.- fn take(&mut self, device: &wgpu::Device, key: u64, slot: &SceneSlot, tess: Option<(&crate::TessGpu, &mut wgpu::CommandEncoder)>) {+ fn take(+ &mut self,+ device: &wgpu::Device,+ queue: &wgpu::Queue,+ uniform: &wgpu::Buffer,+ bgl: &wgpu::BindGroupLayout,+ key: u64,+ slot: &SceneSlot,+ tess: Option<(&crate::TessGpu, &mut wgpu::CommandEncoder)>,+ oit_available: bool,+ ) {if self.key == Some(key) {return;}if let Some(sc) = slot.lock().ok().and_then(|mut s| s.take()) {+ self.uploads = UploadStats::default();+ let palette = sc.palette.clone();+ let mut written = 0;+ match self.palette.take() {+ Some(mut p) => {+ p.update(device, queue, uniform, bgl, palette, &mut written);+ self.palette = Some(p);+ }+ None => self.palette = Some(PaletteGpu::new(device, queue, uniform, bgl, palette, &mut written)),+ }+ self.uploads.palette = written;self.planned = match tess {Some((tess, encoder)) => self.planned(device, tess, encoder, &sc.planned),None => Vec::new(),@@ -996,43 +1559,65 @@ impl Batches {self.selected_planned = sc.selected_planned;self.hover_blocks = sc.hover_blocks;self.selected_blocks = sc.selected_blocks;+ self.recoloured = sc.recoloured;self.hover_instanced = self.instanced(device, &sc.hover_instanced);self.selected_instanced = self.instanced(device, &sc.selected_instanced);let mut kept = std::mem::take(&mut self.blocks);- let mut blocks: Vec<&BlockGpu> = Vec::with_capacity(sc.blocks.len());+ let mut order = Vec::with_capacity(sc.blocks.len());+ let mut geometry = 0;for block in &sc.blocks {- let gpu = match kept.remove(&block.key).filter(|g| Arc::ptr_eq(&g.bytes, &block.bytes)) {- Some(g) => g,- None => BlockGpu {- bytes: block.bytes.clone(),- tris: upload(device, "sc_tris", &block.bytes.tris, TRI_SIZE),- trans: upload(device, "sc_trans", &block.bytes.trans, TRI_SIZE),- lines: upload(device, "sc_lines", &block.bytes.lines, LINE_SIZE),- hidden: upload(device, "sc_hidden", &block.bytes.hidden, LINE_SIZE),- },- };- self.blocks.insert(block.key, gpu);+ let old = kept.remove(&block.key);+ self.blocks.insert(block.key, BlockGpu::update(device, old, block.bytes.clone(), &mut geometry));+ order.push(block.key);}- for block in &sc.blocks {- if let Some(g) = self.blocks.get(&block.key) {- blocks.push(g);+ self.block_order = order;+ let mut own = |label: &str, data: &[u8], stride: usize| {+ geometry += data.len() as u64;+ upload(device, label, data, stride)+ };+ self.tris = own("sc_tris", &sc.tris, TRI_SIZE);+ self.pbr = own("sc_pbr", &sc.pbr, PBR_SIZE);+ self.trans = own("sc_trans", &sc.trans, TRI_SIZE);+ self.shadow = own("sc_shadow", &sc.shadow, TRI_SIZE);+ let own_lines = own("sc_lines", &sc.lines, LINE_SIZE);+ let own_hidden = own("sc_hidden", &sc.hidden, LINE_SIZE);+ self.overlays = own("sc_overlay", &sc.overlay, LINE_SIZE);+ self.ghost = own("sc_ghost", &sc.ghost, TRI_SIZE);+ self.xray = own("sc_xray", &sc.xray, TRI_SIZE);+ self.under = own("sc_under", &sc.under, LINE_SIZE);+ self.guide_trans = own("sc_guide_trans", &sc.guide_trans, TRI_SIZE);+ self.guide_lines = own("sc_guide_lines", &sc.guide_lines, LINE_SIZE);+ let blocks: Vec<&BlockGpu> = self.block_order.iter().filter_map(|k| self.blocks.get(k)).collect();+ self.lines = joined(blocks.iter().map(|b| &b.lines), own_lines);+ self.hidden = joined(blocks.iter().map(|b| &b.hidden), own_hidden);+ // Without order-independent transparency one global glass stream is sorted per view,+ // so cross-body blend order is kept; the blocks' glass triangles join it here. With+ // OIT the blocks draw their own runs and nothing is sorted. A stream made of the same+ // blocks' glass as before (a colour or opacity edit, a selection) is kept as sorted.+ let from: Vec<(u64, usize, usize)> = if oit_available {+ Vec::new()+ } else {+ sc.blocks+ .iter()+ .filter(|b| !b.bytes.glass.is_empty())+ .map(|b| (b.key, Arc::as_ptr(&b.bytes.vertices) as usize, Arc::as_ptr(&b.bytes.glass) as usize))+ .collect()+ };+ let same_glass = sc.glass.is_empty() && self.glass_from.as_ref() == Some(&from);+ if !same_glass {+ self.glass_cpu.clear();+ self.glass_cpu.extend_from_slice(&sc.glass);+ if !oit_available {+ for block in &sc.blocks {+ append_runs(&block.bytes.vertices, &block.bytes.glass, &mut self.glass_cpu);+ }}+ geometry += self.glass_cpu.len() as u64;+ self.glass = upload_with(device, "sc_glass", &self.glass_cpu, TRI_SIZE, wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST);+ self.glass_sorted_for = None;+ self.glass_from = sc.glass.is_empty().then_some(from);}- self.tris = joined(blocks.iter().map(|b| &b.tris), upload(device, "sc_tris", &sc.tris, TRI_SIZE));- self.pbr = upload(device, "sc_pbr", &sc.pbr, PBR_SIZE);- self.trans = joined(blocks.iter().map(|b| &b.trans), upload(device, "sc_trans", &sc.trans, TRI_SIZE));- self.shadow = upload(device, "sc_shadow", &sc.shadow, TRI_SIZE);- self.glass = upload_with(device, "sc_glass", &sc.glass, TRI_SIZE, wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST);- self.glass_cpu = sc.glass;- self.glass_sorted_for = None;- self.lines = joined(blocks.iter().map(|b| &b.lines), upload(device, "sc_lines", &sc.lines, LINE_SIZE));- self.hidden = joined(blocks.iter().map(|b| &b.hidden), upload(device, "sc_hidden", &sc.hidden, LINE_SIZE));- self.overlays = upload(device, "sc_overlay", &sc.overlay, LINE_SIZE);- self.ghost = upload(device, "sc_ghost", &sc.ghost, TRI_SIZE);- self.xray = upload(device, "sc_xray", &sc.xray, TRI_SIZE);- self.under = upload(device, "sc_under", &sc.under, LINE_SIZE);- self.guide_trans = upload(device, "sc_guide_trans", &sc.guide_trans, TRI_SIZE);- self.guide_lines = upload(device, "sc_guide_lines", &sc.guide_lines, LINE_SIZE);+ self.uploads.geometry += geometry;self.key = Some(key);}}@@ -1054,7 +1639,10 @@ impl Batches {let gpu = match kept.remove(&key).or_else(|| self.instanced_tris.remove(&key)).filter(|(b, _)| Arc::ptr_eq(b, tris)) {Some(t) => t,None => match SharedGpu::new(device, tris) {- Some(g) => (tris.clone(), Arc::new(g)),+ Some(g) => {+ self.uploads.geometry += (tris.vertices.len() + tris.indices.len() * 4) as u64;+ (tris.clone(), Arc::new(g))+ }None => continue,},};@@ -1064,6 +1652,7 @@ impl Batches {contents: &placements,usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,});+ self.uploads.placements += placements.len() as u64;let count = if i == 0 { count } else { 0 };levels.push(LevelDraw { tris: gpu.1.clone(), flat: tris.flat, error, instances, count });self.instanced_tris.insert(key, gpu);@@ -1152,7 +1741,7 @@ impl Batches {for b in bodies {let n = b.plan.vertex_count();match chunks.last_mut() {- Some(c) if open && filled + n <= crate::MAX_BATCH => c.push(b),+ Some(c) if open && filled + n <= crate::MAX_BATCH && c.first().is_some_and(|f| f.class == b.class) => c.push(b),_ => {chunks.push(vec![b]);filled = 0;@@ -1173,6 +1762,7 @@ impl Batches {let plans: Vec<&solidcraft_geom::tess::TessPlan> = chunk.iter().map(|b| &*b.plan).collect();match tess.prepare_many(&plans) {Ok(m) => {+ self.uploads.evaluated += plans.iter().map(|p| p.vertex_count() as u64).sum::<u64>();tess.record(encoder, &m);let m = Arc::new(m);self.resident.insert(key(chunk), (chunk.iter().map(|b| b.plan.clone()).collect(), m.clone()));@@ -1187,12 +1777,16 @@ impl Batches {};let mut bytes = Vec::with_capacity(mesh.vertex_face.len() * 4);for (part, b) in mesh.parts.iter().zip(chunk) {- let last = b.face_colors.last().copied().unwrap_or([200, 200, 200, 255]);+ let last = b.face_colors.last().copied().unwrap_or(PaletteIndex(0));let faces = mesh.vertex_face.get(part.vertices.start as usize..part.vertices.end as usize).unwrap_or_default();- bytes.extend(faces.iter().flat_map(|f| b.face_colors.get(*f as usize).copied().unwrap_or(last)));+ for f in faces {+ bytes.extend_from_slice(&b.face_colors.get(*f as usize).copied().unwrap_or(last).0.to_le_bytes());+ }}+ self.uploads.planned += bytes.len() as u64;if let Some((colors, _)) = upload(device, "sc_planned_colors", &bytes, 4).and_then(|c| c.parts.into_iter().next()) {- out.push(PlannedDraw { mesh, colors, plans: key(chunk) });+ let class = chunk.first().map_or(TriClass::Opaque, |b| b.class);+ out.push(PlannedDraw { mesh, colors, class, plans: key(chunk) });}}out@@ -1272,6 +1866,9 @@ pub struct Renderer {guide_trans: wgpu::RenderPipeline,guide_line: wgpu::RenderPipeline,uniform: wgpu::Buffer,+ /// The layout of group 0 (the uniform and a palette), for per-scene bind groups.+ uniform_bgl: wgpu::BindGroupLayout,+ /// Group 0 with a one-entry palette: draws that do not read colours (images, AO, depth).bind: wgpu::BindGroup,linear_out: bool,model: Batches,@@ -1453,7 +2050,7 @@ fn access_texture(device: &wgpu::Device, queue: Option<&wgpu::Queue>, bgl: &wgpupub const SHADER: &str = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/shaders/viewport.wgsl"));fn tri_layout() -> wgpu::VertexBufferLayout<'static> {- const A: [wgpu::VertexAttribute; 3] = wgpu::vertex_attr_array![0 => Float32x3, 1 => Float32x3, 2 => Unorm8x4];+ const A: [wgpu::VertexAttribute; 3] = wgpu::vertex_attr_array![0 => Float32x3, 1 => Float32x3, 2 => Uint32];wgpu::VertexBufferLayout { array_stride: TRI_SIZE as u64, step_mode: wgpu::VertexStepMode::Vertex, attributes: &A }}@@ -1480,7 +2077,7 @@ fn shared_layout() -> wgpu::VertexBufferLayout<'static> {/// An instanced mesh's placements ([`INSTANCE_SIZE`]), one per instance.fn instance_layout() -> wgpu::VertexBufferLayout<'static> {- const A: [wgpu::VertexAttribute; 4] = wgpu::vertex_attr_array![3 => Float32x4, 4 => Float32x4, 5 => Float32x4, 6 => Unorm8x4];+ const A: [wgpu::VertexAttribute; 4] = wgpu::vertex_attr_array![3 => Float32x4, 4 => Float32x4, 5 => Float32x4, 6 => Uint32];wgpu::VertexBufferLayout { array_stride: INSTANCE_SIZE as u64, step_mode: wgpu::VertexStepMode::Instance, attributes: &A }}@@ -1518,12 +2115,12 @@ impl TriSource {/// A planned body's colours, one per vertex.fn color_layout() -> wgpu::VertexBufferLayout<'static> {- const A: [wgpu::VertexAttribute; 1] = wgpu::vertex_attr_array![2 => Unorm8x4];+ const A: [wgpu::VertexAttribute; 1] = wgpu::vertex_attr_array![2 => Uint32];wgpu::VertexBufferLayout { array_stride: 4, step_mode: wgpu::VertexStepMode::Vertex, attributes: &A }}fn line_layout() -> wgpu::VertexBufferLayout<'static> {- const A: [wgpu::VertexAttribute; 4] = wgpu::vertex_attr_array![0 => Float32x3, 1 => Float32x3, 2 => Unorm8x4, 3 => Uint32];+ const A: [wgpu::VertexAttribute; 4] = wgpu::vertex_attr_array![0 => Float32x3, 1 => Float32x3, 2 => Uint32, 3 => Uint32];wgpu::VertexBufferLayout { array_stride: LINE_SIZE as u64, step_mode: wgpu::VertexStepMode::Instance, attributes: &A }}@@ -1535,6 +2132,10 @@ pub struct GpuTarget {pub samples: u32,/// The device evaluates display plans (compute shaders): bodies may be drawn from them.pub tess: bool,+ /// The renderer blends see-through surfaces order-independently: faded and see-through+ /// bodies may be drawn from their plans too (they need no sorting on the CPU). Set by the+ /// renderer ([`Renderer::target`]); asking for it does not make it so.+ pub oit: bool,}impl GpuTarget {@@ -1602,12 +2203,25 @@ impl Renderer {device.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some("sc_viewport"), source: wgpu::ShaderSource::Wgsl(source.into()) });let bgl = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {label: Some("sc_viewport"),- entries: &[wgpu::BindGroupLayoutEntry {- binding: 0,- visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,- ty: wgpu::BindingType::Buffer { ty: wgpu::BufferBindingType::Uniform, has_dynamic_offset: false, min_binding_size: None },- count: None,- }],+ entries: &[+ wgpu::BindGroupLayoutEntry {+ binding: 0,+ visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,+ ty: wgpu::BindingType::Buffer { ty: wgpu::BufferBindingType::Uniform, has_dynamic_offset: false, min_binding_size: None },+ count: None,+ },+ // The palette: a texture (not a storage buffer), so WebGL2 can draw it.+ wgpu::BindGroupLayoutEntry {+ binding: 1,+ visibility: wgpu::ShaderStages::VERTEX,+ ty: wgpu::BindingType::Texture {+ sample_type: wgpu::TextureSampleType::Uint,+ view_dimension: wgpu::TextureViewDimension::D2,+ multisampled: false,+ },+ count: None,+ },+ ],});let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {label: Some("sc_viewport"),@@ -1620,10 +2234,15 @@ impl Renderer {usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,mapped_at_creation: false,});+ let dummy_palette = palette_texture(device, 1);+ let dummy_view = dummy_palette.create_view(&Default::default());let bind = device.create_bind_group(&wgpu::BindGroupDescriptor {label: Some("sc_viewport"),layout: &bgl,- entries: &[wgpu::BindGroupEntry { binding: 0, resource: uniform.as_entire_binding() }],+ entries: &[+ wgpu::BindGroupEntry { binding: 0, resource: uniform.as_entire_binding() },+ wgpu::BindGroupEntry { binding: 1, resource: wgpu::BindingResource::TextureView(&dummy_view) },+ ],});let reversed = t.reversed_depth();let depth = |compare: wgpu::CompareFunction, write: bool| -> Option<wgpu::DepthStencilState> {@@ -1939,7 +2558,7 @@ impl Renderer {ao,depth_reset,section_reset: t.depth.filter(|f| f.has_stencil_aspect()).and_then(|_| depth_reset_pipeline(device, t)),- target: t,+ target: GpuTarget { oit: oit.is_some(), ..t },window,max_texture: device.limits().max_texture_dimension_2d,ss_blit,@@ -2000,6 +2619,7 @@ impl Renderer {guide_trans: pipeline("sc_guide_trans", "vs_tri", "fs_tri_all", tri_layout(), depth(wgpu::CompareFunction::LessEqual, false), alpha),guide_line: pipeline("sc_guide_lines", "vs_line", "fs_line_all", line_layout(), depth(wgpu::CompareFunction::LessEqual, false), alpha),uniform,+ uniform_bgl: bgl,bind,linear_out: t.format.is_srgb(),model: Batches::default(),@@ -2131,7 +2751,11 @@ pub fn sort_back_to_front(bytes: &[u8], back: [f32; 3]) -> Vec<u8> {impl Batches {/// Whether it has see-through surfaces (glass or faded, instanced or not).fn see_through(&self) -> bool {- self.glass.is_some() || self.trans.is_some() || self.instanced.iter().any(|d| d.look != InstanceLook::Opaque)+ self.glass.is_some()+ || self.trans.is_some()+ || self.planned.iter().any(|d| d.class != TriClass::Opaque)+ || self.instanced.iter().any(|d| d.look != InstanceLook::Opaque)+ || self.block_order.iter().any(|k| self.blocks.get(k).is_some_and(|b| b.glass.is_some() || b.faded.is_some()))}/// Re-sort the glass for a new view direction (when it turned more than about 2 degrees).@@ -2263,7 +2887,7 @@ impl Renderer {}res.cached = None;if cb.product {- res.product.take(device, cb.key, &cb.slot, None);+ res.product.take(device, queue, &res.uniform, &res.uniform_bgl, cb.key, &cb.slot, None, false);res.product.sort_glass(queue, cb.back);queue.write_buffer(&res.uniform, 0, &uniform_bytes(cb, cb.size_px[0], cb.size_px[1], res.linear_out, res.target.reversed_depth()));// The product picture goes through the window's pass too: offscreen when the targets@@ -2272,10 +2896,19 @@ impl Renderer {res.ss_key = res.ss_ready.then_some(key);return;}- res.model.take(device, cb.key, &cb.slot, res.tess.as_ref().map(|t| (t, &mut *encoder)));- res.sketch.take(device, cb.sketch_key, &cb.sketch_slot, None);- res.highlight.take(device, cb.hl_key, &cb.hl_slot, None);- res.preview.take(device, cb.pv_key, &cb.pv_slot, None);+ res.model.take(+ device,+ queue,+ &res.uniform,+ &res.uniform_bgl,+ cb.key,+ &cb.slot,+ res.tess.as_ref().map(|t| (t, &mut *encoder)),+ res.oit.is_some(),+ );+ res.sketch.take(device, queue, &res.uniform, &res.uniform_bgl, cb.sketch_key, &cb.sketch_slot, None, res.oit.is_some());+ res.highlight.take(device, queue, &res.uniform, &res.uniform_bgl, cb.hl_key, &cb.hl_slot, None, res.oit.is_some());+ res.preview.take(device, queue, &res.uniform, &res.uniform_bgl, cb.pv_key, &cb.pv_slot, None, res.oit.is_some());// See-through surfaces are drawn without sorting where the device can (order-independent// transparency, in an offscreen frame); else their triangles are sorted for the view.let see_through = res.oit.is_some() && res.model.see_through();@@ -2290,7 +2923,8 @@ impl Renderer {res.access_bind = access_texture(device, Some(queue), &res.access_bgl, a.size, &a.depth);res.access_version = a.version;}- res.ao.prepare(device, encoder, &res.bind, cb.ao_radius, cb.size_px, res.target.reversed_depth(), [&res.model, &res.preview]);+ let ao_binds = [scene_bind(&res.model, &res.bind), scene_bind(&res.preview, &res.bind)];+ res.ao.prepare(device, encoder, ao_binds, cb.ao_radius, cb.size_px, res.target.reversed_depth(), [&res.model, &res.preview]);// Images: upload new or changed textures, drop removed ones, rebuild the quads.res.textures.retain(|id, _| cb.images.iter().any(|i| i.id == *id));res.quads.clear();@@ -2382,6 +3016,11 @@ impl Renderer {self.stats.clone()}+ /// What the model scene's last change uploaded ([`UploadStats`]).+ pub fn uploads(&self) -> UploadStats {+ self.model.uploads+ }+fn publish(&self, drawn: DrawStats) {if let Ok(mut s) = self.stats.lock() {*s = drawn;@@ -2426,18 +3065,31 @@ impl Renderer {} else {(&res.model, &res.sketch, &res.highlight, &res.preview)};+ // A block's triangles of one class, drawn from its canonical vertex buffer.+ let block_class = |pass: &mut wgpu::RenderPass<'static>, p: &wgpu::RenderPipeline, class: TriClass| {+ for key in &m.block_order {+ let Some(block) = m.blocks.get(key) else { continue };+ if block.class(class).is_some() {+ pass.set_pipeline(p);+ block.draw(pass, class, tally);+ }+ }+ };if phase == Phase::AfterSeeThrough {pass.set_bind_group(1, &res.access_bind, &[]);pass.set_bind_group(2, &res.ao.bind, &[]);Self::draw_over(res, pass, sk, h, pv, m, &tris, &lines);return;}+ pass.set_bind_group(0, scene_bind(m, &res.bind), &[]);lines(pass, &res.overlay, &m.under);+ pass.set_bind_group(0, scene_bind(sk, &res.bind), &[]);lines(pass, &res.overlay, &sk.under);pass.set_bind_group(1, &res.access_bind, &[]);pass.set_bind_group(2, &res.ao.bind, &[]);+ pass.set_bind_group(0, scene_bind(m, &res.bind), &[]);let planned = |pass: &mut wgpu::RenderPass<'static>, p: &wgpu::RenderPipeline| {- for d in &m.planned {+ for d in m.planned.iter().filter(|d| d.class == TriClass::Opaque) {pass.set_pipeline(p);pass.set_vertex_buffer(0, d.mesh.vertices.slice(..));pass.set_vertex_buffer(1, d.colors.slice(..));@@ -2467,23 +3119,17 @@ impl Renderer {}}};- // Whole highlighted bodies the model builds on the CPU: their part of a block's triangle- // buffer (the blocks may run over several buffers).+ // Whole highlighted bodies the model builds on the CPU: their runs of a block's vertex+ // buffer (a block too large for one vertex buffer has its highlight skipped).let tinted_blocks = |pass: &mut wgpu::RenderPass<'static>, p: &wgpu::RenderPipeline, refs: &[BlockTris]| {for r in refs {let Some(block) = m.blocks.get(&r.block) else { continue };- let Some(batch) = &block.tris else { continue };+ let Some(vertices) = &block.vertices else { continue };pass.set_pipeline(p);- let mut base = 0u32;- for (buffer, count) in &batch.parts {- let end = base.saturating_add(*count);- let (lo, hi) = (r.tris.start.max(base), r.tris.end.min(end));- if lo < hi {- pass.set_vertex_buffer(0, buffer.slice(..));- pass.draw(lo - base..hi - base, 0..1);- tally.triangles(hi - lo, 1);- }- base = end;+ pass.set_vertex_buffer(0, vertices.slice(..));+ for run in &r.tris {+ pass.draw(run.clone(), 0..1);+ tally.triangles(run.len() as u32, 1);}}};@@ -2504,11 +3150,16 @@ impl Renderer {res.section_reset.as_ref(),) {(Some(cut), Some(cut_planned), Some(cut_instanced), Some(cut_flat), Some(reset)) => {+ // The model's own triangles, blocks, plans and instances with its palette, then the+ // preview's with its own.let all = |pass: &mut wgpu::RenderPass<'static>, pick: fn(&Cut) -> &wgpu::RenderPipeline| {+ pass.set_bind_group(0, scene_bind(m, &res.bind), &[]);tris(pass, pick(cut), &m.tris);- tris(pass, pick(cut), &pv.tris);+ block_class(pass, pick(cut), TriClass::Opaque);planned(pass, pick(cut_planned));instanced(pass, pick(cut_instanced), pick(cut_flat));+ pass.set_bind_group(0, scene_bind(pv, &res.bind), &[]);+ tris(pass, pick(cut), &pv.tris);};pass.set_stencil_reference(1);all(pass, |c| &c.mark);@@ -2519,30 +3170,60 @@ impl Renderer {all(pass, |c| &c.cap);}_ => {+ pass.set_bind_group(0, scene_bind(m, &res.bind), &[]);tris(pass, &res.tri, &m.tris);- tris(pass, &res.tri, &pv.tris);+ block_class(pass, &res.tri, TriClass::Opaque);planned(pass, &res.tri_planned);instanced(pass, &res.tri_instanced, &res.tri_instanced_flat);+ pass.set_bind_group(0, scene_bind(pv, &res.bind), &[]);+ tris(pass, &res.tri, &pv.tris);}}+ pass.set_bind_group(0, scene_bind(m, &res.bind), &[]);tris(pass, &res.pbr, &m.pbr);// Whole-body tints first, so a face or an edge highlighted over the body (in `h.tris`// and `h.lines`) keeps its own colour, as it did when the body's triangles were built// into the same list before them.+ // The model's own data (blocks, plans, instanced meshes) uses the model palette; the+ // highlight scene's own geometry uses the highlight palette.tinted(pass, &res.tri_hl_hover, &h.hover_planned);tinted(pass, &res.tri_hl_selected, &h.selected_planned);tinted_blocks(pass, &res.tri_hl_hover_built, &h.hover_blocks);tinted_blocks(pass, &res.tri_hl_selected_built, &h.selected_blocks);+ pass.set_bind_group(0, scene_bind(h, &res.bind), &[]);tinted_instanced(pass, &res.tri_hl_instanced, &res.tri_hl_instanced_flat, &h.hover_instanced);tinted_instanced(pass, &res.tri_hl_instanced, &res.tri_hl_instanced_flat, &h.selected_instanced);+ // Whole faded or see-through bodies: the model's block vertices, in this palette.+ for r in &h.recoloured {+ let Some(block) = m.blocks.get(&r.block) else { continue };+ let Some(vertices) = &block.vertices else { continue };+ pass.set_pipeline(&res.tri_hl);+ pass.set_vertex_buffer(0, vertices.slice(..));+ pass.draw(r.vertices.clone(), 0..1);+ tally.triangles(r.vertices.len() as u32, 1);+ }+ // The highlight's own feedback triangles: its blocks' (kept while it is unchanged), then+ // the loose ones.+ for key in &h.block_order {+ if let Some(block) = h.blocks.get(key).filter(|b| b.class(TriClass::Opaque).is_some()) {+ pass.set_pipeline(&res.tri_hl);+ block.draw(pass, TriClass::Opaque, tally);+ }+ }tris(pass, &res.tri_hl, &h.tris);+ pass.set_bind_group(0, scene_bind(m, &res.bind), &[]);lines(pass, &res.line, &m.lines);+ pass.set_bind_group(0, scene_bind(sk, &res.bind), &[]);lines(pass, &res.line, &sk.lines);+ pass.set_bind_group(0, scene_bind(m, &res.bind), &[]);lines(pass, &res.line_hidden, &m.hidden);+ pass.set_bind_group(0, scene_bind(h, &res.bind), &[]);lines(pass, &res.line_hidden, &h.hidden);- lines(pass, &res.line, &pv.lines);lines(pass, &res.line, &h.lines);lines(pass, &res.guide_line, &h.guide_lines);+ pass.set_bind_group(0, scene_bind(pv, &res.bind), &[]);+ lines(pass, &res.line, &pv.lines);+ pass.set_bind_group(0, scene_bind(m, &res.bind), &[]);for (id, q) in res.quads.iter().filter(|_| !cb.product) {if let Some((_, bind)) = res.textures.get(id) {pass.set_pipeline(&res.image);@@ -2554,7 +3235,9 @@ impl Renderer {}}}+ pass.set_bind_group(0, scene_bind(pv, &res.bind), &[]);tris(pass, &res.ghost, &pv.ghost);+ pass.set_bind_group(0, scene_bind(m, &res.bind), &[]);tris(pass, &res.trans, &m.shadow);if phase == Phase::BeforeSeeThrough {return;@@ -2571,6 +3254,7 @@ impl Renderer {tris(pass, &res.glass_near, &m.glass);see_through(pass, InstanceLook::Glass, &res.glass_near_instanced);tris(pass, &res.trans, &m.trans);+ block_class(pass, &res.trans, TriClass::Faded);see_through(pass, InstanceLook::Faded, &res.trans_instanced);Self::draw_over(res, pass, sk, h, pv, m, &tris, &lines);}@@ -2587,20 +3271,26 @@ impl Renderer {tris: &dyn Fn(&mut wgpu::RenderPass<'static>, &wgpu::RenderPipeline, &Option<Batch>),lines: &dyn Fn(&mut wgpu::RenderPass<'static>, &wgpu::RenderPipeline, &Option<Batch>),) {+ pass.set_bind_group(0, scene_bind(sk, &res.bind), &[]);tris(pass, &res.trans, &sk.trans);+ pass.set_bind_group(0, scene_bind(h, &res.bind), &[]);tris(pass, &res.trans, &h.trans);tris(pass, &res.guide_trans, &h.guide_trans);- tris(pass, &res.xray, &pv.xray);tris(pass, &res.xray, &h.xray);+ pass.set_bind_group(0, scene_bind(pv, &res.bind), &[]);+ tris(pass, &res.xray, &pv.xray);+ pass.set_bind_group(0, scene_bind(m, &res.bind), &[]);lines(pass, &res.overlay, &m.overlays);+ pass.set_bind_group(0, scene_bind(sk, &res.bind), &[]);lines(pass, &res.overlay, &sk.overlays);+ pass.set_bind_group(0, scene_bind(h, &res.bind), &[]);lines(pass, &res.overlay, &h.overlays);}/// The model's see-through surfaces into the order-independent transparency's targets.fn draw_see_through(&self, pass: &mut wgpu::RenderPass<'static>, p: &oit::Pipelines, tally: &Tally) {let m = &self.model;- pass.set_bind_group(0, &self.bind, &[]);+ pass.set_bind_group(0, scene_bind(m, &self.bind), &[]);pass.set_pipeline(&p.built);for batch in [&m.glass, &m.trans].into_iter().flatten() {for (buffer, count) in &batch.parts {@@ -2609,6 +3299,26 @@ impl Renderer {tally.triangles(*count, 1);}}+ // The blocks' see-through triangles, straight from their vertex buffers (nothing sorted).+ for class in [TriClass::Glass, TriClass::Faded] {+ for key in &m.block_order {+ if let Some(block) = m.blocks.get(key) {+ block.draw(pass, class, tally);+ }+ }+ }+ // Faded and see-through bodies drawn from their plans.+ let mut planned = m.planned.iter().filter(|d| d.class != TriClass::Opaque).peekable();+ if planned.peek().is_some() {+ pass.set_pipeline(&p.planned);+ for d in planned {+ pass.set_vertex_buffer(0, d.mesh.vertices.slice(..));+ pass.set_vertex_buffer(1, d.colors.slice(..));+ pass.set_index_buffer(d.mesh.indices.slice(..), wgpu::IndexFormat::Uint32);+ pass.draw_indexed(0..d.mesh.index_count, 0, 0..1);+ tally.triangles(d.mesh.index_count, 1);+ }+ }for d in m.instanced.iter().filter(|d| d.look != InstanceLook::Opaque) {d.draw(pass, &p.instanced, &p.instanced_flat, tally);}@@ -3156,8 +3866,9 @@ mod glass_tests {fn ground_shadow_blends_and_stays_behind_opaque_geometry() {let mut scene = GpuScene::default();let square = [[-5.0, -5.0, -5.0], [5.0, -5.0, -5.0], [5.0, 5.0, -5.0], [-5.0, -5.0, -5.0], [5.0, 5.0, -5.0], [-5.0, 5.0, -5.0]];+ let shadow_color = scene.color([0, 0, 0, 128]);for p in square {- scene.shadow_tri(p, [0, 0, 0, 128]);+ scene.shadow_tri(p, shadow_color);}for samples in [1, 4] {let Some(shadow) = middle_pixel_with_samples(scene.clone(), true, samples) else {@@ -3166,9 +3877,10 @@ mod glass_tests {};assert!(shadow[..3].iter().all(|c| (125..=129).contains(c)), "{samples}× alpha-blended shadow: {shadow:?}");let mut occluded = scene.clone();+ let green = occluded.color([0, 255, 0, 255]);for mut p in square {p[2] = 5.0;- occluded.tri(p, [0.0; 3], [0, 255, 0, 255]);+ occluded.tri(p, [0.0; 3], green);}assert_eq!(middle_pixel_with_samples(occluded, true, samples), Some([0, 255, 0, 255]), "opaque geometry hides the ground shadow");}@@ -3190,6 +3902,43 @@ mod glass_tests {assert!(buffer_chunk(TRI_SIZE, 1) >= TRI_SIZE * 6, "a tiny limit still holds one unit");}+ /// Without order-independent transparency, the sorted glass stream is kept while the blocks'+ /// see-through triangles stay the same: a colour edit (a new palette) uploads palette rows+ /// and no geometry; a class change rebuilds the stream.+ #[test]+ fn a_colour_edit_keeps_the_sorted_glass_stream() {+ let Ok((_, device, queue)) = crate::open_headless() else { return };+ let format = wgpu::TextureFormat::Rgba8Unorm;+ let mut r =+ Renderer::new(&device, GpuTarget { format, depth: Some(crate::depth_format(&device, true)), samples: 1, tess: false, oit: false }, None);+ let mut palette = Palette::with_stable(vec![[200, 0, 0, 128]]);+ let mut b = BlockBuilder::default();+ b.triangle([[0.0; 3], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], [[0.0, 0.0, 1.0]; 3], PaletteIndex(0), TriClass::Glass);+ let bytes = b.freeze();+ let scene = |palette: &Palette, bytes: &Arc<BlockBytes>| GpuScene {+ palette: Arc::new(palette.clone()),+ blocks: vec![SceneBlock { key: 7, bytes: bytes.clone() }],+ ..GpuScene::default()+ };+ let take = |r: &mut Renderer, key: u64, sc: GpuScene| {+ let slot: SceneSlot = Arc::new(Mutex::new(Some(sc)));+ r.model.take(&device, &queue, &r.uniform, &r.uniform_bgl, key, &slot, None, false);+ r.model.uploads+ };+ let first = take(&mut r, 1, scene(&palette, &bytes));+ assert_eq!(first.geometry, (2 * 3 * TRI_SIZE) as u64, "the block's vertices and the sorted stream: {first:?}");+ palette.set(PaletteIndex(0), [0, 0, 200, 128]);+ let colour = take(&mut r, 2, scene(&palette, &bytes));+ assert_eq!(colour.geometry, 0, "a colour edit keeps the stream: {colour:?}");+ assert!(colour.palette > 0, "and writes the palette: {colour:?}");+ let mut b = BlockBuilder::default();+ b.triangle([[0.0; 3], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0]], [[0.0, 0.0, 1.0]; 3], PaletteIndex(0), TriClass::Opaque);+ let opaque = take(&mut r, 3, scene(&palette, &b.freeze()));+ assert!(opaque.geometry > 0, "new block geometry is uploaded: {opaque:?}");+ let back = take(&mut r, 4, scene(&palette, &bytes));+ assert!(back.geometry >= (3 * TRI_SIZE) as u64, "the stream is rebuilt when the see-through set changes: {back:?}");+ }+/// The middle pixel of `scene` drawn looking down -Z (x, y in -10..10) into a 64 × 64 frame,/// with order-independent transparency (`oit`) or with the see-through triangles sorted./// `None` without a GPU adapter.@@ -3202,7 +3951,7 @@ mod glass_tests {let (_, device, queue) = crate::open_headless().ok()?;let depth = crate::depth_format(&device, true);let format = wgpu::TextureFormat::Rgba8Unorm;- let mut r = Renderer::new(&device, GpuTarget { format, depth: Some(depth), samples, tess: false }, None);+ let mut r = Renderer::new(&device, GpuTarget { format, depth: Some(depth), samples, tess: false, oit: false }, None);assert!(r.oit.is_some(), "this device does order-independent transparency");if !oit {r.oit = None;@@ -3411,9 +4160,10 @@ mod glass_tests {/// A frame of opaque triangles at the fixed view.fn test_scene() -> GpuScene {let mut scene = GpuScene::default();- scene.tri([-5.0, -5.0, 0.0], [0.0, 0.0, 1.0], [255, 0, 0, 255]);- scene.tri([5.0, -5.0, 0.0], [0.0, 0.0, 1.0], [255, 0, 0, 255]);- scene.tri([0.0, 5.0, 0.0], [0.0, 0.0, 1.0], [255, 0, 0, 255]);+ let red = scene.color([255, 0, 0, 255]);+ scene.tri([-5.0, -5.0, 0.0], [0.0, 0.0, 1.0], red);+ scene.tri([5.0, -5.0, 0.0], [0.0, 0.0, 1.0], red);+ scene.tri([0.0, 5.0, 0.0], [0.0, 0.0, 1.0], red);scene}@@ -3425,7 +4175,7 @@ mod glass_tests {let Some((_, device, queue)) = crate::open_headless().ok() else { return };let depth = crate::depth_format(&device, true);let format = wgpu::TextureFormat::Rgba8Unorm;- let mut r = Renderer::new(&device, GpuTarget { format, depth: Some(depth), samples: 1, tess: false }, None);+ let mut r = Renderer::new(&device, GpuTarget { format, depth: Some(depth), samples: 1, tess: false, oit: false }, None);// Supersampled: the picture is drawn into a texture, so it can be cached.let mut frame = test_frame(test_scene(), 2.0);let first = render_frame(&mut r, &device, &queue, &frame, true);@@ -3448,8 +4198,8 @@ mod glass_tests {let Some((_, device, queue)) = crate::open_headless().ok() else { return };let depth = crate::depth_format(&device, true);let format = wgpu::TextureFormat::Rgba8Unorm;- let scene_target = GpuTarget { format, depth: Some(depth), samples: 1, tess: false };- let window_target = GpuTarget { format, depth: None, samples: 1, tess: false };+ let scene_target = GpuTarget { format, depth: Some(depth), samples: 1, tess: false, oit: false };+ let window_target = GpuTarget { format, depth: None, samples: 1, tess: false, oit: false };let mut direct = Renderer::new(&device, scene_target, None);let mut split = Renderer::with_window_target(&device, scene_target, window_target, None);// Each renderer takes the scene out of its slot: a frame of its own for each.@@ -3468,7 +4218,7 @@ mod glass_tests {let Some((_, device, queue)) = crate::open_headless().ok() else { return };let depth = crate::depth_format(&device, true);let format = wgpu::TextureFormat::Rgba8Unorm;- let mut r = Renderer::new(&device, GpuTarget { format, depth: Some(depth), samples: 1, tess: false }, None);+ let mut r = Renderer::new(&device, GpuTarget { format, depth: Some(depth), samples: 1, tess: false, oit: false }, None);let middle = |pixels: &[u8]| -> [i32; 4] {let at = (32 * 64 + 32) * 4;std::array::from_fn(|i| pixels.get(at + i).map_or(-1, |v| i32::from(*v)))@@ -3478,8 +4228,9 @@ mod glass_tests {assert!(r.ss_ready, "the see-through modelling frame is drawn offscreen");assert!(model[0] > model[2] + 60, "the modelling frame shows its red layers: {model:?}");let mut product = GpuScene::default();+ let blue = product.color([40, 80, 220, 255]);for p in [[-5.0, -5.0], [5.0, -5.0], [5.0, 5.0], [-5.0, -5.0], [5.0, 5.0], [-5.0, 5.0]] {- product.tri([p[0], p[1], 0.0], [0.0, 0.0, 1.0], [40, 80, 220, 255]);+ product.tri([p[0], p[1], 0.0], [0.0, 0.0, 1.0], blue);}let mut frame = test_frame(product, 1.0);frame.product = true;@@ -3503,7 +4254,7 @@ mod glass_tests {};let depth = crate::depth_format(&device, true);for format in [wgpu::TextureFormat::Rgba8Unorm, wgpu::TextureFormat::Bgra8Unorm, wgpu::TextureFormat::Bgra8UnormSrgb] {- let window = GpuTarget { format, depth: None, samples: 1, tess: false };+ let window = GpuTarget { format, depth: None, samples: 1, tess: false, oit: false };for samples in [1, 4] {if ![format, depth].iter().all(|f| adapter.get_texture_format_features(*f).flags.sample_count_supported(samples)) {continue;@@ -3539,6 +4290,7 @@ mod glass_tests {layers.reverse();}for (z, c) in layers {+ let c = sc.color(c);for p in [[-5.0, -5.0], [5.0, -5.0], [5.0, 5.0], [-5.0, -5.0], [5.0, 5.0], [-5.0, 5.0]] {sc.glass_tri([p[0], p[1], z], [0.0, 0.0, 1.0], c);}@@ -3572,9 +4324,10 @@ mod glass_tests {fn glass_is_drawn_far_to_near() {// Two triangles at z = 5 and z = -5, given near first; looking down from +Z.let mut sc = GpuScene::default();+ let red = sc.color([255, 0, 0, 100]);for z in [5.0f32, -5.0] {for p in [[0.0, 0.0, z], [1.0, 0.0, z], [0.0, 1.0, z]] {- sc.glass_tri(p, [0.0, 0.0, 1.0], [255, 0, 0, 100]);+ sc.glass_tri(p, [0.0, 0.0, 1.0], red);}}let sorted = sort_back_to_front(&sc.glass, [0.0, 0.0, 1.0]);diff --git a/crates/gpu/src/view/ao.rs b/crates/gpu/src/view/ao.rsindex 7bba01b88b..e6e51525c2 100644--- a/crates/gpu/src/view/ao.rs+++ b/crates/gpu/src/view/ao.rs@@ -116,7 +116,7 @@ impl Resources {&mut self,device: &wgpu::Device,encoder: &mut wgpu::CommandEncoder,- uniform: &wgpu::BindGroup,+ binds: [&wgpu::BindGroup; 2],radius: f32,size_px: [f32; 2],reversed: bool,@@ -152,8 +152,8 @@ impl Resources {occlusion_query_set: None,multiview_mask: None,});- pass.set_bind_group(0, uniform, &[]);- for batch in batches {+ for (batch, bind) in batches.into_iter().zip(binds) {+ pass.set_bind_group(0, bind, &[]);pass.set_pipeline(&self.pipeline);if let Some(tris) = &batch.tris {for (buffer, count) in &tris.parts {@@ -161,15 +161,21 @@ impl Resources {pass.draw(0..*count, 0..1);}}+ // The depth prepass is left out of the performance overlay's counts, as before.+ let uncounted = super::Tally::default();+ // The blocks' opaque triangles, for the same depth.+ for key in &batch.block_order {+ if let Some(block) = batch.blocks.get(key) {+ block.draw(&mut pass, super::TriClass::Opaque, &uncounted);+ }+ }pass.set_pipeline(&self.planned_pipeline);- for draw in &batch.planned {+ for draw in batch.planned.iter().filter(|d| d.class == super::TriClass::Opaque) {pass.set_vertex_buffer(0, draw.mesh.vertices.slice(..));pass.set_vertex_buffer(1, draw.colors.slice(..));pass.set_index_buffer(draw.mesh.indices.slice(..), wgpu::IndexFormat::Uint32);pass.draw_indexed(0..draw.mesh.index_count, 0, 0..1);}- // The depth prepass is left out of the performance overlay's counts, as before.- let uncounted = super::Tally::default();for draw in batch.instanced.iter().filter(|d| d.look == super::InstanceLook::Opaque) {draw.draw(&mut pass, &self.instanced_pipeline, &self.instanced_flat_pipeline, &uncounted);}diff --git a/crates/gpu/src/view/msaa_check.rs b/crates/gpu/src/view/msaa_check.rsindex 7ad61ffe9f..591c3581d8 100644--- a/crates/gpu/src/view/msaa_check.rs+++ b/crates/gpu/src/view/msaa_check.rs@@ -80,12 +80,14 @@ impl Renderer {fn probe_pixels(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, blank_samples: u32) -> Result<bool> {const SIZE: u32 = 16;let mut model = GpuScene::default();+ let red = model.color([255, 0, 0, 255]);for p in [[-0.9, -0.9, 0.0], [0.9, -0.9, 0.0], [0.0, 0.9, 0.0]] {- model.tri(p, [0.0, 0.0, 1.0], [255, 0, 0, 255]);+ model.tri(p, [0.0, 0.0, 1.0], red);}let mut highlight = GpuScene::default();+ let blue = highlight.color([0, 0, 255, 64]);for p in [[-0.8, -0.8, 0.0], [0.8, -0.8, 0.0], [0.8, 0.8, 0.0], [-0.8, -0.8, 0.0], [0.8, 0.8, 0.0], [-0.8, 0.8, 0.0]] {- highlight.xray_tri(p, [0.0, 0.0, 1.0], [0, 0, 255, 64]);+ highlight.xray_tri(p, [0.0, 0.0, 1.0], blue);}let slot = |scene| Arc::new(Mutex::new(scene));let frame = Frame {diff --git a/crates/gpu/src/view/oit.rs b/crates/gpu/src/view/oit.rsindex 54245ceecb..27bd99a45d 100644--- a/crates/gpu/src/view/oit.rs+++ b/crates/gpu/src/view/oit.rs@@ -8,7 +8,7 @@//! sorted, on the CPU or the GPU, however many see-through triangles there are. The targets share//! the frame's depth (tested, not written), so the opaque model hides what lies behind it.-use super::{TriSource, depth_compare, instance_layout, shared_layout, tri_layout};+use super::{TriSource, color_layout, depth_compare, instance_layout, planned_layout, shared_layout, tri_layout};/// The accumulated colour (premultiplied, weighted) and alpha.const ACCUM: wgpu::TextureFormat = wgpu::TextureFormat::Rgba16Float;@@ -38,6 +38,8 @@ fn fs(@builtin(position) pos: vec4<f32>) -> @location(0) vec4<f32> {pub(super) struct Pipelines {/// Built triangles ([`tri_layout`]), and instanced meshes smooth and flat.pub built: wgpu::RenderPipeline,+ /// Faded and see-through bodies drawn from their plans' evaluated vertices.+ pub planned: wgpu::RenderPipeline,pub instanced: wgpu::RenderPipeline,pub instanced_flat: wgpu::RenderPipeline,composite: wgpu::RenderPipeline,@@ -90,6 +92,7 @@ impl Pipelines {}),];let built_buffers = [Some(tri_layout())];+ let evaluated = [Some(planned_layout()), Some(color_layout())];let placed = [Some(shared_layout()), Some(instance_layout())];let pipeline = |label: &str, source: TriSource| {device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {@@ -98,7 +101,11 @@ impl Pipelines {vertex: wgpu::VertexState {module,entry_point: Some(source.entry()),- buffers: if source == TriSource::Built { &built_buffers[..] } else { &placed[..] },+ buffers: match source {+ TriSource::Built => &built_buffers[..],+ TriSource::Planned => &evaluated[..],+ TriSource::Instanced | TriSource::InstancedFlat => &placed[..],+ },compilation_options: Default::default(),},primitive: wgpu::PrimitiveState { topology: wgpu::PrimitiveTopology::TriangleList, ..Default::default() },@@ -121,6 +128,7 @@ impl Pipelines {})};let built = pipeline("sc_oit", TriSource::Built);+ let planned = pipeline("sc_oit_planned", TriSource::Planned);let instanced = pipeline("sc_oit_instanced", TriSource::Instanced);let instanced_flat = pipeline("sc_oit_instanced_flat", TriSource::InstancedFlat);let texture = |binding| wgpu::BindGroupLayoutEntry {@@ -183,7 +191,7 @@ impl Pipelines {log::info!("see-through surfaces are sorted (no order-independent transparency here: {e})");return None;}- Some(Pipelines { built, instanced, instanced_flat, composite, bgl })+ Some(Pipelines { built, planned, instanced, instanced_flat, composite, bgl })}/// The targets for a frame of `size` pixels at `samples` per pixel.diff --git a/crates/gpu/tests/depth.rs b/crates/gpu/tests/depth.rsindex 04744bf52d..024aeca916 100644--- a/crates/gpu/tests/depth.rs+++ b/crates/gpu/tests/depth.rs@@ -197,7 +197,8 @@ fn an_edge_on_a_face_draws_whole_at_any_angle() {fn a_selected_edge_on_a_grazing_face_draws_whole() {let highlight = |a: Vec3, b: Vec3, n: Vec3| {let mut sc = solidcraft_gpu::view::GpuScene::default();- sc.lifted_line(a.to_f32(), b.to_f32(), [255, 0, 0, 255], 6.0, [n.to_f32(), n.to_f32()]);+ let red = sc.color([255, 0, 0, 255]);+ sc.lifted_line(a.to_f32(), b.to_f32(), red, 6.0, [n.to_f32(), n.to_f32()]);sc};let reference = |a: Vec3, b: Vec3| vec![SceneLine { points: vec![a, b], color: Rgb(255, 0, 0), alpha: 1.0, width: 6.0, on_top: true }];diff --git a/crates/ui-egui/src/extrude_preview.rs b/crates/ui-egui/src/extrude_preview.rsindex 14d1541d43..227daa4bbe 100644--- a/crates/ui-egui/src/extrude_preview.rs+++ b/crates/ui-egui/src/extrude_preview.rs@@ -105,13 +105,15 @@ impl StraightPreview {let cache = self.cached.as_ref()?;let mut scene = GpuScene::default();let mut bounds = cache.bounds;- let color = if operation == "cut" {- colors.removed+ let (color, cut_edge) = if operation == "cut" {+ (colors.removed, [colors.removed[0], colors.removed[1], colors.removed[2], 255])} else if operation == "intersect" {- [colors.added[0], colors.added[1], colors.added[2], colors.removed[3]]+ ([colors.added[0], colors.added[1], colors.added[2], colors.removed[3]], colors.edge)} else {- colors.added+ (colors.added, colors.edge)};+ let color = scene.color(color);+ let cut_edge = scene.color(cut_edge);let triangle = |scene: &mut GpuScene, points: [Vec3; 3], normal: Vec3| {for point in points {if matches!(operation, "cut" | "intersect") {@@ -131,7 +133,7 @@ impl StraightPreview {bounds.add(point);}}- let edge_color = if operation == "cut" { [color[0], color[1], color[2], 255] } else { colors.edge };+ let edge_color = if operation == "cut" { cut_edge } else { scene.color(colors.edge) };for &[a, b] in &surface.edges {let normal = (b - a).cross(surface.normal).normalized()?;triangle(&mut scene, [a + low, b + low, b + high], normal);diff --git a/crates/ui-egui/src/gpu.rs b/crates/ui-egui/src/gpu.rsindex 4903b75119..2535f3ddaa 100644--- a/crates/ui-egui/src/gpu.rs+++ b/crates/ui-egui/src/gpu.rs@@ -8,9 +8,9 @@ use std::sync::{Arc, Mutex};use egui_wgpu::wgpu;pub use solidcraft_gpu::view::{- AccessMap, BlockBytes, BlockTris, DrawStats, DrawStatsHandle, Frame, GpuImage, GpuScene, GpuTarget, INSTANCE_SIZE, InstanceLook, InstancedMesh,- LINE_SIZE, LOD_PX, PBR_SIZE, PlannedBody, Renderer, SHARED_SIZE, SceneBlock, SceneSlot, SharedTris, TRI_SIZE, level_for, placement_scale,- supersampled_size,+ AccessMap, BlockBuilder, BlockBytes, BlockTris, DrawStats, DrawStatsHandle, Frame, GpuImage, GpuScene, GpuTarget, INSTANCE_SIZE, InstanceLook,+ InstancedMesh, LINE_SIZE, LOD_PX, MAX_PALETTE, PBR_SIZE, Palette, PaletteIndex, PlannedBody, Renderer, SHARED_SIZE, SceneBlock, SceneSlot,+ SharedTris, TRI_SIZE, TriClass, extend_runs, level_for, placement_scale, runs_within, supersampled_size,};/// A frame of the viewport as an egui paint callback.@@ -27,6 +27,8 @@ pub fn install(rs: &egui_wgpu::RenderState, scene: GpuTarget, window: GpuTarget,let scene = GpuTarget { tess: tess.is_some(), ..scene };let window = GpuTarget { tess: tess.is_some(), ..window };let res = Renderer::with_window_target(&rs.device, scene, window, tess);+ // What the renderer can do (order-independent transparency), not only what was asked for.+ let scene = res.target();let stats = res.stats();rs.renderer.write().callback_resources.insert(res);(scene, stats)@@ -333,7 +335,7 @@ fn offscreen(let format = if srgb { wgpu::TextureFormat::Rgba8UnormSrgb } else { wgpu::TextureFormat::Rgba8Unorm };let depth = solidcraft_gpu::depth_format(&device, true);let compute = tess.and_then(|shader| solidcraft_gpu::view::tessellation(&adapter, &device, &queue, shader));- let target = GpuTarget { format, depth: Some(depth), samples: 1, tess: compute.is_some() };+ let target = GpuTarget { format, depth: Some(depth), samples: 1, tess: compute.is_some(), oit: false };let mut resources = egui_wgpu::CallbackResources::default();resources.insert(Renderer::new(&device, target, compute));let none = || Arc::new(Mutex::new(None));@@ -428,6 +430,106 @@ fn offscreen(Some(bytes)}+/// A viewport renderer kept on an offscreen device of its own, for timing frames (prepare, paint,+/// and the GPU finishing them) as the window would draw them. Scale measurements only.+#[cfg(all(test, not(target_arch = "wasm32")))]+pub(crate) struct OffscreenFrames {+ device: wgpu::Device,+ queue: wgpu::Queue,+ resources: egui_wgpu::CallbackResources,+ color: wgpu::TextureView,+ depth: wgpu::TextureView,+ size: u32,+}++#[cfg(all(test, not(target_arch = "wasm32")))]+impl OffscreenFrames {+ /// `None` without a GPU adapter. With `tess`, planned bodies are evaluated on the GPU.+ pub(crate) fn new(size: u32, tess: bool) -> Option<OffscreenFrames> {+ let (adapter, device, queue) = offscreen_device()?;+ let format = wgpu::TextureFormat::Rgba8Unorm;+ let depth = solidcraft_gpu::depth_format(&device, true);+ let compute = if tess { solidcraft_gpu::view::tessellation(&adapter, &device, &queue, solidcraft_gpu::SHADER) } else { None };+ let target = GpuTarget { format, depth: Some(depth), samples: 1, tess: compute.is_some(), oit: false };+ let mut resources = egui_wgpu::CallbackResources::default();+ resources.insert(Renderer::new(&device, target, compute));+ let texture = |format, usage| {+ device+ .create_texture(&wgpu::TextureDescriptor {+ label: Some("offscreen frames"),+ 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,+ view_formats: &[],+ })+ .create_view(&Default::default())+ };+ let color = texture(format, wgpu::TextureUsages::RENDER_ATTACHMENT);+ let depth = texture(depth, wgpu::TextureUsages::RENDER_ATTACHMENT);+ Some(OffscreenFrames { device, queue, resources, color, depth, size })+ }++ /// What the renderer can do, as the viewport is told when the window's renderer is+ /// installed (plans evaluated, order-independent transparency).+ pub(crate) fn target(&self) -> Option<GpuTarget> {+ self.resources.get::<Renderer>().map(Renderer::target)+ }++ /// Whether the device evaluates plans (so scenes should be built with `tess`).+ pub(crate) fn tessellates(&self) -> bool {+ self.resources.get::<Renderer>().is_some_and(|r| r.target().tess)+ }++ /// Draw one frame and wait for the GPU: milliseconds from `prepare` to the work finishing.+ pub(crate) fn frame(&mut self, frame: Frame) -> f64 {+ let started = std::time::Instant::now();+ let cb = ViewportCallback(frame);+ let mut encoder = self.device.create_command_encoder(&Default::default());+ let screen = egui_wgpu::ScreenDescriptor { size_in_pixels: [self.size, self.size], pixels_per_point: 1.0 };+ let extra = egui_wgpu::CallbackTrait::prepare(&cb, &self.device, &self.queue, &screen, &mut encoder, &mut self.resources);+ {+ let mut pass = encoder+ .begin_render_pass(&wgpu::RenderPassDescriptor {+ label: Some("offscreen frames"),+ color_attachments: &[Some(wgpu::RenderPassColorAttachment {+ view: &self.color,+ depth_slice: None,+ resolve_target: None,+ ops: wgpu::Operations { load: wgpu::LoadOp::Clear(wgpu::Color::WHITE), store: wgpu::StoreOp::Store },+ })],+ depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {+ view: &self.depth,+ depth_ops: Some(wgpu::Operations { load: wgpu::LoadOp::Clear(1.0), store: wgpu::StoreOp::Store }),+ stencil_ops: Some(wgpu::Operations { load: wgpu::LoadOp::Clear(0), store: wgpu::StoreOp::Store }),+ }),+ timestamp_writes: None,+ occlusion_query_set: None,+ multiview_mask: None,+ })+ .forget_lifetime();+ let rect = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(self.size as f32, self.size as f32));+ let info = egui::PaintCallbackInfo { viewport: rect, clip_rect: rect, pixels_per_point: 1.0, screen_size_px: [self.size, self.size] };+ egui_wgpu::CallbackTrait::paint(&cb, info, &mut pass, &self.resources);+ }+ self.queue.submit(extra.into_iter().chain([encoder.finish()]));+ let _ = self.device.poll(wgpu::PollType::wait_indefinitely());+ started.elapsed().as_secs_f64() * 1000.0+ }++ /// What the model scene's last change uploaded.+ pub(crate) fn uploads(&self) -> solidcraft_gpu::view::UploadStats {+ self.resources.get::<Renderer>().map(Renderer::uploads).unwrap_or_default()+ }++ /// What the last frame drew.+ pub(crate) fn stats(&self) -> DrawStats {+ self.resources.get::<Renderer>().and_then(|r| r.stats().lock().ok().map(|s| *s)).unwrap_or_default()+ }+}+#[cfg(test)]mod tests {/// The offscreen tests start the backends the app would: on Windows without `WGPU_BACKEND`diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex b9fad80b36..e4bb6b38be 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -211,6 +211,7 @@ mod rule_editor;mod rule_editor_tests;pub mod save_job;pub mod scenario;+pub(crate) mod scene_palette;pub mod select_other;pub mod selection;pub mod shell;@@ -778,6 +779,7 @@ impl SolveApp {depth: egui_wgpu::depth_format_from_bits(depth_bits, stencil_bits),samples: samples.max(1),tess: false,+ oit: false,};self.set_wgpu_targets(rs, target, target);}@@ -792,8 +794,9 @@ impl SolveApp {depth: egui_wgpu::depth_format_from_bits(depth_bits, stencil_bits),samples: samples.max(1),tess: false,+ oit: false,};- let window = crate::gpu::GpuTarget { format: rs.target_format, depth: None, samples: 1, tess: false };+ let window = crate::gpu::GpuTarget { format: rs.target_format, depth: None, samples: 1, tess: false, oit: false };self.set_wgpu_targets(rs, scene, window);self.viewport.gpu.map_or(samples, |g| g.samples)}diff --git a/crates/ui-egui/src/move_preview.rs b/crates/ui-egui/src/move_preview.rsindex afbe61bb7c..f66ba782dd 100644--- a/crates/ui-egui/src/move_preview.rs+++ b/crates/ui-egui/src/move_preview.rs@@ -91,6 +91,7 @@ impl MovePreview {let m = rigid(translate, Vec3::ZERO, axis, angle);let copy = params.get("copy").and_then(Value::as_bool) == Some(true);let mut scene = GpuScene::default();+ let removed = scene.color(colors.removed);let mut bounds = Aabb3::EMPTY;for mesh in &cache.meshes {draw(&mut scene, mesh, &m, colors, &mut bounds);@@ -99,7 +100,7 @@ impl MovePreview {for t in &mesh.triangles {for k in t {if let (Some(p), Some(n)) = (mesh.positions.get(*k as usize), mesh.normals.get(*k as usize)) {- scene.ghost_tri(p.to_f32(), n.to_f32(), colors.removed);+ scene.ghost_tri(p.to_f32(), n.to_f32(), removed);}}}@@ -120,22 +121,24 @@ impl MovePreview {/// `mesh` moved by `m`, in the colour of geometry the feature adds, with its shaded edges.fn draw(scene: &mut GpuScene, mesh: &Mesh, m: &Mat, colors: Colors, bounds: &mut Aabb3) {+ let added = scene.color(colors.added);for t in &mesh.triangles {for k in t {let i = *k as usize;if let (Some(p), Some(n)) = (mesh.positions.get(i), mesh.normals.get(i)) {let p = apply_point(m, *p);bounds.add(p);- scene.tri(p.to_f32(), apply_vector(m, *n).to_f32(), colors.added);+ scene.tri(p.to_f32(), apply_vector(m, *n).to_f32(), added);}}}+ let edge = scene.color(colors.edge);for (ei, e) in mesh.edges.iter().enumerate() {if !mesh.shaded_edge_visible(ei) {continue;}for w in e.windows(2) {- scene.line(apply_point(m, w[0]).to_f32(), apply_point(m, w[1]).to_f32(), colors.edge, 1.3, false);+ scene.line(apply_point(m, w[0]).to_f32(), apply_point(m, w[1]).to_f32(), edge, 1.3, false);}}}diff --git a/crates/ui-egui/src/preview.rs b/crates/ui-egui/src/preview.rsindex 53d980725e..e64fb145ed 100644--- a/crates/ui-egui/src/preview.rs+++ b/crates/ui-egui/src/preview.rs@@ -520,6 +520,10 @@ fn state_bounds(st: &ModelState) -> Aabb3 {/// (red) and intersect.fn build_tool(before: &ModelState, after: &ModelState, c: Colors, op: &str) -> Built {let mut sc = GpuScene::default();+ let removed = sc.color(c.removed);+ let intersect = sc.color([c.added[0], c.added[1], c.added[2], c.removed[3]]);+ let added = sc.color(c.added);+ let edge = if op == "cut" { sc.color([c.removed[0], c.removed[1], c.removed[2], 255]) } else { sc.color(c.edge) };for a in after.bodies.iter().filter(|a| before.body(&a.name).is_none()) {let m = a.mesh();for t in &m.triangles {@@ -527,14 +531,13 @@ fn build_tool(before: &ModelState, after: &ModelState, c: Colors, op: &str) -> Blet i = *k as usize;if let (Some(p), Some(n)) = (m.positions.get(i), m.normals.get(i)) {match op {- "cut" => sc.xray_tri(p.to_f32(), n.to_f32(), c.removed),- "intersect" => sc.xray_tri(p.to_f32(), n.to_f32(), [c.added[0], c.added[1], c.added[2], c.removed[3]]),- _ => sc.tri(p.to_f32(), n.to_f32(), c.added),+ "cut" => sc.xray_tri(p.to_f32(), n.to_f32(), removed),+ "intersect" => sc.xray_tri(p.to_f32(), n.to_f32(), intersect),+ _ => sc.tri(p.to_f32(), n.to_f32(), added),}}}}- let edge = if op == "cut" { [c.removed[0], c.removed[1], c.removed[2], 255] } else { c.edge };for (ei, e) in m.edges.iter().enumerate() {if m.shaded_edge_visible(ei) {for w in e.windows(2) {@@ -586,6 +589,12 @@ fn same(a: &Mesh, b: &Mesh) -> bool {/// version of changed or removed bodies.pub fn build(before: &ModelState, after: &ModelState, c: Colors) -> Built {let mut sc = GpuScene::default();+ let added_color = sc.color(c.added);+ let added_plane = sc.color([c.added[0], c.added[1], c.added[2], 64]);+ let body_color = sc.color(c.body);+ let new_body = sc.color(c.new_body);+ let removed = sc.color(c.removed);+ let edge = sc.color(c.edge);let mut replaced = Vec::new();for construct in &after.construct {if before.construct.iter().any(|old| old == construct) {@@ -594,14 +603,13 @@ pub fn build(before: &ModelState, after: &ModelState, c: Colors) -> Built {if let solidcraft_engine::doc::construct::ConstructGeom::Plane(plane) = construct.geom {let (o, x, y) = (plane.origin, plane.x * 10.0, plane.y * 10.0);let quad = [o - x - y, o + x - y, o + x + y, o - x + y];- let color = [c.added[0], c.added[1], c.added[2], 64];for triangle in [[quad[0], quad[1], quad[2]], [quad[0], quad[2], quad[3]]] {for p in triangle {- sc.xray_tri(p.to_f32(), plane.normal().to_f32(), color);+ sc.xray_tri(p.to_f32(), plane.normal().to_f32(), added_plane);}}for (a, b) in Ring::from(quad).edges() {- sc.line(a.to_f32(), b.to_f32(), c.added, 1.3, true);+ sc.line(a.to_f32(), b.to_f32(), added_color, 1.3, true);}}}@@ -622,16 +630,16 @@ pub fn build(before: &ModelState, after: &ModelState, c: Colors) -> Built {for (t, f) in am.triangles.iter().zip(&am.tri_face) {let new = added.get(*f as usize).copied().unwrap_or(true);let col = match (new, old.is_some()) {- (false, _) => c.body,- (true, true) => c.added,- (true, false) => c.new_body,+ (false, _) => body_color,+ (true, true) => added_color,+ (true, false) => new_body,};for k in t {let i = *k as usize;if let (Some(p), Some(n)) = (am.positions.get(i), am.normals.get(i)) {sc.tri(p.to_f32(), n.to_f32(), col);if new && cut {- sc.xray_tri(p.to_f32(), n.to_f32(), c.removed);+ sc.xray_tri(p.to_f32(), n.to_f32(), removed);}}}@@ -641,7 +649,7 @@ pub fn build(before: &ModelState, after: &ModelState, c: Colors) -> Built {continue;}for w in e.windows(2) {- sc.line(w[0].to_f32(), w[1].to_f32(), c.edge, 1.3, false);+ sc.line(w[0].to_f32(), w[1].to_f32(), edge, 1.3, false);}}if old.is_some() {@@ -658,7 +666,7 @@ pub fn build(before: &ModelState, after: &ModelState, c: Colors) -> Built {for k in t {let i = *k as usize;if let (Some(p), Some(n)) = (m.positions.get(i), m.normals.get(i)) {- sc.ghost_tri(p.to_f32(), n.to_f32(), c.removed);+ sc.ghost_tri(p.to_f32(), n.to_f32(), removed);}}}@@ -1127,8 +1135,14 @@ mod tests {assert!((b.max.z - 18.0).abs() < 1e-6 && (b.max.y - 30.0).abs() < 1e-6, "on top, not at right angles: {b:?}");}- fn count(bytes: &[u8], stride: usize, col: [u8; 4]) -> usize {- bytes.chunks(stride).filter(|v| v.get(24..28) == Some(&col[..])).count()+ fn count(scene: &GpuScene, bytes: &[u8], stride: usize, col: [u8; 4]) -> usize {+ bytes+ .chunks(stride)+ .filter(|v| {+ let Some(i) = v.get(24..28).and_then(|b| b.try_into().ok()).map(u32::from_le_bytes) else { return false };+ scene.palette.get(crate::gpu::PaletteIndex(i)) == Some(col)+ })+ .count()}#[test]@@ -1138,10 +1152,11 @@ mod tests {let p = s.preview(&[("solid.hole".to_string(), json!({"position": [20, 15, 20], "diameter": 5, "depth": 10}))]).unwrap();let b = build(&p.before, &p.after, colors());// The hole's walls are drawn see-through in the cut colour (seen from any side).- assert!(count(&b.scene.xray, 28, colors().removed) > 0);+ assert!(count(&b.scene, &b.scene.xray, 28, colors().removed) > 0);// A feature that only adds material shows no cut.let p = s.preview(&[("solid.box".to_string(), json!({"length": 10, "width": 10, "height": 30, "operation": "join"}))]).unwrap();- assert_eq!(count(&build(&p.before, &p.after, colors()).scene.xray, 28, colors().removed), 0);+ let b = build(&p.before, &p.after, colors());+ assert_eq!(count(&b.scene, &b.scene.xray, 28, colors().removed), 0);}fn plate() -> Session {@@ -1276,8 +1291,8 @@ mod tests {let (rev, undo) = (s.revision, s.undo.len());let b = compute(&s, &[("solid.fillet".into(), json!({"edges": [[0, 0, 10]], "radius": 3}))], colors()).unwrap();assert_eq!(b.replaced, vec!["Body1".to_string()]);- let added = count(&b.scene.tris, crate::gpu::TRI_SIZE, colors().added);- let kept = count(&b.scene.tris, crate::gpu::TRI_SIZE, colors().body);+ let added = count(&b.scene, &b.scene.tris, crate::gpu::TRI_SIZE, colors().added);+ let kept = count(&b.scene, &b.scene.tris, crate::gpu::TRI_SIZE, colors().body);assert!(added > 0 && kept > 0, "added {added} kept {kept}");assert!(!b.scene.ghost.is_empty());assert_eq!(s.revision, rev);@@ -1306,10 +1321,10 @@ mod tests {s.execute("sketch.finish", &json!({})).unwrap();let b = compute(&s, &[("solid.extrude".into(), json!({"distance": "15 mm"}))], colors()).unwrap();assert!(b.replaced.is_empty());- assert_eq!(count(&b.scene.tris, crate::gpu::TRI_SIZE, colors().body), 0);+ assert_eq!(count(&b.scene, &b.scene.tris, crate::gpu::TRI_SIZE, colors().body), 0);// #1805: a new body has its own colour, not a join's.- assert!(count(&b.scene.tris, crate::gpu::TRI_SIZE, colors().new_body) > 0);- assert_eq!(count(&b.scene.tris, crate::gpu::TRI_SIZE, colors().added), 0);+ assert!(count(&b.scene, &b.scene.tris, crate::gpu::TRI_SIZE, colors().new_body) > 0);+ assert_eq!(count(&b.scene, &b.scene.tris, crate::gpu::TRI_SIZE, colors().added), 0);assert!(b.scene.ghost.is_empty());assert!(compute(&s, &[("solid.extrude".into(), json!({"distance": "1 +"}))], colors()).is_err());assert!(s.model.state().bodies.is_empty());@@ -1404,7 +1419,8 @@ mod tests {fn reset_hands_the_viewport_an_empty_scene() {let mut pv = PreviewState::default();let mut sc = GpuScene::default();- sc.xray_tri([0.0; 3], [0.0, 0.0, 1.0], [255; 4]);+ let white = sc.color([255; 4]);+ sc.xray_tri([0.0; 3], [0.0, 0.0, 1.0], white);pv.set_scene(sc);pv.active = true;pv.replaced = vec!["Body1".into()];diff --git a/crates/ui-egui/src/render_workspace.rs b/crates/ui-egui/src/render_workspace.rsindex 5ce821678b..27c796ef8d 100644--- a/crates/ui-egui/src/render_workspace.rs+++ b/crates/ui-egui/src/render_workspace.rs@@ -1511,6 +1511,7 @@ pub fn gpu_scene(scene: &ProductScene) -> Result<(u64, GpuScene), String> {});let [Some(a), Some(b), Some(c)] = vertices else { return Err("invalid product triangle".into()) };let rgba = [color[0], color[1], color[2], (opacity * 255.0).round() as u8];+ let index = gpu.color(rgba);for (p, n) in [a, b, c] {if let Some(surface) = surface {if n.iter().all(|v| *v == 0.0) {@@ -1518,9 +1519,9 @@ pub fn gpu_scene(scene: &ProductScene) -> Result<(u64, GpuScene), String> {}gpu.pbr_tri(p, n, surface);} else if opacity < 0.999 {- gpu.glass_tri(p, n, rgba);+ gpu.glass_tri(p, n, index);} else {- gpu.tri(p, n, rgba);+ gpu.tri(p, n, index);}}}diff --git a/crates/ui-egui/src/render_workspace_tests.rs b/crates/ui-egui/src/render_workspace_tests.rsindex a7fbecc805..965207560f 100644--- a/crates/ui-egui/src/render_workspace_tests.rs+++ b/crates/ui-egui/src/render_workspace_tests.rs@@ -645,7 +645,11 @@ fn product_gpu_buffers_preserve_opacity_and_never_contain_overlays() {let (key, gpu) = gpu_scene(&scene).unwrap();assert!(gpu.tris.is_empty());assert!(!gpu.glass.is_empty());- assert!(gpu.glass.as_chunks::<{ crate::gpu::TRI_SIZE }>().0.iter().all(|v| v[24..] == [51, 102, 153, 102]));+ let color = |v: &[u8]| {+ let i = v.get(crate::gpu::TRI_SIZE - 4..).and_then(|b| b.try_into().ok()).map(u32::from_le_bytes)?;+ gpu.palette.get(crate::gpu::PaletteIndex(i))+ };+ assert!(gpu.glass.as_chunks::<{ crate::gpu::TRI_SIZE }>().0.iter().all(|v| color(v) == Some([51, 102, 153, 102])));assert!(gpu.lines.is_empty() && gpu.overlay.is_empty() && gpu.under.is_empty() && gpu.hidden.is_empty() && gpu.ghost.is_empty());s.selection = vec![solidcraft_engine::Sel::Body { name: "Glass".into() }];s.section = Some((solidcraft_engine::geom::Vec3::ZERO, solidcraft_engine::geom::Vec3::X));diff --git a/crates/ui-egui/src/scale_tests.rs b/crates/ui-egui/src/scale_tests.rsindex 5011719604..ad7598c7db 100644--- a/crates/ui-egui/src/scale_tests.rs+++ b/crates/ui-egui/src/scale_tests.rs@@ -71,6 +71,303 @@ fn frame_and_cheap_command_cost_by_body_count() {}}+/// Times the model scene build after the edits that used to rebuild and upload everything:+/// selection (a revision bump with no model change), an appearance colour and an opacity class+/// change, a theme switch, and one body's geometry edit. Run with `--ignored --nocapture`.+#[test]+#[ignore = "manual palette measurement"]+fn appearance_and_selection_rebuild_cost() {+ let rect = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(800.0, 600.0));+ for n in [200usize, 1000, 5000] {+ let mut h = grid(n);+ h.app.session.world_state().warm_meshes(|| true);+ h.frames(2);+ let body = h.app.session.world_state().bodies[0].name.clone();+ let cold = ms(|| drop(crate::viewport::build_scene(&h.app)));+ let again = ms(|| drop(crate::viewport::build_scene(&h.app)));+ let proj = crate::viewport::projection(&h.app, rect);+ let key = crate::viewport::display_scene_keys(&h.app, &proj).0;+ h.app.run("select.set", json!({"items":[{"type":"body","name":body}]})).unwrap();+ let selection_key_changed = crate::viewport::display_scene_keys(&h.app, &proj).0 != key;+ let selection = ms(|| drop(crate::viewport::build_scene(&h.app)));+ h.app.run("select.clear", json!({})).unwrap();+ h.app.run("appearance.assign", json!({"bodies":[body.clone()],"color":"#336699"})).unwrap();+ let colour = ms(|| drop(crate::viewport::build_scene(&h.app)));+ h.app.run("appearance.assign", json!({"bodies":[body.clone()],"color":"#336699","opacity":0.5})).unwrap();+ let opacity_class = ms(|| drop(crate::viewport::build_scene(&h.app)));+ let theme_name = if crate::theme::is_dark() { "light" } else { "dark" };+ let _ = h.call("ui.prefs", json!({"theme": theme_name}));+ let theme = ms(|| drop(crate::viewport::build_scene(&h.app)));+ let geometry = match h.app.run("solid.move", json!({"bodies":[body.clone()], "translate":[1.0, 0.0, 0.0]})) {+ Ok(_) => ms(|| drop(crate::viewport::build_scene(&h.app))),+ Err(e) => {+ println!("MEASURE n={n} geometry edit refused: {e}");+ f64::NAN+ }+ };+ println!(+ "MEASURE n={n} cold_ms={cold:.1} unchanged_ms={again:.1} selection_ms={selection:.1} selection_rebuilds={selection_key_changed} colour_ms={colour:.1} opacity_class_ms={opacity_class:.1} theme_ms={theme:.1} geometry_ms={geometry:.1}"+ );+ }+}++/// The same edits on a design of few, large meshes: the case where rebuilding a block rebuilt and+/// re-uploaded a large part of the model. Run with `--ignored --nocapture`.+#[test]+#[ignore = "manual palette measurement"]+fn large_body_scene_rebuild_cost() {+ for n in [20usize, 100] {+ let mut h = Harness::new();+ for k in 0..n {+ h.app+ .run("solid.torus", json!({"major": 100, "minor": 10, "center": [k as f64 * 220.0, 0.0, 0.0], "body_name": format!("T{k}")}))+ .unwrap();+ }+ h.app.session.world_state().warm_meshes(|| true);+ h.frames(2);+ let bodies = h.app.session.world_state().bodies.len();+ let triangles: usize = h.app.session.world_state().bodies.iter().map(|b| b.mesh().triangles.len()).sum();+ let body = h.app.session.world_state().bodies[0].name.clone();+ let cold = ms(|| drop(crate::viewport::build_scene(&h.app)));+ h.app.run("appearance.assign", json!({"bodies":[body.clone()],"color":"#336699"})).unwrap();+ let colour = ms(|| drop(crate::viewport::build_scene(&h.app)));+ h.app.run("appearance.assign", json!({"bodies":[body.clone()],"color":"#336699","opacity":0.5})).unwrap();+ let opacity_class = ms(|| drop(crate::viewport::build_scene(&h.app)));+ let theme_name = if crate::theme::is_dark() { "light" } else { "dark" };+ let _ = h.call("ui.prefs", json!({"theme": theme_name}));+ let theme = ms(|| drop(crate::viewport::build_scene(&h.app)));+ println!(+ "LARGE n={n} bodies={bodies} triangles={triangles} cold_ms={cold:.1} colour_ms={colour:.1} opacity_class_ms={opacity_class:.1} theme_ms={theme:.1}"+ );+ }+}++/// An assembly: `unique` detailed parts (a patterned torus, ~8,400 triangles each) and one+/// detailed component placed `placed` times (drawn as instances). Settled, with warm meshes.+fn assembly(unique: usize, placed: usize) -> Harness {+ let mut h = Harness::new();+ let per = |n: usize| (n as f64).sqrt().ceil().max(1.0) as usize;+ h.app.run("solid.torus", json!({"major": 40, "minor": 6, "center": [0, 0, 0], "body_name": "Part"})).unwrap();+ let (c1, c2) = (per(unique), unique.div_ceil(per(unique)));+ h.app+ .run(+ "solid.pattern.rectangular",+ json!({"bodies": ["Part"], "dir1": [1, 0, 0], "count1": c1, "spacing1": 100, "dir2": [0, 1, 0], "count2": c2, "spacing2": 100}),+ )+ .unwrap();+ h.app.run("solid.torus", json!({"major": 40, "minor": 6, "center": [0, 0, -200], "body_name": "Wheel"})).unwrap();+ h.app.run("component.from_bodies", json!({"bodies": ["Wheel"]})).unwrap();+ let (p1, p2) = (per(placed), placed.div_ceil(per(placed)));+ h.app+ .run(+ "solid.pattern.rectangular",+ json!({"components": ["Wheel"], "dir1": [1, 0, 0], "count1": p1, "spacing1": 100, "dir2": [0, 1, 0], "count2": p2, "spacing2": 100}),+ )+ .unwrap();+ h.app.session.world_state().warm_meshes(|| true);+ h.frames(3);+ h+}++/// The edits made on an assembly, timed on the model scene build: selection, a part's colour and+/// opacity, a component's colour (every placement), a theme switch, hiding a part, and moving one+/// part. Run with `--ignored --nocapture`.+#[test]+#[ignore = "manual palette measurement"]+fn assembly_scene_rebuild_cost() {+ let rect = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(800.0, 600.0));+ for (unique, placed) in [(100, 100), (300, 500)] {+ let mut h = assembly(unique, placed);+ let st = h.app.session.world_state();+ let bodies = st.bodies.len();+ let triangles: usize = st.bodies.iter().map(|b| b.mesh().triangles.len()).sum();+ let part = st.bodies.iter().find(|b| b.component == 0).map(|b| b.name.clone()).unwrap();+ drop(st);+ let cold = ms(|| drop(crate::viewport::build_scene(&h.app)));+ let unchanged = ms(|| drop(crate::viewport::build_scene(&h.app)));+ let proj = crate::viewport::projection(&h.app, rect);+ let key = crate::viewport::display_scene_keys(&h.app, &proj).0;+ h.app.run("select.set", json!({"items": [{"type": "body", "name": part}]})).unwrap();+ let selection_rebuilds = crate::viewport::display_scene_keys(&h.app, &proj).0 != key;+ let selection = if selection_rebuilds { ms(|| drop(crate::viewport::build_scene(&h.app))) } else { 0.0 };+ h.app.run("select.clear", json!({})).unwrap();+ // The command itself (the engine's refresh) and then the scene build.+ let colour_command = ms(|| drop(h.app.run("appearance.assign", json!({"bodies": [part.clone()], "color": "#336699"})).unwrap()));+ let colour = ms(|| drop(crate::viewport::build_scene(&h.app)));+ h.app.run("appearance.assign", json!({"bodies": [part.clone()], "color": "#336699", "opacity": 0.5})).unwrap();+ let opacity_class = ms(|| drop(crate::viewport::build_scene(&h.app)));+ h.app.run("appearance.assign", json!({"components": ["Wheel"], "color": "#cc6633"})).unwrap();+ let component_colour = ms(|| drop(crate::viewport::build_scene(&h.app)));+ let theme_name = if crate::theme::is_dark() { "light" } else { "dark" };+ let _ = h.call("ui.prefs", json!({"theme": theme_name}));+ let theme = ms(|| drop(crate::viewport::build_scene(&h.app)));+ h.app.run("browser.visibility", json!({"visible": false, "items": [part.clone()]})).unwrap();+ let hide = ms(|| drop(crate::viewport::build_scene(&h.app)));+ h.app.run("browser.visibility", json!({"visible": true, "items": [part.clone()]})).unwrap();+ let _ = crate::viewport::build_scene(&h.app);+ let geometry = match h.app.run("solid.move", json!({"bodies": [part.clone()], "translate": [1.0, 0.0, 0.0]})) {+ Ok(_) => ms(|| drop(crate::viewport::build_scene(&h.app))),+ Err(_) => f64::NAN,+ };+ println!(+ "ASSEMBLY unique={unique} placed={placed} bodies={bodies} triangles={triangles} cold_ms={cold:.1} unchanged_ms={unchanged:.1} selection_ms={selection:.1} colour_command_ms={colour_command:.1} colour_ms={colour:.1} opacity_class_ms={opacity_class:.1} component_colour_ms={component_colour:.1} theme_ms={theme:.1} hide_ms={hide:.1} geometry_ms={geometry:.1}"+ );+ }+}++/// Hovering the document tree on an assembly: the highlight scene built as the pointer moves+/// from row to row (one part, one placement of the component, the component's every placement,+/// the whole design), then back over rows it has lit before. Run with `--ignored --nocapture`.+#[test]+#[ignore = "manual highlight measurement"]+fn assembly_tree_hover_highlight_cost() {+ for (unique, placed) in [(100, 100), (300, 500)] {+ let mut h = assembly(unique, placed);+ let _ = crate::viewport::build_scene(&h.app);+ let st = h.app.session.world_state();+ let part = st.bodies.iter().find(|b| b.component == 0).map(|b| b.name.clone()).unwrap();+ let wheels: Vec<String> = st.bodies.iter().filter(|b| b.component != 0).map(|b| b.name.clone()).collect();+ let everything: Vec<String> = st.bodies.iter().map(|b| b.name.clone()).collect();+ drop(st);+ let rows = [("part", vec![part.clone()]), ("placement", wheels[..1].to_vec()), ("component", wheels.clone()), ("design", everything.clone())];+ let mut line = format!("HOVER unique={unique} placed={placed}");+ for (name, bodies) in rows.iter() {+ h.app.viewport.hover_bodies = bodies.clone();+ let first = ms(|| drop(crate::viewport::build_highlight(&h.app)));+ line.push_str(&format!(" {name}_ms={first:.2}"));+ }+ // Moving back and forth between two rows, as the pointer runs down the tree.+ let mut again = Vec::new();+ for i in 0..20 {+ h.app.viewport.hover_bodies = if i % 2 == 0 { vec![part.clone()] } else { wheels.clone() };+ again.push(ms(|| drop(crate::viewport::build_highlight(&h.app))));+ }+ again.sort_by(f64::total_cmp);+ line.push_str(&format!(" back_and_forth_median_ms={:.2}", again[again.len() / 2]));+ h.app.viewport.hover_bodies.clear();+ let none = ms(|| drop(crate::viewport::build_highlight(&h.app)));+ line.push_str(&format!(" none_ms={none:.2}"));+ println!("{line}");+ }+}++/// A frame of the viewport for `app`'s camera, drawing the given model and highlight scenes.+#[cfg(not(target_arch = "wasm32"))]+pub(crate) fn view_frame(+ app: &crate::SolveApp,+ size: u32,+ model: (u64, &crate::gpu::SceneSlot),+ highlight: (u64, &crate::gpu::SceneSlot),+) -> crate::gpu::Frame {+ let rect = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(size as f32, size as f32));+ let proj = crate::viewport::projection(app, rect);+ let e = proj.cam.eye().to_f32();+ let t = crate::theme::Tokens::get();+ let none = || std::sync::Arc::new(std::sync::Mutex::new(None));+ crate::gpu::Frame {+ product: false,+ key: model.0,+ slot: model.1.clone(),+ sketch_key: 0,+ sketch_slot: none(),+ hl_key: highlight.0,+ hl_slot: highlight.1.clone(),+ pv_key: 0,+ pv_slot: none(),+ pv_hide: false,+ view_proj: proj.vp.to_f32(),+ back: proj.cam.back().to_f32(),+ size_px: [size as f32; 2],+ clip: [0.0; 4],+ cap: [0.0; 4],+ images: Vec::new(),+ analysis: [0.0; 8],+ analysis_colors: crate::gpu::analysis_colors(&t.analysis),+ access: None,+ outline: false,+ eye: [e[0], e[1], e[2], if proj.cam.fov > 0.0 { 1.0 } else { 0.0 }],+ ao_radius: 0.0,+ ssaa: 1.0,+ hover_tint: [f32::from(t.hover_face_lift) / 255.0; 3],+ selection_tint: [0.4, 0.6, 0.9],+ }+}++/// Time hovering four rows of `h`'s tree (one part, one placement, every placement of the+/// component, the whole design), each hover change building, uploading and drawing the highlight.+#[cfg(not(target_arch = "wasm32"))]+fn hover_rows(h: &mut Harness, frames: &mut crate::gpu::OffscreenFrames, size: u32, model_key: u64, label: &str) -> String {+ let st = h.app.session.world_state();+ let part = st.bodies.iter().find(|b| b.component == 0).map(|b| b.name.clone()).unwrap();+ let wheels: Vec<String> = st.bodies.iter().filter(|b| b.component != 0).map(|b| b.name.clone()).collect();+ let everything: Vec<String> = st.bodies.iter().map(|b| b.name.clone()).collect();+ drop(st);+ let model: crate::gpu::SceneSlot = std::sync::Arc::new(std::sync::Mutex::new(Some(crate::viewport::build_scene(&h.app))));+ let highlight: crate::gpu::SceneSlot = std::sync::Arc::new(std::sync::Mutex::new(None));+ let cold = frames.frame(view_frame(&h.app, size, (model_key, &model), (model_key, &highlight)));+ let mut still = Vec::new();+ for _ in 0..5 {+ still.push(frames.frame(view_frame(&h.app, size, (model_key, &model), (model_key, &highlight))));+ }+ still.sort_by(f64::total_cmp);+ let mut line = format!("{label} cold_ms={cold:.1} still_ms={:.2} triangles={}", still[2], frames.stats().triangles);+ let rows = [("part", vec![part]), ("placement", wheels[..1].to_vec()), ("component", wheels.clone()), ("design", everything)];+ let mut key = model_key;+ for (name, bodies) in rows.iter() {+ let mut times = Vec::new();+ for _ in 0..7 {+ // Off the row and back on: each time a new highlight scene, as a sweep does.+ for hovered in [Vec::new(), bodies.clone()] {+ h.app.viewport.hover_bodies = hovered;+ key += 1;+ let built = std::time::Instant::now();+ *highlight.lock().unwrap() = Some(crate::viewport::build_highlight(&h.app));+ let build_ms = built.elapsed().as_secs_f64() * 1000.0;+ let ms = frames.frame(view_frame(&h.app, size, (model_key, &model), (key, &highlight)));+ if !h.app.viewport.hover_bodies.is_empty() {+ times.push((build_ms + ms, build_ms));+ }+ }+ }+ times.sort_by(|a, b| a.0.total_cmp(&b.0));+ let (total, build) = times[times.len() / 2];+ line.push_str(&format!(" {name}_ms={total:.2} {name}_build_ms={build:.2}"));+ }+ h.app.viewport.hover_bodies.clear();+ line+}++/// Hovering the document tree on an assembly, as the window draws it: each hover change builds+/// the highlight scene, uploads it and draws the frame (GPU work included), on an offscreen+/// renderer with GPU tessellation where the device has it. Then the same with the component+/// active (every other part faded, as when working in context) and with see-through parts.+/// Skipped without a GPU adapter. Run with `--ignored --nocapture`.+#[cfg(not(target_arch = "wasm32"))]+#[test]+#[ignore = "manual highlight measurement"]+fn assembly_tree_hover_frame_cost() {+ const SIZE: u32 = 1024;+ let Some(mut frames) = crate::gpu::OffscreenFrames::new(SIZE, true) else {+ eprintln!("skipping: no GPU adapter");+ return;+ };+ for (design, (unique, placed)) in [(100, 100), (300, 500)].into_iter().enumerate() {+ // Keys of their own for each scene: the renderer keeps a scene while its key comes back.+ let base = 1_000_000 * (3 * design as u64 + 1);+ let mut h = assembly(unique, placed);+ h.app.viewport.gpu = frames.target();+ h.app.fit_view();+ let label = format!("HOVERFRAME unique={unique} placed={placed} tess={}", frames.tessellates());+ println!("{}", hover_rows(&mut h, &mut frames, SIZE, base, &format!("{label} mode=plain")));+ h.app.run("component.activate", json!({"component": "Wheel"})).unwrap();+ println!("{}", hover_rows(&mut h, &mut frames, SIZE, base + 1_000_000, &format!("{label} mode=component_active")));+ h.app.run("component.activate", json!({"component": 0})).unwrap();+ let parts: Vec<String> = h.app.session.world_state().bodies.iter().filter(|b| b.component == 0).map(|b| b.name.clone()).collect();+ h.app.run("appearance.assign", json!({"bodies": parts, "color": "#88aacc", "opacity": 0.5})).unwrap();+ println!("{}", hover_rows(&mut h, &mut frames, SIZE, base + 2_000_000, &format!("{label} mode=glass_parts")));+ }+}+/// A design from a file (`SOLIDCRAFT_SCALE_DESIGN`), every browser folder open: the time of an/// idle frame and of the cheap commands, as [`frame_and_cheap_command_cost_by_body_count`].#[test]@@ -128,7 +425,105 @@ fn whole_body_highlight_cost_from_the_models_own_triangles() {let bodies = names.len();h.app.viewport.hover_bodies = names;let copied = ms(|| drop(crate::viewport::build_highlight(&h.app)));- h.app.viewport.gpu = Some(crate::gpu::GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: true });+ h.app.viewport.gpu =+ Some(crate::gpu::GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: true, oit: false });let planned = ms(|| drop(crate::viewport::build_highlight(&h.app)));println!("HIGHLIGHT bodies={bodies} triangles={triangles} cpu_copy_ms={copied:.2} model_triangles_ms={planned:.2}");}++/// A STEP file (`SOLIDCRAFT_SCALE_STEP`), opened as the app opens one (a new design and+/// `file.insert_step`): the time of each phase of opening it, of an idle frame with its tree, of+/// the model scene and of appearance edits on it, and of hovering its bodies on an offscreen GPU+/// (skipped without an adapter). Run with `--ignored --nocapture`.+#[cfg(not(target_arch = "wasm32"))]+#[test]+#[ignore = "manual measurement on a STEP file"]+fn step_file_cost() {+ let Some(path) = std::env::var_os("SOLIDCRAFT_SCALE_STEP") else { return };+ let mut h = Harness::new();+ let mut line = String::from("STEP");+ let phase = |line: &mut String, name: &str, ms: f64| {+ line.push_str(&format!(" {name}_ms={ms:.1}"));+ eprintln!("{name}: {ms:.1} ms");+ };+ let import = ms(|| drop(h.app.run("file.insert_step", json!({"path": path.to_string_lossy()})).unwrap()));+ phase(&mut line, "import", import);+ let world = ms(|| drop(h.app.session.world_state()));+ phase(&mut line, "world", world);+ let mesh = ms(|| h.app.session.world_state().warm_meshes(|| true));+ phase(&mut line, "mesh", mesh);+ let st = h.app.session.world_state();+ let bodies: Vec<String> = st.bodies.iter().map(|b| b.name.clone()).collect();+ let triangles: usize = st.bodies.iter().map(|b| b.mesh().triangles.len()).sum();+ let components = h.app.session.doc.components.len();+ let occurrences = h.app.session.doc.occurrences.len();+ drop(st);+ line.push_str(&format!(" bodies={} triangles={triangles} components={components} occurrences={occurrences}", bodies.len()));+ let first_frame = ms(|| h.frame());+ phase(&mut line, "first_frame", first_frame);+ let mut idle: Vec<f64> = (0..5).map(|_| ms(|| h.frame())).collect();+ idle.sort_by(f64::total_cmp);+ phase(&mut line, "idle_frame", idle[2]);+ let cold = ms(|| drop(crate::viewport::build_scene(&h.app)));+ phase(&mut line, "scene_cold", cold);+ let unchanged = ms(|| drop(crate::viewport::build_scene(&h.app)));+ phase(&mut line, "scene_unchanged", unchanged);+ let Some(part) = bodies.first().cloned() else {+ println!("{line}");+ return;+ };+ let colour_command = ms(|| drop(h.app.run("appearance.assign", json!({"bodies": [&part], "color": "#336699"})).unwrap()));+ phase(&mut line, "colour_command", colour_command);+ let colour = ms(|| drop(crate::viewport::build_scene(&h.app)));+ phase(&mut line, "colour_scene", colour);+ let opacity_command = ms(|| drop(h.app.run("appearance.assign", json!({"bodies": [&part], "color": "#336699", "opacity": 0.5})).unwrap()));+ phase(&mut line, "opacity_command", opacity_command);+ let opacity = ms(|| drop(crate::viewport::build_scene(&h.app)));+ phase(&mut line, "opacity_scene", opacity);+ let theme_name = if crate::theme::is_dark() { "light" } else { "dark" };+ let _ = h.call("ui.prefs", json!({"theme": theme_name}));+ let theme = ms(|| drop(crate::viewport::build_scene(&h.app)));+ phase(&mut line, "theme_scene", theme);+ let select = ms(|| drop(h.app.run("select.set", json!({"items": [{"type": "body", "name": &part}]})).unwrap()));+ phase(&mut line, "select_command", select);+ let selected_frame = ms(|| h.frame());+ phase(&mut line, "selected_frame", selected_frame);+ let _ = h.app.run("select.clear", json!({}));+ const SIZE: u32 = 1024;+ if let Some(mut frames) = crate::gpu::OffscreenFrames::new(SIZE, true) {+ h.app.viewport.gpu = frames.target();+ h.app.fit_view();+ let model: crate::gpu::SceneSlot = std::sync::Arc::new(std::sync::Mutex::new(Some(crate::viewport::build_scene(&h.app))));+ let highlight: crate::gpu::SceneSlot = std::sync::Arc::new(std::sync::Mutex::new(None));+ let gpu_cold = frames.frame(view_frame(&h.app, SIZE, (1, &model), (1, &highlight)));+ phase(&mut line, "gpu_cold_frame", gpu_cold);+ let mut still: Vec<f64> = (0..5).map(|_| frames.frame(view_frame(&h.app, SIZE, (1, &model), (1, &highlight)))).collect();+ still.sort_by(f64::total_cmp);+ phase(&mut line, "gpu_still_frame", still[2]);+ line.push_str(&format!(" gpu_triangles={}", frames.stats().triangles));+ let tenth = bodies.len().div_ceil(10);+ let mut key = 1;+ for (name, hovered) in [("hover_one", vec![part.clone()]), ("hover_tenth", bodies[..tenth].to_vec()), ("hover_all", bodies.clone())] {+ let mut times = Vec::new();+ for _ in 0..5 {+ for set in [Vec::new(), hovered.clone()] {+ h.app.viewport.hover_bodies = set;+ key += 1;+ let built = std::time::Instant::now();+ *highlight.lock().unwrap() = Some(crate::viewport::build_highlight(&h.app));+ let build = built.elapsed().as_secs_f64() * 1000.0;+ let frame = frames.frame(view_frame(&h.app, SIZE, (1, &model), (key, &highlight)));+ if !h.app.viewport.hover_bodies.is_empty() {+ times.push((build + frame, build));+ }+ }+ }+ times.sort_by(|a, b| a.0.total_cmp(&b.0));+ let (total, build) = times[times.len() / 2];+ phase(&mut line, name, total);+ phase(&mut line, &format!("{name}_build"), build);+ }+ h.app.viewport.hover_bodies.clear();+ }+ println!("{line}");+}diff --git a/crates/ui-egui/src/scene_palette.rs b/crates/ui-egui/src/scene_palette.rsnew file mode 100644index 0000000000..3db6a5e6c4--- /dev/null+++ b/crates/ui-egui/src/scene_palette.rs@@ -0,0 +1,188 @@+//! Stable palette slots for the model scene.+//!+//! Cached block bytes index a scene palette (`solidcraft_gpu::view::Palette`). A body's faces,+//! edges and placement keep their slots while the scene rebuilds, so an appearance or theme edit+//! changes only palette entries — never a block's vertex bytes. Slots are append-only for the+//! session and are reset when a different design replaces the one they belonged to.+//!+//! The model scene needs at most one stable slot per visible body face (plus a few per body), so+//! the arena is capped by [`MAX_PALETTE`]. Past the cap a face falls back to its body's slot:+//! editing such a face once rebuilds that body's block (the build still succeeds).++use std::collections::HashMap;++use crate::gpu::{MAX_PALETTE, PaletteIndex};++/// The stable slots of one body: its own colour, its face range, its edges and its instances.+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub(crate) struct BodySlots {+ /// The body's own colour: the fallback for faces past the allocated range.+ pub body: PaletteIndex,+ /// The first face slot, or [`u32::MAX`] when the arena is full (every face uses `body`).+ pub faces: u32,+ pub face_capacity: u32,+ pub edge: PaletteIndex,+ pub hidden_edge: PaletteIndex,+ pub instance: PaletteIndex,+}++impl BodySlots {+ /// The slot of face `face`, or the body's slot when the face has none.+ pub fn face(&self, face: usize) -> PaletteIndex {+ if self.faces == u32::MAX || face >= self.face_capacity as usize {+ return self.body;+ }+ PaletteIndex(self.faces.saturating_add(face as u32))+ }+}++#[derive(Default)]+pub(crate) struct PaletteArena {+ entries: Vec<[u8; 4]>,+ bodies: HashMap<String, BodySlots>,+ /// Bumped when the arena is reset (a different design); cached blocks must rebuild then.+ generation: u64,+}++impl PaletteArena {+ /// The stable entries, copied into the scene's palette.+ pub fn entries(&self) -> Vec<[u8; 4]> {+ self.entries.clone()+ }++ pub fn generation(&self) -> u64 {+ self.generation+ }++ /// The slots of `name`, allocating them (and `face_count` face slots) the first time.+ pub fn body(&mut self, name: &str, face_count: usize) -> BodySlots {+ if let Some(slots) = self.bodies.get(name).copied() {+ let grown = self.grow_faces(&slots, face_count);+ // Written back only when it grew: most rebuilds find every body as it was.+ if grown != slots+ && let Some(kept) = self.bodies.get_mut(name)+ {+ *kept = grown;+ }+ return grown;+ }+ let body = self.push();+ let edge = self.push();+ let hidden_edge = self.push();+ let instance = self.push();+ let slots = BodySlots { body, faces: u32::MAX, face_capacity: 0, edge, hidden_edge, instance };+ let slots = self.grow_faces(&slots, face_count);+ self.bodies.insert(name.to_string(), slots);+ slots+ }++ /// Extend a body's face range when its face count grew. The range is reused when it is at the+ /// end of the arena; otherwise a new range is appended (the old one is left unused rather+ /// than moving an index cached blocks may refer to).+ fn grow_faces(&mut self, slots: &BodySlots, face_count: usize) -> BodySlots {+ let want = u32::try_from(face_count).unwrap_or(u32::MAX);+ if slots.faces != u32::MAX && slots.face_capacity >= want {+ return *slots;+ }+ let room = MAX_PALETTE.saturating_sub(self.entries.len());+ let need = usize::try_from(want).unwrap_or(usize::MAX).saturating_sub(slots.face_capacity as usize);+ let at_end = slots.faces != u32::MAX && slots.faces as usize + slots.face_capacity as usize == self.entries.len();+ if at_end && need <= room {+ self.entries.resize(self.entries.len() + need, [0; 4]);+ return BodySlots { face_capacity: want, ..*slots };+ }+ if want as usize <= room {+ let base = u32::try_from(self.entries.len()).unwrap_or(u32::MAX);+ self.entries.resize(self.entries.len() + want as usize, [0; 4]);+ return BodySlots { faces: base, face_capacity: want, ..*slots };+ }+ // Out of room: every face falls back to the body's own slot.+ BodySlots { faces: u32::MAX, face_capacity: 0, ..*slots }+ }++ /// Append a zero entry; [`PaletteIndex(0)`] when the arena is full (never a panic).+ fn push(&mut self) -> PaletteIndex {+ if self.entries.len() >= MAX_PALETTE {+ return PaletteIndex(0);+ }+ let i = u32::try_from(self.entries.len()).unwrap_or(0);+ self.entries.push([0; 4]);+ PaletteIndex(i)+ }++ /// The slots of `name`, if it has any (nothing is allocated).+ pub fn slots(&self, name: &str) -> Option<BodySlots> {+ self.bodies.get(name).copied()+ }++ /// The colour at `slot`, if it is allocated.+ pub fn get(&self, slot: PaletteIndex) -> Option<[u8; 4]> {+ self.entries.get(slot.0 as usize).copied()+ }++ /// Set a slot's colour; out-of-range slots are ignored.+ pub fn set(&mut self, slot: PaletteIndex, rgba: [u8; 4]) {+ if let Some(entry) = self.entries.get_mut(slot.0 as usize) {+ *entry = rgba;+ }+ }++ /// Drop every body when the scene belongs to a different design (no body name survives).+ /// A design that removed every body and then adds one keeps its slots (the empty set does+ /// not reset the arena).+ pub fn sync<'a>(&mut self, names: impl IntoIterator<Item = &'a str>) {+ if self.bodies.is_empty() {+ return;+ }+ let mut names = names.into_iter().peekable();+ if names.peek().is_none() {+ return;+ }+ if !names.any(|n| self.bodies.contains_key(n)) {+ self.entries.clear();+ self.bodies.clear();+ self.generation = self.generation.wrapping_add(1);+ }+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn slots_survive_rebuilds_and_faces_fall_back_at_the_cap() {+ let mut arena = PaletteArena::default();+ let first = arena.body("A", 2);+ let again = arena.body("A", 2);+ assert_eq!(first, again);+ assert_ne!(first.face(0), first.face(1));+ assert_eq!(first.face(2), first.body);+ arena.set(first.face(0), [1, 2, 3, 4]);+ assert_eq!(arena.entries()[first.face(0).0 as usize], [1, 2, 3, 4]);+ // A grown face count reuses the range at the end of the arena.+ let grown = arena.body("A", 4);+ assert_eq!(grown.faces, first.faces);+ assert_ne!(grown.face(3), grown.body);+ // A new design with no shared names resets the slots.+ let generation = arena.generation();+ arena.sync(["B"]);+ assert_eq!(arena.generation(), generation.wrapping_add(1));+ assert!(arena.entries().is_empty());+ // An empty scene does not reset.+ let before = arena.generation();+ arena.sync([]);+ assert_eq!(arena.generation(), before);+ }++ #[test]+ fn the_cap_falls_back_to_the_body_slot_without_panicking() {+ // The arena cannot allocate past MAX_PALETTE; simulate a full one by filling entries.+ let mut arena = PaletteArena { entries: vec![[0; 4]; MAX_PALETTE], ..Default::default() };+ let slots = arena.body("Big", 10);+ assert_eq!(slots.faces, u32::MAX);+ assert_eq!(slots.face(3), slots.body);+ // Every push after the cap is index 0, never an out-of-range write.+ assert_eq!(arena.push(), PaletteIndex(0));+ }+}diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rsindex a039fa188e..b176cc1dce 100644--- a/crates/ui-egui/src/viewport.rs+++ b/crates/ui-egui/src/viewport.rs@@ -88,7 +88,12 @@ pub struct ViewportState {mesh_bounds: std::sync::Mutex<MeshBounds>,/// Each shown body mesh's section index for the cut's normal (the mesh held, so its address/// stays its own): a Section Analysis dragged along its normal cuts through it.- section_index: std::sync::Mutex<Vec<(std::sync::Arc<solidcraft_engine::geom::Mesh>, std::sync::Arc<solidcraft_engine::view::SectionIndex>)>>,+ section_index: std::sync::Mutex<+ std::collections::HashMap<+ (usize, [u64; 3]),+ (std::sync::Arc<solidcraft_engine::geom::Mesh>, std::sync::Arc<solidcraft_engine::view::SectionIndex>),+ >,+ >,/// Each body mesh's picking index (made the first time a pick reaches the body), kept while/// the mesh is part of the world state.pub(crate) pick_index: crate::pick_index::PickIndexes,@@ -122,8 +127,13 @@ pub struct ViewportState {/// Browser/timeline body feedback, independent of the camera and reference widget scale.hover_block: std::sync::Mutex<Option<HoverBlock>>,/// Each shown body the model builds on the CPU: the block of the model scene that holds its- /// triangles, and the body's vertex range in it (for whole-body highlights).- body_tris: std::sync::Mutex<std::collections::HashMap<String, (u64, std::ops::Range<u32>)>>,+ /// triangles, and the body's index and vertex ranges in it (for whole-body highlights).+ body_tris: std::sync::Mutex<std::collections::HashMap<String, crate::gpu::BlockTris>>,+ /// The stable palette slots of the model scene (body faces, edges, placements).+ pub(crate) palette: std::sync::Mutex<crate::scene_palette::PaletteArena>,+ /// Each body's resolved look, kept while its geometry and the design's appearance state are+ /// the same: a theme or visibility rebuild does not resolve every face again.+ appearance: std::sync::Mutex<AppearanceCache>,pub nav: Option<NavMode>,/// The preset's navigation for the left-button drag under way (Alias: Shift+Alt), taken/// when the button went down, so the drag neither selects nor moves sketch geometry.@@ -406,10 +416,12 @@ fn in_view(proj: &Proj, b: &solidcraft_engine::geom::Aabb3) -> bool {fn scene_key(app: &SolveApp) -> u64 {let mut h = std::collections::hash_map::DefaultHasher::new();- app.session.revision.hash(&mut h);+ // Not the session revision: selection and view-only commands bump it without changing the+ // model. The document identity catches edits, including appearance-only ones (whose world+ // state may be the same Arc).+ (std::sync::Arc::as_ptr(&app.session.doc) as usize).hash(&mut h);app.session.colored_components.hash(&mut h);(std::sync::Arc::as_ptr(&crate::open_meshing::shown_world(app)) as usize).hash(&mut h);- app.ui.show_grid.hash(&mut h);app.ui.visual_style.hash(&mut h);app.ui.ground_shadow.hash(&mut h);solidcraft_engine::doc::display_quality::current().hash(&mut h);@@ -430,12 +442,21 @@ fn scene_key(app: &SolveApp) -> u64 {app.preview.effective_replaced().hash(&mut h);app.preview.rolled_back.hash(&mut h);app.preferences.cosmetic_threads.hash(&mut h);- app.tree.redefine.hash(&mut h);crate::theme::is_dark().hash(&mut h);crate::theme::vision().hash(&mut h);// Two themes may share a light/dark base while drawing different geometry colours.crate::theme_files::color_key(&Tokens::get()).hash(&mut h);app.session.active_sketch.hash(&mut h);+ // A reset palette arena (another design) invalidates every cached block's indices.+ app.viewport.palette.lock().map_or(0, |a| a.generation()).hash(&mut h);+ // Continuity seams are model-scene lines but are not part of the document or world state.+ for seam in &app.session.continuity {+ seam.body.hash(&mut h);+ seam.edge.hash(&mut h);+ seam.points.len().hash(&mut h);+ format!("{:?}", seam.verdict).hash(&mut h);+ seam.points.first().map(|p| [p.x.to_bits(), p.y.to_bits(), p.z.to_bits()]).hash(&mut h);+ }h.finish()}@@ -444,6 +465,7 @@ fn sketch_scene_key(app: &SolveApp, proj: &Proj) -> u64 {scene_key(app).hash(&mut h);// The grid this scene draws follows the view when the preference says so (#1470): turning it// on or off redraws even while the camera holds still.+ app.ui.show_grid.hash(&mut h);app.preferences.grid_follows_view.hash(&mut h);// Finished sketches are drawn over the bodies when the preference says so.app.preferences.reference_geometry_through_bodies.hash(&mut h);@@ -565,10 +587,7 @@ fn shown_mesh(// Refined: faces drawn from the refined plan on the GPU or built from its mesh here.return mesh;}- let doc = &app.session.doc;- let opaque =- || !body_faded(app, b, active_bodies) && doc.model_body_opacity(b) >= 0.999 && doc.face_colors(b).iter().all(|(_, l)| l.opacity >= 0.999);- (app.viewport.gpu.is_some_and(|g| g.tess) && opaque())+ (app.viewport.gpu.is_some_and(|g| g.tess) && model_plan_class(app, b, active_bodies).is_some()).then(|| drawn_plan(app, b, true)).flatten()// A large body's plan mesh is made on a worker: until then its faces are lit on the@@ -682,14 +701,154 @@ fn update_refinement(app: &mut SolveApp, ctx: &egui::Context, proj: &Proj) {}}+/// A body's look as the scene resolves it: the component/body colours, the body opacity and the+/// faces with looks of their own.+#[derive(Clone)]+struct ResolvedAppearance {+ component: Option<Color32>,+ body: Option<Color32>,+ opacity: f64,+ face_looks: std::collections::HashMap<usize, solidcraft_engine::doc::appearance::Look>,+}++/// [`ViewportState::appearance`]: resolved bodies by name, with their geometry key and the+/// appearance state they were resolved from.+#[derive(Default)]+struct AppearanceCache {+ /// The document the face index below was built from, and whether components coloured bodies.+ doc: Option<(usize, bool)>,+ /// A hash of each body's face appearances, so a body's look is keyed without scanning them.+ faces: std::collections::HashMap<String, u64>,+ /// Each body's appearance key, reused while the document and its geometry are unchanged.+ keys: std::collections::HashMap<String, u64>,+ bodies: std::collections::HashMap<String, (u64, std::sync::Arc<ResolvedAppearance>)>,+ /// Bodies actually resolved (the test asserts an unrelated edit resolves only its body).+ #[cfg(test)]+ resolved: u32,+}++/// A hash per body of the face appearances that name it, in design order (a later assignment+/// wins). Rebuilt when the document changes.+fn face_appearance_hashes(doc: &solidcraft_engine::doc::Document) -> std::collections::HashMap<String, u64> {+ use std::hash::Hasher as _;+ let mut out: std::collections::HashMap<String, u64> = std::collections::HashMap::new();+ for f in &doc.appearances.faces {+ let mut h = std::collections::hash_map::DefaultHasher::new();+ out.get(&f.body).hash(&mut h);+ serde_json::to_string(f).ok().hash(&mut h);+ out.insert(f.body.clone(), h.finish());+ }+ out+}++fn hash_look(look: Option<&solidcraft_engine::doc::appearance::Look>, h: &mut impl std::hash::Hasher) {+ use std::hash::Hash as _;+ match look {+ Some(l) => {+ 1u8.hash(h);+ l.name.hash(h);+ l.color.hash(h);+ l.opacity.to_bits().hash(h);+ match &l.pbr {+ Some(p) => {+ 1u8.hash(h);+ p.metallic().to_bits().hash(h);+ p.roughness().to_bits().hash(h);+ p.dielectric_ior().to_bits().hash(h);+ }+ None => 0u8.hash(h),+ }+ }+ None => 0u8.hash(h),+ }+}++/// What a body's resolved look depends on: its geometry (imported paint), the body/component+/// looks, its material, its face appearances, and component colouring.+fn body_appearance_key(+ doc: &solidcraft_engine::doc::Document,+ b: &solidcraft_engine::doc::ModelBody,+ faces: &std::collections::HashMap<String, u64>,+ colored: bool,+) -> u64 {+ use std::hash::{Hash as _, Hasher as _};+ let mut h = std::collections::hash_map::DefaultHasher::new();+ b.geometry_key().unwrap_or(0).hash(&mut h);+ let name = b.definition_name();+ hash_look(doc.appearances.bodies.get(name), &mut h);+ hash_look(doc.appearances.components.get(&b.component), &mut h);+ doc.materials.get(name).hash(&mut h);+ faces.get(name).copied().unwrap_or(0).hash(&mut h);+ colored.hash(&mut h);+ if colored {+ doc.component_identification_color(b.component).hash(&mut h);+ }+ h.finish()+}++fn resolve_appearance(app: &SolveApp, b: &solidcraft_engine::doc::ModelBody) -> ResolvedAppearance {+ let s = &app.session;+ ResolvedAppearance {+ component: solidcraft_engine::view::component_color(s, b.component).map(|[r, g, b]| Color32::from_rgb(r, g, b)),+ body: body_color(&s.doc, b),+ opacity: s.doc.model_body_opacity(b),+ face_looks: if s.colored_components.is_none() { s.doc.face_colors(b).into_iter().collect() } else { Default::default() },+ }+}++/// How a body whose faces all share one class may be drawn from its plan: opaque on any GPU+/// path; faded or see-through only where the renderer blends them order-independently (the+/// sorted fallback needs the triangles on the CPU). `None`: faces of different classes, which+/// are built on the CPU. `faces` are the classes [`build_scene`] gives the body's faces.+fn plan_class(app: &SolveApp, faces: &[crate::gpu::TriClass]) -> Option<crate::gpu::TriClass> {+ let first = faces.first().copied().unwrap_or(crate::gpu::TriClass::Opaque);+ if faces.iter().any(|c| *c != first) {+ return None;+ }+ (first == crate::gpu::TriClass::Opaque || app.viewport.gpu.is_some_and(|g| g.oit)).then_some(first)+}++/// The classes [`build_scene`] gives `b`'s faces: faded outside the active component, else+/// see-through below full opacity (the body's, or a face's own look).+fn face_classes(app: &SolveApp, b: &solidcraft_engine::doc::ModelBody, active_bodies: &Option<Vec<String>>) -> Vec<crate::gpu::TriClass> {+ if body_faded(app, b, active_bodies) {+ return vec![crate::gpu::TriClass::Faded; b.body.face_count()];+ }+ let resolved = resolve_appearance(app, b);+ (0..b.body.face_count())+ .map(|f| {+ let opacity = resolved.face_looks.get(&f).map_or(resolved.opacity, |l| l.opacity);+ if opacity < 0.999 { crate::gpu::TriClass::Glass } else { crate::gpu::TriClass::Opaque }+ })+ .collect()+}++/// Whether the model scene draws `b` from its plan's GPU-evaluated triangles (and with which+/// class), as [`build_scene`] decides: a live preview stands in for none.+fn model_plan_class(app: &SolveApp, b: &solidcraft_engine::doc::ModelBody, active_bodies: &Option<Vec<String>>) -> Option<crate::gpu::TriClass> {+ if app.preview.effective_replaced().contains(&b.name) {+ return None;+ }+ plan_class(app, &face_classes(app, b, active_bodies))+}+/// A model scene block kept by the viewport: its bytes and the meshes they were built from/// (held, so no other mesh can take their addresses while the block is kept).pub(crate) struct CachedBlock {bytes: std::sync::Arc<crate::gpu::BlockBytes>,meshes: Vec<std::sync::Arc<solidcraft_engine::geom::Mesh>>,- /// Each body's triangles in `bytes.tris`, by body name: whole-body highlights draw those- /// vertices again instead of building a copy of them on the CPU.- ranges: Vec<(String, std::ops::Range<u32>)>,+ /// Each body's share of the block: its vertices, its opaque runs of them (whole-body+ /// highlights draw those again), and the face classes the runs were built from.+ ranges: Vec<BodyRange>,+}++/// One body's share of a block.+struct BodyRange {+ name: String,+ /// Its vertices: three per triangle, in mesh order (none when its faces are drawn elsewhere).+ vertices: std::ops::Range<u32>,+ opaque: Vec<std::ops::Range<u32>>,+ face_classes: Vec<crate::gpu::TriClass>,}/// [`ViewportState::mesh_bounds`]: each box by the shared mesh it was measured on (held, so its@@ -736,7 +895,8 @@ fn taken_shared_tris(mesh: &std::sync::Arc<solidcraft_engine::geom::Mesh>) -> OpSome(warmed.remove(at).1)}-/// One body as the model scene draws it.+/// One body as the model scene draws it. Its geometry lives in a block's canonical vertex+/// buffer; its colours are palette indices, so appearance edits never touch vertex bytes.struct BodyDraw {/// The body's name in the world state, for the highlight's lookup of its triangles.name: String,@@ -744,54 +904,51 @@ struct BodyDraw {mesh: std::sync::Arc<solidcraft_engine::geom::Mesh>,/// The move from `mesh` to where the body stands, for a body drawn as an instance.place: Option<solidcraft_engine::doc::Mat>,- col: [u8; 4],+ /// The palette index of each face's colour, and the body's fallback.+ face_colors: Vec<crate::gpu::PaletteIndex>,+ body_color: crate::gpu::PaletteIndex,+ /// The render class of each face (opaque, glass or faded).+ face_classes: Vec<crate::gpu::TriClass>,faded: bool,- opacity: f64,- face_looks: std::collections::HashMap<usize, solidcraft_engine::doc::appearance::Look>,/// Its faces are drawn elsewhere, from its plan on the GPU or as an instance of shared/// triangles (only its edges are built here).on_gpu: bool,+ /// The body's first face slot: stable while the body exists, so cached block indices are.+ slot_base: u32,+ edge: crate::gpu::PaletteIndex,+ hidden_edge: crate::gpu::PaletteIndex,}impl BodyDraw {- /// Everything [`BodyDraw::build`] reads.- fn key(&self, shaded: bool, edges: bool, hidden_edges: bool, edge_col: [u8; 4], hidden_col: [u8; 4]) -> u64 {+ /// Everything [`BodyDraw::build`] reads. Colours, opacity and classes are deliberately left+ /// out: changing them must not change the block's vertices.+ fn key(&self, shaded: bool, edges: bool, hidden_edges: bool) -> u64 {let mut h = std::collections::hash_map::DefaultHasher::new();(std::sync::Arc::as_ptr(&self.mesh) as usize).hash(&mut h);self.place.iter().flatten().flatten().for_each(|v| v.to_bits().hash(&mut h));- (self.col, self.faded, self.opacity.to_bits(), self.on_gpu, shaded, edges, hidden_edges, edge_col, hidden_col).hash(&mut h);- let mut looks: Vec<_> = self.face_looks.iter().map(|(f, l)| (*f, l.color, l.opacity.to_bits())).collect();- looks.sort_unstable();- looks.hash(&mut h);+ (self.faded, self.on_gpu, shaded, edges, hidden_edges, self.slot_base, self.edge.0, self.hidden_edge.0).hash(&mut h);h.finish()}- fn build(&self, sc: &mut crate::gpu::BlockBytes, shaded: bool, edges: bool, hidden_edges: bool, edge_col: [u8; 4], hidden_col: [u8; 4]) {+ fn build(&self, out: &mut crate::gpu::BlockBuilder, shaded: bool, edges: bool, hidden_edges: bool) {let m = &self.mesh;- let mut out = GpuScene::default();- for (ti, t) in m.triangles.iter().enumerate().filter(|_| shaded && !self.on_gpu) {- let (mut col, a) = match m.tri_face.get(ti).and_then(|f| self.face_looks.get(&(*f as usize))) {- Some(l) => {- let c = Color32::from_rgb(l.color[0], l.color[1], l.color[2]);- (if self.faded { c4(c.gamma_multiply(0.35)) } else { c4(c) }, l.opacity)- }- None => (self.col, self.opacity),+ let color = |ti: usize| m.tri_face.get(ti).and_then(|f| self.face_colors.get(*f as usize)).copied().unwrap_or(self.body_color);+ let class = |ti: usize| {+ if self.faded {+ return crate::gpu::TriClass::Faded;+ }+ m.tri_face.get(ti).and_then(|f| self.face_classes.get(*f as usize)).copied().unwrap_or(crate::gpu::TriClass::Opaque)+ };+ if shaded && !self.on_gpu {+ let corner = |k: u32| {+ let i = k as usize;+ (m.positions.get(i).copied().unwrap_or(Vec3::ZERO).to_f32(), m.normals.get(i).copied().unwrap_or(Vec3::ZERO).to_f32())};- let glass = !self.faded && a < 0.999;- if glass {- col[3] = (a.clamp(0.05, 1.0) * 255.0).round() as u8;- }- for k in t {- let i = *k as usize;- if let (Some(p), Some(n)) = (m.positions.get(i), m.normals.get(i)) {- if self.faded {- out.trans_tri(p.to_f32(), n.to_f32(), col);- } else if glass {- out.glass_tri(p.to_f32(), n.to_f32(), col);- } else {- out.tri(p.to_f32(), n.to_f32(), col);- }- }+ // Exactly three vertices per triangle, in mesh order: a class change regenerates the+ // runs without touching the vertices (see `reindex_block`).+ for (ti, t) in m.triangles.iter().enumerate() {+ let [a, b, c] = t.map(corner);+ out.triangle([a.0, b.0, c.0], [a.1, b.1, c.1], color(ti), class(ti));}}let at = |p: Vec3| self.place.as_ref().map_or(p, |m| solidcraft_engine::doc::apply_point(m, p)).to_f32();@@ -801,17 +958,12 @@ impl BodyDraw {}for w in e.windows(2) {let (a, b) = (at(w[0]), at(w[1]));- out.line(a, b, edge_col, 1.3, false);+ out.line(a, b, self.edge, 1.3);if hidden_edges {- out.hidden_line(a, b, hidden_col, 1.0);+ out.hidden_line(a, b, self.hidden_edge, 1.0);}}}- sc.tris.extend_from_slice(&out.tris);- sc.trans.extend_from_slice(&out.trans);- sc.glass.extend_from_slice(&out.glass);- sc.lines.extend_from_slice(&out.lines);- sc.hidden.extend_from_slice(&out.hidden);}}@@ -823,38 +975,117 @@ fn push_block(made: &mut std::collections::HashMap<u64, CachedBlock>,key: u64,draws: Vec<BodyDraw>,- build: impl Fn(&BodyDraw, &mut crate::gpu::BlockBytes),+ shaded: bool,+ build: impl Fn(&BodyDraw, &mut crate::gpu::BlockBuilder),) {let same = |c: &CachedBlock| c.meshes.len() == draws.len() && c.meshes.iter().zip(&draws).all(|(m, d)| std::sync::Arc::ptr_eq(m, &d.mesh));+ let classes_same = |c: &CachedBlock| c.ranges.len() == draws.len() && c.ranges.iter().zip(&draws).all(|(r, d)| r.face_classes == d.face_classes);let mut block = match kept.remove(&key).or_else(|| made.remove(&key)).filter(same) {- Some(c) => c,- None => {- let mut bytes = crate::gpu::BlockBytes::default();- let mut ranges = Vec::with_capacity(draws.len());- for d in &draws {- let start = u32::try_from(bytes.tris.len() / crate::gpu::TRI_SIZE).unwrap_or(u32::MAX);- build(d, &mut bytes);- let end = u32::try_from(bytes.tris.len() / crate::gpu::TRI_SIZE).unwrap_or(u32::MAX);- ranges.push((d.name.clone(), start..end));- }- CachedBlock { bytes: std::sync::Arc::new(bytes), meshes: draws.iter().map(|d| d.mesh.clone()).collect(), ranges }- }+ Some(c) if classes_same(&c) => c,+ Some(c) => reindex_block(c, &draws),+ None => build_block(&draws, shaded, &build),};// The body names are not part of a block's key (its bytes are the same whatever a body is// called): keep the ranges' names those of the bodies drawn from them this time.if block.ranges.len() == draws.len() {for (range, d) in block.ranges.iter_mut().zip(&draws) {- if range.0 != d.name {- range.0.clone_from(&d.name);+ if range.name != d.name {+ range.name.clone_from(&d.name);}}}- // See-through triangles are sorted with the rest of the glass, every view.- sc.glass.extend_from_slice(&block.bytes.glass);sc.blocks.push(crate::gpu::SceneBlock { key, bytes: block.bytes.clone() });made.insert(key, block);}+/// Write a body's colour into the stable arena and into the scene palette being built from it.+fn set_palette_color(+ arena: &mut crate::scene_palette::PaletteArena,+ palette: &mut std::sync::Arc<crate::gpu::Palette>,+ slot: crate::gpu::PaletteIndex,+ rgba: [u8; 4],+) {+ // The scene palette starts as a copy of the arena's entries: an unchanged slot is already+ // right, and most rebuilds (visibility, LOD, section) change none.+ if arena.get(slot) == Some(rgba) {+ return;+ }+ arena.set(slot, rgba);+ std::sync::Arc::make_mut(palette).set(slot, rgba);+}++fn build_block(draws: &[BodyDraw], shaded: bool, build: &impl Fn(&BodyDraw, &mut crate::gpu::BlockBuilder)) -> CachedBlock {+ let mut builder = crate::gpu::BlockBuilder::default();+ if shaded {+ builder.reserve_triangles(draws.iter().filter(|d| !d.on_gpu).map(|d| d.mesh.triangles.len()).sum());+ }+ let at = |i: usize| u32::try_from(i).unwrap_or(u32::MAX);+ let mut spans = Vec::with_capacity(draws.len());+ for d in draws {+ let v0 = builder.vertices_len();+ build(d, &mut builder);+ spans.push(at(v0)..at(builder.vertices_len()));+ }+ let ranges = draws+ .iter()+ .zip(spans)+ .map(|(d, vertices)| BodyRange {+ name: d.name.clone(),+ opaque: builder.runs_within(crate::gpu::TriClass::Opaque, vertices.clone()),+ vertices,+ face_classes: d.face_classes.clone(),+ })+ .collect();+ CachedBlock { bytes: builder.freeze(), meshes: draws.iter().map(|d| d.mesh.clone()).collect(), ranges }+}++/// Keep a block's vertex, line and hidden artifacts and regenerate only the class runs (an+/// opacity class change). A body's vertices are three per triangle in mesh order, so this reads+/// each triangle's face, not the mesh's geometry.+fn reindex_block(block: CachedBlock, draws: &[BodyDraw]) -> CachedBlock {+ use crate::gpu::TriClass;+ let mut runs: [Vec<std::ops::Range<u32>>; 3] = Default::default();+ for (range, d) in block.ranges.iter().zip(draws) {+ // The triangles this body wrote (none when its faces are drawn from a plan or as an+ // instance), never more than its mesh has.+ let written = ((range.vertices.end.saturating_sub(range.vertices.start)) / 3) as usize;+ for j in 0..written.min(d.mesh.triangles.len()) {+ let class = d.mesh.tri_face.get(j).and_then(|f| d.face_classes.get(*f as usize)).copied().unwrap_or(TriClass::Opaque);+ let slot = match class {+ TriClass::Opaque => 0,+ TriClass::Glass => 1,+ TriClass::Faded => 2,+ };+ let at = range.vertices.start.saturating_add(u32::try_from(j * 3).unwrap_or(u32::MAX));+ if let Some(list) = runs.get_mut(slot) {+ crate::gpu::extend_runs(list, at);+ }+ }+ }+ let [opaque, glass, faded] = runs;+ let ranges = block+ .ranges+ .iter()+ .zip(draws)+ .map(|(range, d)| BodyRange {+ name: d.name.clone(),+ vertices: range.vertices.clone(),+ opaque: crate::gpu::runs_within(&opaque, range.vertices.clone()),+ face_classes: d.face_classes.clone(),+ })+ .collect();+ let old = block.bytes;+ let bytes = std::sync::Arc::new(crate::gpu::BlockBytes {+ vertices: old.vertices.clone(),+ opaque: std::sync::Arc::new(opaque),+ glass: std::sync::Arc::new(glass),+ faded: std::sync::Arc::new(faded),+ lines: old.lines.clone(),+ hidden: old.hidden.clone(),+ });+ CachedBlock { bytes, meshes: draws.iter().map(|d| d.mesh.clone()).collect(), ranges }+}+/// The model scene's instanced meshes: the shared triangles drawn more than once among the shown/// bodies (or large: [`INSTANCE_ALONE`]), and each body placed from them.struct Instances {@@ -862,6 +1093,8 @@ struct Instances {candidates: std::collections::HashMap<String, (std::sync::Arc<solidcraft_engine::geom::Mesh>, solidcraft_engine::doc::Mat)>,/// The meshes drawn as instances, in the order their first placement came, by address.meshes: Vec<(std::sync::Arc<solidcraft_engine::geom::Mesh>, crate::gpu::InstancedMesh)>,+ /// Where a mesh's look already is in `meshes`, so placing a body is a lookup, not a scan.+ by_mesh: std::collections::HashMap<(usize, crate::gpu::InstanceLook), usize>,kept: InstancedTris,lods: crate::mesh_lod::MeshLods,}@@ -883,7 +1116,7 @@ impl Instances {.filter(|(_, (m, _))| m.triangles.len() >= INSTANCE_ALONE || uses.get(&(std::sync::Arc::as_ptr(m) as usize)).is_some_and(|n| *n > 1)).collect();}- Instances { candidates, meshes: Vec::new(), kept, lods: app.viewport.mesh_lods.clone() }+ Instances { candidates, meshes: Vec::new(), by_mesh: std::collections::HashMap::new(), kept, lods: app.viewport.mesh_lods.clone() }}/// Draw `b` as an instance when it is one, in colour `col` (its alpha for a see-through@@ -891,13 +1124,13 @@ impl Instances {fn place(&mut self,b: &solidcraft_engine::doc::ModelBody,- col: [u8; 4],+ col: crate::gpu::PaletteIndex,look: crate::gpu::InstanceLook,) -> Option<(std::sync::Arc<solidcraft_engine::geom::Mesh>, solidcraft_engine::doc::Mat)> {let (mesh, m) = self.candidates.get(&b.name)?.clone();let rows = [0, 1, 2].map(|r| [m[0][r] as f32, m[1][r] as f32, m[2][r] as f32, m[3][r] as f32]);let key = std::sync::Arc::as_ptr(&mesh) as usize;- let at = match self.meshes.iter().position(|(k, i)| std::sync::Arc::ptr_eq(k, &mesh) && i.look == look) {+ let at = match self.by_mesh.get(&(key, look)).copied() {Some(at) => at,None => {// The same triangles (and levels) for each look of a mesh.@@ -914,6 +1147,7 @@ impl Instances {),};self.meshes.push((mesh.clone(), crate::gpu::InstancedMesh { key: key as u64, tris, instances: Vec::new(), look, levels }));+ self.by_mesh.insert((key, look), self.meshes.len() - 1);self.meshes.len() - 1}};@@ -950,7 +1184,6 @@ fn shared_mesh(pub(crate) fn build_scene(app: &SolveApp) -> GpuScene {let tk = Tokens::get();- let mut sc = GpuScene::default();let s = &app.session;// Bodies where their occurrences place them.let st = crate::open_meshing::shown_world(app);@@ -964,53 +1197,107 @@ pub(crate) fn build_scene(app: &SolveApp) -> GpuScene {// Shaded with hidden edges: edges behind the model show faintly.let hidden_edges = app.ui.visual_style == 3;let hidden_col = c4(tk.text.gamma_multiply(0.35));+ let shown: Vec<&solidcraft_engine::doc::ModelBody> =+ st.bodies.iter().filter(|b| app.session.body_visible(&b.name) && !app.preview.effective_replaced().contains(&b.name)).collect();+ let mut arena = app.viewport.palette.lock().unwrap_or_else(|e| e.into_inner());+ let shown_names: Vec<&str> = shown.iter().map(|b| b.name.as_str()).collect();+ arena.sync(shown_names.iter().copied());+ // Allocate every body's slots before the scene's palette is copied, so the stable prefix+ // covers them; the colours themselves are written in the loop below, into both the arena+ // and the scene's palette.+ let slots: Vec<_> = shown.iter().map(|b| arena.body(&b.name, b.body.face_count())).collect();+ let mut sc = GpuScene::with_palette(crate::gpu::Palette::with_stable(arena.entries()));+ // Resolve looks once per body and appearance state: a theme, visibility or LOD rebuild does+ // not scan the whole design's face appearances again.+ let mut appearance = app.viewport.appearance.lock().unwrap_or_else(|e| e.into_inner());+ let doc = std::sync::Arc::as_ptr(&s.doc) as usize;+ let colored = s.colored_components.is_some();+ if appearance.doc != Some((doc, colored)) {+ appearance.doc = Some((doc, colored));+ appearance.faces = face_appearance_hashes(&s.doc);+ // A design or colouring edit can key any body differently; the resolved looks whose+ // key comes back unchanged are still reused.+ appearance.keys.clear();+ }// The blocks the last scene built, reused when their bodies come back as they were.let mut kept = app.viewport.blocks.lock().map(|mut b| std::mem::take(&mut *b)).unwrap_or_default();let mut made: std::collections::HashMap<u64, CachedBlock> = std::collections::HashMap::new();let mut run: Vec<BodyDraw> = Vec::new();let mut run_key = std::collections::hash_map::DefaultHasher::new();- let shown: Vec<&solidcraft_engine::doc::ModelBody> =- st.bodies.iter().filter(|b| app.session.body_visible(&b.name) && !app.preview.effective_replaced().contains(&b.name)).collect();// Bodies drawn from the same triangles more than once (a part placed by many occurrences)// are drawn as instances of them: one copy of the triangles on the GPU, and none moved on// the CPU.let mut instances = Instances::new(app, &shown, shaded);let mut thread_budget = solidcraft_engine::cosmetic_threads::Budget::default();- for b in shown {+ for (b, slots) in shown.into_iter().zip(slots) {let faded = body_faded(app, b, &active_bodies);+ let identity = match appearance.keys.get(&b.name).copied() {+ Some(key) => key,+ None => {+ let key = body_appearance_key(&s.doc, b, &appearance.faces, colored);+ appearance.keys.insert(b.name.clone(), key);+ key+ }+ };+ let resolved = match appearance.bodies.get(&b.name) {+ Some((key, resolved)) if *key == identity => resolved.clone(),+ _ => {+ let resolved = std::sync::Arc::new(resolve_appearance(app, b));+ appearance.bodies.insert(b.name.clone(), (identity, resolved.clone()));+ #[cfg(test)]+ {+ appearance.resolved = appearance.resolved.saturating_add(1);+ }+ resolved+ }+ };+ set_palette_color(&mut arena, &mut sc.palette, slots.edge, edge_col);+ set_palette_color(&mut arena, &mut sc.palette, slots.hidden_edge, hidden_col);if app.preferences.cosmetic_threads&& thread_budget.available()&& shaded&& !faded&& thread_budget.has_thread(&b.name, &st.threads)- && s.doc.model_body_opacity(b) >= 0.999- && s.doc.face_colors(b).iter().all(|(_, l)| l.opacity >= 0.999)+ && resolved.opacity >= 0.999+ && resolved.face_looks.values().all(|l| l.opacity >= 0.999){let mesh = shown_mesh(app, b, &active_bodies);for (a, c) in solidcraft_engine::cosmetic_threads::segments_with_budget(b, &mesh, &st.threads, &mut thread_budget) {- sc.line(a.to_f32(), c.to_f32(), c4(tk.body_edge), 0.85, false);+ sc.line(a.to_f32(), c.to_f32(), slots.edge, 0.85, false);}}- let base = solidcraft_engine::view::component_color(s, b.component)- .map(|[r, g, b]| Color32::from_rgb(r, g, b))- .or_else(|| body_color(&s.doc, b))- .unwrap_or(tk.body);+ let base = resolved.component.or(resolved.body).unwrap_or(tk.body);let col = if faded { c4(base.gamma_multiply(0.35)) } else { c4(base) };+ set_palette_color(&mut arena, &mut sc.palette, slots.body, col);// Appearances: the body's opacity, and faces with looks of their own.- let opacity = s.doc.model_body_opacity(b);- let face_looks: std::collections::HashMap<usize, solidcraft_engine::doc::appearance::Look> =- if shaded && s.colored_components.is_none() { s.doc.face_colors(b).into_iter().collect() } else { Default::default() };- let opaque = !faded && opacity >= 0.999 && face_looks.values().all(|l| l.opacity >= 0.999);- let planned = drawn_plan(app, b, opaque);+ let opacity = resolved.opacity;+ let face_looks = &resolved.face_looks;+ let faces = b.body.face_count();+ let mut face_colors = Vec::with_capacity(faces);+ let mut face_classes = Vec::with_capacity(faces);+ for f in 0..faces {+ let look = face_looks.get(&f);+ let color = look.map_or(base, |l| Color32::from_rgb(l.color[0], l.color[1], l.color[2]));+ let opacity = look.map_or(opacity, |l| l.opacity);+ let (rgba, class) = if faded {+ (c4(color.gamma_multiply(0.35)), crate::gpu::TriClass::Faded)+ } else if opacity < 0.999 {+ let mut rgba = c4(color);+ rgba[3] = (opacity.clamp(0.05, 1.0) * 255.0).round() as u8;+ (rgba, crate::gpu::TriClass::Glass)+ } else {+ (c4(color), crate::gpu::TriClass::Opaque)+ };+ let slot = slots.face(f);+ set_palette_color(&mut arena, &mut sc.palette, slot, rgba);+ face_colors.push(slot);+ face_classes.push(class);+ }+ let class = plan_class(app, &face_classes);+ let planned = class.and_then(|class| drawn_plan(app, b, true).map(|plan| (plan, class)));let on_gpu = planned.is_some();- if let Some(plan) = planned {- let face_colors = (0..b.body.face_count())- .map(|f| match face_looks.get(&f) {- Some(l) => c4(Color32::from_rgb(l.color[0], l.color[1], l.color[2])),- None => col,- })- .collect();- sc.planned.push(crate::gpu::PlannedBody { plan, face_colors });+ if let Some((plan, class)) = planned {+ sc.planned.push(crate::gpu::PlannedBody { plan, face_colors: face_colors.clone(), class });}// Opaque, faded and see-through bodies alike, in one colour (faces of their own colour// are built as before).@@ -1026,13 +1313,38 @@ pub(crate) fn build_scene(app: &SolveApp) -> GpuScene {crate::gpu::InstanceLook::Glass => (opacity.clamp(0.05, 1.0) * 255.0).round() as u8,crate::gpu::InstanceLook::Opaque => 255,};- let instanced = (!on_gpu && face_looks.is_empty()).then(|| instances.place(b, [col[0], col[1], col[2], alpha], look)).flatten();+ set_palette_color(&mut arena, &mut sc.palette, slots.instance, [col[0], col[1], col[2], alpha]);+ let instanced = (!on_gpu && face_looks.is_empty()).then(|| instances.place(b, slots.instance, look)).flatten();let name = b.name.clone();let body = match instanced {- Some((mesh, place)) => BodyDraw { name, mesh, place: Some(place), col, faded, opacity, face_looks, on_gpu: true },- None => BodyDraw { name, mesh: drawn_mesh(app, b), place: None, col, faded, opacity, face_looks, on_gpu },+ Some((mesh, place)) => BodyDraw {+ name,+ mesh,+ place: Some(place),+ face_colors,+ body_color: slots.body,+ face_classes,+ faded,+ on_gpu: true,+ slot_base: slots.faces,+ edge: slots.edge,+ hidden_edge: slots.hidden_edge,+ },+ None => BodyDraw {+ name,+ mesh: drawn_mesh(app, b),+ place: None,+ face_colors,+ body_color: slots.body,+ face_classes,+ faded,+ on_gpu,+ slot_base: slots.faces,+ edge: slots.edge,+ hidden_edge: slots.hidden_edge,+ },};- let key = body.key(shaded, edges, hidden_edges, edge_col, hidden_col);+ let key = body.key(shaded, edges, hidden_edges);key.hash(&mut run_key);run.push(body);// Blocks end where a body's own key says, so a body added or removed changes only its@@ -1040,25 +1352,32 @@ pub(crate) fn build_scene(app: &SolveApp) -> GpuScene {if key.is_multiple_of(16) || run.len() >= 64 {let draws = std::mem::take(&mut run);let block_key = std::mem::replace(&mut run_key, std::collections::hash_map::DefaultHasher::new()).finish();- push_block(&mut sc, &mut kept, &mut made, block_key, draws, |d, out| d.build(out, shaded, edges, hidden_edges, edge_col, hidden_col));+ push_block(&mut sc, &mut kept, &mut made, block_key, draws, shaded, |d, out| d.build(out, shaded, edges, hidden_edges));}}if !run.is_empty() {- push_block(&mut sc, &mut kept, &mut made, run_key.finish(), run, |d, out| d.build(out, shaded, edges, hidden_edges, edge_col, hidden_col));+ push_block(&mut sc, &mut kept, &mut made, run_key.finish(), run, shaded, |d, out| d.build(out, shaded, edges, hidden_edges));}// Where each CPU-built body's triangles are in the model's blocks, for whole-body// highlights (see `highlight_block_tris`).let mut body_tris = std::collections::HashMap::new();for (key, c) in &made {- for (name, tris) in &c.ranges {- if !tris.is_empty() {- body_tris.insert(name.clone(), (*key, tris.clone()));+ for range in &c.ranges {+ if !range.vertices.is_empty() {+ body_tris+ .insert(range.name.clone(), crate::gpu::BlockTris { block: *key, tris: range.opaque.clone(), vertices: range.vertices.clone() });}}}if let Ok(mut m) = app.viewport.body_tris.lock() {*m = body_tris;}+ // Every shown body has its entries, so only a larger map holds bodies no longer shown.+ if appearance.bodies.len() > shown_names.len() || appearance.keys.len() > shown_names.len() {+ let names: std::collections::HashSet<&str> = shown_names.iter().copied().collect();+ appearance.bodies.retain(|name, _| names.contains(name.as_str()));+ appearance.keys.retain(|name, _| names.contains(name.as_str()));+ }if let Ok(mut b) = app.viewport.blocks.lock() {*b = made;}@@ -1068,19 +1387,21 @@ pub(crate) fn build_scene(app: &SolveApp) -> GpuScene {}// Section: the outline of each body where the plane cuts it, in the view's text colour (#4146).if let Some((o, n)) = section_plane(app) {- let col = c4(Tokens::view().text.gamma_multiply(0.9));+ let col = sc.color(c4(Tokens::view().text.gamma_multiply(0.9)));let mut kept = app.viewport.section_index.lock().map(|mut k| std::mem::take(&mut *k)).unwrap_or_default();- let mut made = Vec::new();+ let mut made = std::collections::HashMap::with_capacity(kept.len());+ let normal = [n.x.to_bits(), n.y.to_bits(), n.z.to_bits()];for b in st.bodies.iter().filter(|b| app.session.body_visible(&b.name)) {let mesh = b.mesh();- let index = match kept.iter().position(|(m, i)| std::sync::Arc::ptr_eq(m, &mesh) && i.normal() == n) {- Some(k) => kept.swap_remove(k).1,+ let key = (std::sync::Arc::as_ptr(&mesh) as usize, normal);+ let index = match kept.remove(&key).filter(|(m, i)| std::sync::Arc::ptr_eq(m, &mesh) && i.normal() == n) {+ Some((_, index)) => index,None => std::sync::Arc::new(solidcraft_engine::view::SectionIndex::new(&mesh, n)),};for (a, c) in index.segments(&mesh, o) {sc.line(a.to_f32(), c.to_f32(), col, 1.8, false);}- made.push((mesh, index));+ made.insert(key, (mesh, index));}if let Ok(mut k) = app.viewport.section_index.lock() {*k = made;@@ -1089,7 +1410,7 @@ pub(crate) fn build_scene(app: &SolveApp) -> GpuScene {// Continuity analysis: each seam `inspect.continuity` measured, drawn over the model in the// colour of its worst verdict.for seam in &s.continuity {- let col = c4(continuity_color(&tk, seam.verdict));+ let col = sc.color(c4(continuity_color(&tk, seam.verdict)));for w in seam.points.windows(2) {if let (Some(a), Some(b)) = (w.first(), w.get(1)) {sc.line(a.to_f32(), b.to_f32(), col, 2.6, true);@@ -1172,15 +1493,17 @@ fn build_sketch_scene(app: &SolveApp, proj: &Proj) -> GpuScene {// before its own edge, which is therefore never seen.let fade = GridFade::new(app.cam.half_height(), slant, ext, far_reach);let n = ((fade.end / minor) as i64).clamp(1, 300);+ let (grid, grid_major) = (c4(tk.grid), c4(tk.grid_major));for i in -n..=n {let t = i as f64 * minor;let maj = (t / major).round() * major == t;- let col = if maj { c4(tk.grid_major) } else { c4(tk.grid) };+ let col = if maj { grid_major } else { grid };let wd = if maj { 1.0 } else { 0.7 };// Two lines through the point `c + u * t`: one along v, one along u.for (along, across) in [(v, u), (u, v)] {for (s0, s1, alpha) in fade.pieces(t) {- sc.under_line(w3(c + across * t + along * s0), w3(c + across * t + along * s1), grid_colour(col, alpha), wd);+ let col = sc.color(grid_colour(col, alpha));+ sc.under_line(w3(c + across * t + along * s0), w3(c + across * t + along * s1), col, wd);}}}@@ -1191,11 +1514,12 @@ fn build_sketch_scene(app: &SolveApp, proj: &Proj) -> GpuScene {// Closed profiles are shaded (lifted off a face they may lie on).let lift = ss.plane.normal() * 0.01;let profiles = if app.session.visibility.hidden_profiles.contains(&sid) || ss.sketch.view.hide_profile { &[][..] } else { &ss.profiles[..] };+ let profile_fill = sc.color(c4(tk.profile_fill));for (index, _) in profiles.iter().enumerate() {let display = crate::sketch_display::profile_region(app, sid, index, &ss.plane, proj);for tri in display.as_ref().as_ref().map_or_else(Vec::new, |region| crate::sketch_display::fill_triangles(region, &mut fill_budget)) {for q in tri {- sc.trans_tri((ss.plane.to_world(q) + lift).to_f32(), [0.0; 3], c4(tk.profile_fill));+ sc.trans_tri((ss.plane.to_world(q) + lift).to_f32(), [0.0; 3], profile_fill);}}}@@ -1220,12 +1544,12 @@ fn build_sketch_scene(app: &SolveApp, proj: &Proj) -> GpuScene {unit,);let haloed = app.preferences.sketch_halo && !active && col != colors::SKETCH_PROJECTED && col != colors::SKETCH_LOST;- strokes.push((segs, sketch_color(&tk, col), if cons { 1.2 } else { 2.0 }, haloed));+ strokes.push((segs, sc.color(sketch_color(&tk, col)), if cons { 1.2 } else { 2.0 }, haloed));}// Active sketches retain their existing through-body display. Inactive sketches// can opt into the same behaviour in Preferences.let through = active || app.preferences.reference_geometry_through_bodies;- let halo = c4(tk.sketch_halo);+ let halo = sc.color(c4(tk.sketch_halo));for (segs, _, width, _) in strokes.iter().filter(|stroke| stroke.3) {for (a, b) in segs {sc.line(a.to_f32(), b.to_f32(), halo, width + SKETCH_HALO_WIDTH, through);@@ -1238,9 +1562,10 @@ fn build_sketch_scene(app: &SolveApp, proj: &Proj) -> GpuScene {}}let guide_unit = grid_step(app.cam.half_height()).0;+ let warning = sc.color(c4(tk.warning));for points in crate::sketch_attachment_ui::display_guide_lines(app, proj) {for (a, b) in dashes(&points, &[guide_unit * 0.25, guide_unit * 0.15]) {- sc.line(a.to_f32(), b.to_f32(), c4(tk.warning), 1.5, true);+ sc.line(a.to_f32(), b.to_f32(), warning, 1.5, true);}}sc@@ -1283,7 +1608,7 @@ fn ground_shadow(sc: &mut GpuScene, app: &SolveApp, st: &std::sync::Arc<solidcra};for w in rings.windows(2) {let ((r0, a0), (r1, a1)) = (w[0], w[1]);- let (c0, c1) = ([0, 0, 0, a0 as u8], [0, 0, 0, a1 as u8]);+ let (c0, c1) = (sc.color([0, 0, 0, a0 as u8]), sc.color([0, 0, 0, a1 as u8]));for k in 0..n {let (p00, p01, p10, p11) = (at(r0, k), at(r0, k + 1), at(r1, k), at(r1, k + 1));sc.shadow_tri(p00, c0);@@ -2467,6 +2792,7 @@ fn face_tris(sc: &mut GpuScene, m: &solidcraft_engine::geom::Mesh, face: usize,/// Emit a set of faces in one mesh pass. Whole-body feedback must not scan every triangle/// again for each face of a detailed imported part.fn mesh_tris(sc: &mut GpuScene, m: &solidcraft_engine::geom::Mesh, col: [u8; 4], lit: bool, takes: impl Fn(u32) -> bool) {+ let col = sc.color(col);for (t, f) in m.triangles.iter().zip(&m.tri_face) {if !takes(*f) {continue;@@ -2487,13 +2813,15 @@ const SKETCH_HALO_WIDTH: f32 = 2.0;/// pick on the far side still shows).fn edge_lines(sc: &mut GpuScene, e: &[Vec3], core: Color32, halo: Color32, w: f32, normals: &[[[f32; 3]; 2]]) {for (col, width) in [(halo, w + 3.0), (core, w)] {+ let col = sc.color(c4(col));for (i, p) in e.windows(2).enumerate() {let n = normals.get(i).copied().unwrap_or_default();- sc.lifted_line(p[0].to_f32(), p[1].to_f32(), c4(col), width, n);+ sc.lifted_line(p[0].to_f32(), p[1].to_f32(), col, width, n);}}+ let hidden = sc.color(c4(core.gamma_multiply(0.45)));for p in e.windows(2) {- sc.hidden_line(p[0].to_f32(), p[1].to_f32(), c4(core.gamma_multiply(0.45)), (w * 0.7).max(1.0));+ sc.hidden_line(p[0].to_f32(), p[1].to_f32(), hidden, (w * 0.7).max(1.0));}}@@ -2527,11 +2855,12 @@ fn edge_normals(m: &solidcraft_engine::geom::Mesh, e: &[Vec3]) -> Vec<[[f32; 3];/// The outline of a highlighted face where the model hides it (dimmed).fn hidden_face_outline(sc: &mut GpuScene, m: &solidcraft_engine::geom::Mesh, face: usize, col: Color32) {+ let col = sc.color(c4(col.gamma_multiply(0.45)));for (ei, e) in m.edges.iter().enumerate() {let on = m.edge_faces.get(ei).is_some_and(|f| f.iter().any(|x| *x as usize == face));if on && m.edge_pickable(ei) {for p in e.windows(2) {- sc.hidden_line(p[0].to_f32(), p[1].to_f32(), c4(col.gamma_multiply(0.45)), 1.4);+ sc.hidden_line(p[0].to_f32(), p[1].to_f32(), col, 1.4);}}}@@ -2549,7 +2878,8 @@ pub(crate) fn profile_fill(sc: &mut GpuScene, app: &SolveApp, sketch: u64, index// Lift toward the eye so a profile on a face shows over it.let lift = app.cam.back() * (app.cam.half_height() * 0.002);let w = |q: solidcraft_engine::geom::Vec2| (plane.to_world(q) + lift).to_f32();- let col = c4(fill);+ let col = sc.color(c4(fill));+ let edge = sc.color(c4(edge));// In the translucent pass (after the grid and edges) so it covers them.let proj = display_proj(app);let display = crate::sketch_display::profile_region(app, sketch, index, &plane, &proj);@@ -2561,7 +2891,7 @@ pub(crate) fn profile_fill(sc: &mut GpuScene, app: &SolveApp, sketch: u64, indexfor lp in std::iter::once(&p.region.outer).chain(&p.region.holes) {for part in crate::sketch_display::boundary_parts(lp, &plane, &proj, app.viewport.pixels_per_point()) {for pair in part.windows(2) {- sc.line((pair[0] + lift).to_f32(), (pair[1] + lift).to_f32(), c4(edge), 2.0, false);+ sc.line((pair[0] + lift).to_f32(), (pair[1] + lift).to_f32(), edge, 2.0, false);}}}@@ -2572,7 +2902,7 @@ pub(crate) fn profile_fill(sc: &mut GpuScene, app: &SolveApp, sketch: u64, index/// a body stays visible and pickable; or the Preferences setting to show reference geometry/// through bodies), else it is depth-tested like the rest of the scene.fn quad(sc: &mut GpuScene, q: &[Vec3; 4], fill: Color32, edge: Color32, through: bool) {- let col = c4(fill);+ let col = sc.color(c4(fill));for i in [0, 1, 2, 0, 2, 3] {if let Some(p) = q.get(i) {if through {@@ -2591,6 +2921,7 @@ fn quad(sc: &mut GpuScene, q: &[Vec3; 4], fill: Color32, edge: Color32, through:/// A reference line (plane edge, axis): over the model when `through` (as [`quad`]), else depth-tested and/// left whole by a section.fn reference_line(sc: &mut GpuScene, a: [f32; 3], b: [f32; 3], col: [u8; 4], width: f32, through: bool) {+ let col = sc.color(col);if through {sc.line(a, b, col, width, true);} else {@@ -2671,6 +3002,8 @@ struct HoverBlock {key: u64,state: std::sync::Arc<solidcraft_engine::doc::ModelState>,doc: std::sync::Arc<solidcraft_engine::doc::Document>,+ /// The colours the block's palette indices refer to.+ palette: std::sync::Arc<crate::gpu::Palette>,block: crate::gpu::SceneBlock,/// Whole bodies the model draws from their plans: reused like the block when the camera/// moves (they are the model's own evaluated triangles, not a copy of them).@@ -2683,6 +3016,8 @@ struct HoverBlock {/// highlight colour.hover_instanced: Vec<crate::gpu::InstancedMesh>,selected_instanced: Vec<crate::gpu::InstancedMesh>,+ /// Faded or see-through bodies in the model's blocks, drawn again in this palette.+ recoloured: Vec<crate::gpu::BlockTris>,}/// The plan the model draws a whole highlighted body from, when it draws one on the GPU. The@@ -2694,7 +3029,7 @@ fn highlight_plan(b: &solidcraft_engine::doc::ModelBody,active_bodies: &Option<Vec<String>>,) -> Option<std::sync::Arc<solidcraft_engine::geom::tess::TessPlan>> {- drawn_plan(app, b, highlight_opaque(app, b, active_bodies))+ drawn_plan(app, b, model_plan_class(app, b, active_bodies).is_some())}/// Whether the model draws a whole body opaque on the GPU, rather than building it on the CPU:@@ -2722,9 +3057,11 @@ struct HighlightInstances {impl HighlightInstances {/// Add the body at `color`, when the model draws it as an instanced placement of an opaque/// shared mesh; `false` when it does not (the caller builds its feedback on the CPU).- fn add(&mut self, app: &SolveApp, b: &solidcraft_engine::doc::ModelBody, active_bodies: &Option<Vec<String>>, color: [u8; 4]) -> bool {- // A body with face appearances of its own is built on the CPU, never as an instance.- if !highlight_opaque(app, b, active_bodies) || !app.session.doc.face_colors(b).is_empty() {+ fn add(&mut self, app: &SolveApp, b: &solidcraft_engine::doc::ModelBody, color: crate::gpu::PaletteIndex) -> bool {+ // A live preview stands in for the body; a body with face appearances of its own is built+ // on the CPU, never as an instance. A faded or see-through placement is lit like an opaque+ // one: the highlight colour is the placement's own here, not the model's.+ if app.preview.effective_replaced().contains(&b.name) || !app.session.doc.face_colors(b).is_empty() {return false;}let Some((mesh, m)) = shared_mesh(app, b) else { return false };@@ -2778,15 +3115,75 @@ fn highlight_block_tris(app: &SolveApp, b: &solidcraft_engine::doc::ModelBody) -return None;}let map = app.viewport.body_tris.lock().ok()?;- let (block, tris) = map.get(&b.name)?;- Some(crate::gpu::BlockTris { block: *block, tris: tris.clone() })+ map.get(&b.name).cloned()+}++/// How a whole body is lit: hovered or selected, and in which colour (where the model's own+/// colour is not kept: placements, and faded or see-through bodies).+#[derive(Clone, Copy)]+struct WholeBody {+ selected: bool,+ colour: [u8; 4],+}++/// Light the whole of `b` from what the model already has on the GPU, copying no triangle: its+/// plan or its opaque runs (tinted over the model's own colours), its block's vertices recoloured+/// in the highlight's palette (faded and see-through bodies), or its placements. `false` when+/// none applies (wireframe, a live preview standing in for the body): the caller copies it.+fn light_whole_body(+ app: &SolveApp,+ b: &solidcraft_engine::doc::ModelBody,+ active_bodies: &Option<Vec<String>>,+ lit: WholeBody,+ body_slots: &crate::scene_palette::PaletteArena,+ feedback: &mut GpuScene,+ instances: &mut HighlightInstances,+) -> bool {+ if let Some(plan) = highlight_plan(app, b, active_bodies) {+ if lit.selected {+ feedback.selected_planned.push(plan)+ } else {+ feedback.hover_planned.push(plan)+ }+ return true;+ }+ let opaque = highlight_opaque(app, b, active_bodies);+ if let Some(tris) = highlight_block_tris(app, b) {+ if opaque && !tris.tris.is_empty() {+ if lit.selected {+ feedback.selected_blocks.push(tris)+ } else {+ feedback.hover_blocks.push(tris)+ }+ return true;+ }+ // Faded or see-through: the body's every vertex again, its slots in this palette holding+ // the highlight colour (as the copy it replaces was drawn).+ if !opaque && let Some(slots) = body_slots.slots(&b.name) {+ let palette = std::sync::Arc::make_mut(&mut feedback.palette);+ palette.set(slots.body, lit.colour);+ for f in 0..b.body.face_count() {+ palette.set(slots.face(f), lit.colour);+ }+ feedback.recoloured.push(tris);+ return true;+ }+ }+ let colour = feedback.color(lit.colour);+ instances.add(app, b, colour)}/// The highlight scene: origin widget, construction planes, selection and hover.pub(crate) fn build_highlight(app: &SolveApp) -> GpuScene {let began = crate::now_ms();let t = Tokens::get();- let mut sc = GpuScene::default();+ // The model scene's stable palette slots first: whole faded or see-through bodies are drawn+ // again from the model's own vertices in this palette, their slots set to the highlight's+ // colour (see `light_whole_body`); this scene's own colours follow.+ // The key first: it reads the arena (`scene_key`), which is held below.+ let key = highlight_geometry_key(app);+ let body_slots = app.viewport.palette.lock().unwrap_or_else(|e| e.into_inner());+ let mut sc = GpuScene::with_palette(crate::gpu::Palette::with_stable(body_slots.entries()));let st = crate::open_meshing::shown_world(app);let s = &app.session;let active_bodies = s.active_occurrence_path.as_ref().and_then(|p| s.occurrence_bodies(p, true).ok());@@ -2857,7 +3254,7 @@ pub(crate) fn build_highlight(app: &SolveApp) -> GpuScene {for (name, p) in construction_points(app) {let on = sel.iter().any(|x| matches!(x, Sel::ConstructionPoint { name: n } if *n == name))|| matches!(hover, Some(Hit::ConstructionPoint { name: n }) if *n == name);- let col = c4(if on { t.sel_edge } else { t.construction_geom });+ let col = sc.color(c4(if on { t.sel_edge } else { t.construction_geom }));let r = size * 0.04;for d in [Vec3::X, Vec3::Y, Vec3::Z] {sc.line((p - d * r).to_f32(), (p + d * r).to_f32(), col, 2.0, true);@@ -2867,41 +3264,43 @@ pub(crate) fn build_highlight(app: &SolveApp) -> GpuScene {// circle in a point input its centre, as construction geometry. The axis runs through the// solid it belongs to, so it is drawn over the model.let (round_axes, round_centres) = round_pick_feedback(app);+ let construction = sc.color(c4(t.construction_geom));for (a, b) in round_axes {let len = a.dist(b);let dash = size * 0.08;let mut s = 0.0;while s < len {let e = (s + dash).min(len);- sc.line(a.lerp(b, s / len).to_f32(), a.lerp(b, e / len).to_f32(), c4(t.construction_geom), 2.0, true);+ sc.line(a.lerp(b, s / len).to_f32(), a.lerp(b, e / len).to_f32(), construction, 2.0, true);s += dash * 1.6;}}for p in round_centres {let r = size * 0.04;for d in [Vec3::X, Vec3::Y, Vec3::Z] {- sc.line((p - d * r).to_f32(), (p + d * r).to_f32(), c4(t.construction_geom), 2.0, true);+ sc.line((p - d * r).to_f32(), (p + d * r).to_f32(), construction, 2.0, true);}}// Reference widgets follow zoom; the often much larger world-space feedback does not.let projected = sel.iter().any(|s| matches!(s, Sel::Profile { .. } | Sel::SketchCurve { .. } | Sel::ExternalSketchCurve { .. }))|| matches!(hover, Some(Hit::Profile { .. }));- let key = highlight_geometry_key(app);if !projected&& let Some(cached) = app.viewport.hover_block.lock().ok().and_then(|cache| {cache.as_ref().filter(|c| c.key == key && std::sync::Arc::ptr_eq(&c.state, &st) && std::sync::Arc::ptr_eq(&c.doc, &s.doc)).cloned()}){+ sc.palette = cached.palette;sc.blocks.push(cached.block);sc.hover_planned = cached.hover_planned;sc.selected_planned = cached.selected_planned;sc.hover_blocks = cached.hover_blocks;sc.selected_blocks = cached.selected_blocks;+ sc.recoloured = cached.recoloured;sc.hover_instanced = cached.hover_instanced;sc.selected_instanced = cached.selected_instanced;return sc;}- let mut feedback = GpuScene::default();+ let mut feedback = GpuScene { palette: std::sync::Arc::new((*sc.palette).clone()), ..Default::default() };let mut hover_instances = HighlightInstances::default();let mut selected_instances = HighlightInstances::default();// Selected things.@@ -2918,11 +3317,8 @@ pub(crate) fn build_highlight(app: &SolveApp) -> GpuScene {if let Some(b) = st.body(name)&& app.session.body_visible(name){- if let Some(plan) = highlight_plan(app, b, &active_bodies) {- feedback.selected_planned.push(plan);- } else if let Some(tris) = highlight_block_tris(app, b) {- feedback.selected_blocks.push(tris);- } else if !selected_instances.add(app, b, &active_bodies, c4(t.body_selected)) {+ let lit = WholeBody { selected: true, colour: c4(t.body_selected) };+ if !light_whole_body(app, b, &active_bodies, lit, &body_slots, &mut feedback, &mut selected_instances) {let m = shown(b);let count = b.body.face_count();mesh_tris(&mut feedback, &m, c4(t.body_selected), true, |f| (f as usize) < count);@@ -2942,29 +3338,31 @@ pub(crate) fn build_highlight(app: &SolveApp) -> GpuScene {Sel::Profile { sketch, index } => profile_fill(&mut feedback, app, *sketch, *index, t.sel_profile, t.sel_profile_edge),// A 3D sketch curve, in the sketch it names, or whichever sketch has it.Sel::SketchCurve { id, sketch } if st.sketches.iter().any(|ss| ss.sketch.wire_index(id).is_some()) => {+ let sel_edge = feedback.color(c4(t.sel_edge));for ss in st.sketches.iter().filter(|ss| sketch.is_none_or(|k| ss.feature == k)) {if let Some(w) = ss.sketch.wire_index(id).and_then(|i| ss.sketch.wires.get(i)) {for q in w.pts.windows(2) {- feedback.line(q[0].to_f32(), q[1].to_f32(), c4(t.sel_edge), 3.5, true);+ feedback.line(q[0].to_f32(), q[1].to_f32(), sel_edge, 3.5, true);}}}}// A curve picked into a dialog from another sketch than the active one names it.Sel::ExternalSketchCurve { sketch, id } | Sel::SketchCurve { id, sketch: Some(sketch) } => {+ let sel_edge = feedback.color(c4(t.sel_edge));if let Some(ss) = st.sketch(*sketch)&& let Some(ci) = ss.sketch.curve_index(id){for pts in &crate::sketch_display::curve_sample(app, *sketch, ci, &ss.plane, &display_proj(app)).parts {let mode = ss.sketch.curves.get(ci).map_or(0, |c| if c.centerline { 2 } else { u8::from(c.construction) });for (a, b) in sketch_segments(pts, mode, grid_step(app.cam.half_height()).0) {- feedback.line(a.to_f32(), b.to_f32(), c4(t.sel_edge), 3.5, true);+ feedback.line(a.to_f32(), b.to_f32(), sel_edge, 3.5, true);}}} else if let Some(w) = st.sketch(*sketch).and_then(|ss| ss.sketch.wire_index(id).and_then(|i| ss.sketch.wires.get(i))) {// A 3D sketch curve of that sketch.for q in w.pts.windows(2) {- feedback.line(q[0].to_f32(), q[1].to_f32(), c4(t.sel_edge), 3.5, true);+ feedback.line(q[0].to_f32(), q[1].to_f32(), sel_edge, 3.5, true);}}}@@ -2972,10 +3370,11 @@ pub(crate) fn build_highlight(app: &SolveApp) -> GpuScene {if let Some(ss) = app.session.active_sketch.and_then(|sid| st.sketch(sid))&& let Some(ci) = ss.sketch.curve_index(id){+ let sel_edge = feedback.color(c4(t.sel_edge));for pts in &crate::sketch_display::curve_sample(app, ss.feature, ci, &ss.plane, &display_proj(app)).parts {let mode = ss.sketch.curves.get(ci).map_or(0, |c| if c.centerline { 2 } else { u8::from(c.construction) });for (a, b) in sketch_segments(pts, mode, grid_step(app.cam.half_height()).0) {- feedback.line(a.to_f32(), b.to_f32(), c4(t.sel_edge), 3.5, true);+ feedback.line(a.to_f32(), b.to_f32(), sel_edge, 3.5, true);}}}@@ -3019,12 +3418,9 @@ pub(crate) fn build_highlight(app: &SolveApp) -> GpuScene {if !selected_body {// A whole body the model draws from a plan is lit by redrawing the plan's own// evaluated triangles, not by building every triangle again (see `highlight_plan`).- if whole && let Some(plan) = highlight_plan(app, b, &active_bodies) {- feedback.hover_planned.push(plan);- } else if whole && let Some(tris) = highlight_block_tris(app, b) {- feedback.hover_blocks.push(tris);- } else if whole && hover_instances.add(app, b, &active_bodies, hover_col) {- // Its placements carry the highlight colour.+ let lit = WholeBody { selected: false, colour: hover_col };+ if whole && light_whole_body(app, b, &active_bodies, lit, &body_slots, &mut feedback, &mut hover_instances) {+ // Drawn again from what the model already has on the GPU.} else {let lit = shown(b);let selected_faces = selected_faces.get(b.name.as_str());@@ -3050,11 +3446,8 @@ pub(crate) fn build_highlight(app: &SolveApp) -> GpuScene {let k = t.hover_face_lift;let c = body_color(&s.doc, b).unwrap_or(t.body);let hover_col = [c.r().saturating_add(k), c.g().saturating_add(k), c.b().saturating_add(k), 255];- if let Some(plan) = highlight_plan(app, b, &active_bodies) {- feedback.hover_planned.push(plan);- } else if let Some(tris) = highlight_block_tris(app, b) {- feedback.hover_blocks.push(tris);- } else if !hover_instances.add(app, b, &active_bodies, hover_col) {+ let lit = WholeBody { selected: false, colour: hover_col };+ if !light_whole_body(app, b, &active_bodies, lit, &body_slots, &mut feedback, &mut hover_instances) {let m = shown(b);let count = b.body.face_count();mesh_tris(&mut feedback, &m, hover_col, true, |f| (f as usize) < count);@@ -3104,6 +3497,9 @@ pub(crate) fn build_highlight(app: &SolveApp) -> GpuScene {}feedback.hover_instanced = hover_instances.finish();feedback.selected_instanced = selected_instances.finish();+ // The feedback palette extends the scene's own: set it before sharing the geometry, and keep+ // the indices valid on the cache hit above.+ sc.palette = feedback.palette.clone();if projected {sc.tris.append(&mut feedback.tris);sc.trans.append(&mut feedback.trans);@@ -3114,26 +3510,34 @@ pub(crate) fn build_highlight(app: &SolveApp) -> GpuScene {sc.selected_planned.append(&mut feedback.selected_planned);sc.hover_blocks.append(&mut feedback.hover_blocks);sc.selected_blocks.append(&mut feedback.selected_blocks);+ sc.recoloured.append(&mut feedback.recoloured);sc.hover_instanced.append(&mut feedback.hover_instanced);sc.selected_instanced.append(&mut feedback.selected_instanced);} else {+ // The feedback triangles become a block's canonical vertices, in one opaque list.+ let vertices = std::mem::take(&mut feedback.tris);+ let count = u32::try_from(vertices.len() / crate::gpu::TRI_SIZE).unwrap_or(0);let block = crate::gpu::SceneBlock {key,bytes: std::sync::Arc::new(crate::gpu::BlockBytes {- tris: feedback.tris,- lines: feedback.lines,- hidden: feedback.hidden,+ vertices: std::sync::Arc::new(vertices),+ opaque: std::sync::Arc::new(std::iter::once(0..count).filter(|r| !r.is_empty()).collect()),+ lines: std::sync::Arc::new(std::mem::take(&mut feedback.lines)),+ hidden: std::sync::Arc::new(std::mem::take(&mut feedback.hidden)),..Default::default()}),};+ let palette = feedback.palette.clone();let (hover_planned, selected_planned) = (feedback.hover_planned, feedback.selected_planned);let (hover_blocks, selected_blocks) = (feedback.hover_blocks, feedback.selected_blocks);let (hover_instanced, selected_instanced) = (feedback.hover_instanced, feedback.selected_instanced);+ let recoloured = feedback.recoloured;if let Ok(mut cache) = app.viewport.hover_block.lock() {*cache = Some(HoverBlock {key,state: st.clone(),doc: s.doc.clone(),+ palette,block: block.clone(),hover_planned: hover_planned.clone(),selected_planned: selected_planned.clone(),@@ -3141,6 +3545,7 @@ pub(crate) fn build_highlight(app: &SolveApp) -> GpuScene {selected_blocks: selected_blocks.clone(),hover_instanced: hover_instanced.clone(),selected_instanced: selected_instanced.clone(),+ recoloured: recoloured.clone(),});}sc.blocks.push(block);@@ -3150,11 +3555,12 @@ pub(crate) fn build_highlight(app: &SolveApp) -> GpuScene {sc.selected_blocks = selected_blocks;sc.hover_instanced = hover_instanced;sc.selected_instanced = selected_instanced;+ sc.recoloured = recoloured;}if solidcraft_engine::geom::env::var_os("PROFILE_FRAMES").is_some() {let in_blocks = |f: fn(&crate::gpu::SceneBlock) -> usize| sc.blocks.iter().map(f).sum::<usize>();- let tris = sc.tris.len() + in_blocks(|b| b.bytes.tris.len());+ let tris = sc.tris.len() + in_blocks(|b| b.bytes.vertices.len());let lines = sc.lines.len() + in_blocks(|b| b.bytes.lines.len());let hidden = sc.hidden.len() + in_blocks(|b| b.bytes.hidden.len());eprintln!(@@ -5269,7 +5675,11 @@ mod tests {ground_shadow(&mut scene, &app, &app.session.world_state());assert!(scene.trans.is_empty(), "the ground shadow must not trigger order-independent transparency");assert_eq!(scene.shadow.len(), 48 * 5 * 3 * crate::gpu::TRI_SIZE, "all shadow rings are retained");- assert!(scene.shadow.as_chunks::<{ crate::gpu::TRI_SIZE }>().0.iter().any(|v| v.get(27).is_some_and(|a| *a > 0)));+ let shadow_alpha = |v: &[u8]| {+ let i = u32::from_le_bytes(v.get(24..28)?.try_into().ok()?);+ scene.palette.get(crate::gpu::PaletteIndex(i)).map(|c| c[3])+ };+ assert!(scene.shadow.as_chunks::<{ crate::gpu::TRI_SIZE }>().0.iter().any(|v| shadow_alpha(v).is_some_and(|a| a > 0)));Ok(())}@@ -5411,7 +5821,7 @@ mod tests {.find_map(|(lies, n)| lies.then_some(n))};for tess in [false, true] {- app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess });+ app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess, oit: false });let proj = projection(&app, rect);let e = proj.cam.eye().to_f32();let eye = [e[0], e[1], e[2], if proj.cam.fov > 0.0 { 1.0 } else { 0.0 }];@@ -5477,7 +5887,16 @@ mod tests {let app = SolveApp::new(s, crate::Services::default());let sc = build_scene(&app);// An overlay line is two points, a colour and a width: 32 bytes.- let colours: Vec<[u8; 4]> = sc.overlay.as_chunks::<32>().0.iter().map(|r| [r[24], r[25], r[26], r[27]]).collect();+ let colours: Vec<[u8; 4]> = sc+ .overlay+ .as_chunks::<32>()+ .0+ .iter()+ .filter_map(|r| {+ let i = u32::from_le_bytes(r.get(24..28)?.try_into().ok()?);+ sc.palette.get(crate::gpu::PaletteIndex(i))+ })+ .collect();let t = Tokens::get();let count = |c: Color32| colours.iter().filter(|x| **x == c4(c)).count();let [smooth, jump, sharp, gap] = t.continuity.map(count);@@ -5498,7 +5917,7 @@ mod tests {const SIZE: u32 = 256;let rect = Rect::from_min_size(Pos2::ZERO, vec2(SIZE as f32, SIZE as f32));let mut render = |tess: bool| {- app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess });+ app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess, oit: false });let scene = build_scene(&app).merged();let proj = projection(&app, rect);let e = proj.cam.eye().to_f32();@@ -5557,7 +5976,7 @@ mod tests {s.run_script(&solidcraft_engine::sample::script()).unwrap();let mut app = SolveApp::new(s, crate::Services::default());app.fit_view();- app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess });+ app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess, oit: false });const SIZE: u32 = 256;let rect = Rect::from_min_size(Pos2::ZERO, vec2(SIZE as f32, SIZE as f32));let scene = build_scene(&app).merged();@@ -5595,7 +6014,7 @@ mod tests {s.run_script(&solidcraft_engine::sample::script()).unwrap();let mut app = SolveApp::new(s, crate::Services::default());app.fit_view();- app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: false });+ app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: false, oit: false });const SIZE: u32 = 256;let rect = Rect::from_min_size(Pos2::ZERO, vec2(SIZE as f32, SIZE as f32));let proj = projection(&app, rect);@@ -5658,7 +6077,7 @@ mod tests {app.ui.show_grid = false;app.set_origin_shown(false);app.ui.ground_shadow = false;- app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: false });+ app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: false, oit: false });const SIZE: u32 = 512;const RADIUS: f32 = 45.0;let rect = Rect::from_min_size(Pos2::ZERO, vec2(SIZE as f32, SIZE as f32));@@ -5701,6 +6120,77 @@ mod tests {assert!(step < 0.005, "no copies of the block's outline: a step of {step:.4} between neighbouring columns");}+ /// Faded and see-through bodies are drawn from their plans where the renderer blends them+ /// order-independently, and look as they did built on the CPU: a see-through box beside a+ /// part faded outside the active component, drawn both ways. Without order-independent+ /// transparency they stay on the CPU (the sorted fallback needs their triangles). Skipped+ /// without a GPU adapter.+ #[cfg(not(target_arch = "wasm32"))]+ #[test]+ fn faded_and_see_through_bodies_are_drawn_from_their_plans_with_oit() {+ let mut s = solidcraft_engine::Session::default();+ let part = s.execute("component.create", &json!({"name": "Part"})).unwrap()["component"].as_u64().unwrap();+ s.execute("solid.box", &json!({"length": 30, "width": 30, "height": 30, "corner": [0, 0, 0], "operation": "new", "body_name": "Glass"}))+ .unwrap();+ s.execute("appearance.assign", &json!({"bodies": ["Glass"], "color": "#3366cc", "opacity": 0.5})).unwrap();+ s.execute("solid.box", &json!({"length": 20, "width": 20, "height": 20, "corner": [40, 0, 0], "operation": "new", "body_name": "Inside"}))+ .unwrap();+ s.execute("component.activate", &json!({"component": 0})).unwrap();+ s.execute("solid.box", &json!({"length": 20, "width": 20, "height": 20, "corner": [0, 40, 0], "operation": "new", "body_name": "Faded"}))+ .unwrap();+ s.execute("component.activate", &json!({"component": part})).unwrap();+ let mut app = SolveApp::new(s, crate::Services::default());+ app.ui.ground_shadow = false;+ app.fit_view();+ const SIZE: u32 = 192;+ let rect = Rect::from_min_size(Pos2::ZERO, vec2(SIZE as f32, SIZE as f32));+ let target =+ |tess: bool, oit: bool| Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess, oit });+ let classes = |scene: &GpuScene| {+ let mut c: Vec<_> = scene.planned.iter().map(|b| format!("{:?}", b.class)).collect();+ c.sort();+ c+ };+ app.viewport.gpu = target(true, false);+ assert_eq!(classes(&build_scene(&app)), ["Opaque"], "without OIT only the opaque body is drawn from its plan");+ app.viewport.gpu = target(true, true);+ let planned = build_scene(&app);+ assert_eq!(classes(&planned), ["Faded", "Glass", "Opaque"], "with OIT every body is");+ let built: usize = planned.blocks.iter().map(|b| b.bytes.vertices.len()).sum();+ assert_eq!(built, 0, "and none is built on the CPU");+ // Hovered, a faded body drawn from its plan lights through the plan's triangles.+ let faded = app.session.world_state().bodies.iter().find(|b| b.name.starts_with("Faded")).map(|b| b.name.clone()).unwrap();+ app.viewport.hover_bodies = vec![faded];+ assert_eq!(build_highlight(&app).hover_planned.len(), 1, "the faded body's plan is lit");+ app.viewport.hover_bodies.clear();+ app.viewport.gpu = target(false, false);+ let cpu = build_scene(&app);+ let render = |scene: GpuScene, tess: bool| {+ let proj = projection(&app, rect);+ let e = proj.cam.eye().to_f32();+ let eye = [e[0], e[1], e[2], if proj.cam.fov > 0.0 { 1.0 } else { 0.0 }];+ crate::gpu::render_offscreen(+ scene,+ None,+ proj.vp.to_f32(),+ proj.cam.back().to_f32(),+ eye,+ SIZE,+ tess.then_some(solidcraft_gpu::SHADER),+ [0.0; 8],+ crate::gpu::analysis_colors(&Tokens::get().analysis),+ )+ };+ let (Some(from_plans), Some(from_cpu)) = (render(planned, true), render(cpu, false)) else {+ eprintln!("skipping: no GPU adapter");+ return;+ };+ let differ = from_plans.chunks(4).zip(from_cpu.chunks(4)).filter(|(a, b)| a.iter().zip(*b).any(|(x, y)| x.abs_diff(*y) > 6)).count();+ let shown = from_cpu.chunks(4).filter(|p| p[..3] != from_cpu[..3]).count();+ assert!(shown > 2000, "the bodies are in view ({shown} px)");+ assert!(differ * 100 < shown, "{differ} of {shown} px differ between the plan and CPU pictures");+ }+/// A hovered face lights solidly over a body drawn from its display plan on the GPU: the/// highlight uses the plan's triangles, not the reference mesh's other triangulation of the/// same face, which fought the model at equal depth and shimmered in wedges. Every face of a@@ -5720,7 +6210,7 @@ mod tests {let body = app.session.world_state().bodies[0].clone();let faces = body.body.face_count();let mut render = |tess: bool, hover: Option<usize>| {- app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess });+ app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess, oit: false });app.viewport.hover = hover.map(|index| Hit::Face { body: body.name.clone(), index, point: Vec3::ZERO });let (scene, highlight) = (build_scene(&app), build_highlight(&app).merged());assert_eq!(!scene.planned.is_empty(), tess, "the box is drawn from its plan exactly on the GPU path");@@ -5798,6 +6288,53 @@ mod tests {if saved { format!("pictures in {}", dir.display()) } else { format!("the pictures could not be saved in {}", dir.display()) }}+ /// The highlight scene as the viewport hands it over keeps its feedback (a hovered face, a+ /// body copied on the CPU) in a block of its own, kept while the highlight is unchanged. That+ /// block is drawn: the picture is the same as with the feedback merged into the scene's own+ /// triangles. Skipped without a GPU adapter.+ #[cfg(not(target_arch = "wasm32"))]+ #[test]+ fn the_highlight_scenes_own_block_is_drawn() {+ let mut s = solidcraft_engine::Session::default();+ s.execute("solid.box", &json!({"length": 40, "width": 30, "height": 20, "corner": [0, 0, 0], "operation": "new"})).unwrap();+ let mut app = SolveApp::new(s, crate::Services::default());+ app.fit_view();+ const SIZE: u32 = 128;+ let rect = Rect::from_min_size(Pos2::ZERO, vec2(SIZE as f32, SIZE as f32));+ let body = app.session.world_state().bodies[0].clone();+ let proj = projection(&app, rect);+ let e = proj.cam.eye().to_f32();+ let eye = [e[0], e[1], e[2], if proj.cam.fov > 0.0 { 1.0 } else { 0.0 }];+ let model = build_scene(&app);+ let render = |highlight: GpuScene| {+ crate::gpu::render_offscreen(+ model.clone(),+ Some(highlight),+ proj.vp.to_f32(),+ proj.cam.back().to_f32(),+ eye,+ SIZE,+ None,+ [0.0; 8],+ crate::gpu::analysis_colors(&Tokens::get().analysis),+ )+ };+ let Some(plain) = render(GpuScene::default()) else {+ eprintln!("skipping: no GPU adapter");+ return;+ };+ let mut lit = 0;+ for index in 0..body.body.face_count() {+ app.viewport.hover = Some(Hit::Face { body: body.name.clone(), index, point: Vec3::ZERO });+ let highlight = build_highlight(&app);+ assert!(highlight.blocks.iter().any(|b| !b.bytes.vertices.is_empty()), "the face's feedback is in the highlight's block");+ let (Some(as_handed), Some(merged)) = (render(highlight.clone()), render(highlight.merged())) else { return };+ assert!(as_handed == merged, "face {index}: the highlight's block is not drawn as its merged triangles are");+ lit += usize::from(as_handed != plain);+ }+ assert!(lit >= 3, "{lit} faces light up");+ }+/// An origin plane lying on a body's face is tinted evenly over it (#1739: a box built at the/// origin, seen from below in orthographic; the XY plane's square z-fought with the bottom/// face in stripes). Faces are pushed back by their slope (`FACE_BIAS`), the planes are not.@@ -5822,7 +6359,8 @@ mod tests {let rect = Rect::from_min_size(Pos2::ZERO, vec2(SIZE as f32, SIZE as f32));let mut render = |origin: bool| {app.set_origin_shown(origin);- app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: false });+ app.viewport.gpu =+ Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: false, oit: false });let (scene, highlight) = (build_scene(&app), build_highlight(&app).merged());let proj = projection(&app, rect);let e = proj.cam.eye().to_f32();@@ -6010,7 +6548,17 @@ mod tests {h.app.run("inspect.section", json!({"plane": "XZ", "at": 15})).unwrap();h.call("ui.prefs", json!({"theme": "dark", "viewport_theme": "light"}));h.frames(2);- let colours: Vec<[u8; 4]> = build_scene(&h.app).lines.as_chunks::<32>().0.iter().map(|l| [l[24], l[25], l[26], l[27]]).collect();+ let scene = build_scene(&h.app);+ let colours: Vec<[u8; 4]> = scene+ .lines+ .as_chunks::<32>()+ .0+ .iter()+ .filter_map(|l| {+ let i = u32::from_le_bytes(l.get(24..28)?.try_into().ok()?);+ scene.palette.get(crate::gpu::PaletteIndex(i))+ })+ .collect();let (view, window) = (Tokens::light().text.gamma_multiply(0.9), Tokens::dark().text.gamma_multiply(0.9));assert!(colours.contains(&c4(view)), "the outlines in the view's text colour");assert!(!colours.contains(&c4(window)), "none in the window's");@@ -6174,7 +6722,7 @@ mod tests {let mut app = SolveApp::new(solidcraft_engine::Session::default(), crate::Services::default());app.ui.ground_shadow = false;app.set_origin_shown(false);- app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: false });+ app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: false, oit: false });app.run("component.create", json!({"name":"Part"})).unwrap();app.run(command, serde_json::from_str(params).unwrap()).unwrap();app.run("occurrence.copy", json!({"component":"Part","translate":[40,0,0]})).unwrap();@@ -6208,7 +6756,7 @@ mod tests {let corners = shared.indices.len();let vertices = shared.vertices.len() / crate::gpu::SHARED_SIZE;assert!(vertices * 2 < corners, "{part:?}: {vertices} vertices shared by {corners} corners");- assert!(scene.blocks.iter().all(|b| b.bytes.tris.is_empty()), "no body's triangles built where it stands");+ assert!(scene.blocks.iter().all(|b| b.bytes.vertices.is_empty()), "no body's triangles built where it stands");let moved = st.bodies.iter().filter(|b| b.cached_mesh().is_some()).count();assert!(moved <= 1, "{moved} bodies made a moved mesh to be drawn");let merged = scene.merged();@@ -6342,7 +6890,7 @@ mod tests {let (w, h, samples) = (3600u32 / scale, 2190u32 / scale, 4u32);let depth = solidcraft_gpu::depth_format(&device, true);let format = wgpu::TextureFormat::Rgba8Unorm;- app.viewport.gpu = Some(GpuTarget { format, depth: Some(depth), samples, tess: false });+ app.viewport.gpu = Some(GpuTarget { format, depth: Some(depth), samples, tess: false, oit: false });app.fit_view();let texture = |format, samples| {device@@ -6419,7 +6967,7 @@ mod tests {return;}for (label, scene) in [("own triangles", scene.clone().merged()), ("instanced", scene), ("instanced, levels of detail", lod)] {- let mut renderer = crate::gpu::Renderer::new(&device, GpuTarget { format, depth: Some(depth), samples, tess: false }, None);+ let mut renderer = crate::gpu::Renderer::new(&device, GpuTarget { format, depth: Some(depth), samples, tess: false, oit: false }, None);let slot: SceneSlot = std::sync::Arc::new(std::sync::Mutex::new(Some(scene)));let none = || std::sync::Arc::new(std::sync::Mutex::new(None));let (mut times, mut prepared) = (Vec::new(), Vec::new());@@ -6521,7 +7069,7 @@ mod tests {}];doc.add_feature(FeatureKind::MeshImport { file: "grid.stl".into(), meshes }, Some("Grid")).unwrap();let mut app = SolveApp::new(solidcraft_engine::Session::new(doc), crate::Services::default());- app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: false });+ app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: false, oit: false });let (mesh, _) = app.session.world_state().bodies[0].mesh_in_place();assert!(mesh.triangles.len() >= INSTANCE_ALONE);warm_shared_tris(&mesh);@@ -6558,7 +7106,7 @@ mod tests {let mut app = SolveApp::new(solidcraft_engine::Session::new(doc), crate::Services::default());app.ui.ground_shadow = false;app.set_origin_shown(false);- app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: false });+ app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: false, oit: false });app}@@ -6632,7 +7180,11 @@ mod tests {let glass = build_scene(&app);assert_eq!(glass.instanced.len(), 1);assert_eq!((glass.instanced[0].look, glass.instanced[0].count()), (InstanceLook::Glass, 3));- assert!(glass.instanced[0].instances.as_chunks::<{ crate::gpu::INSTANCE_SIZE }>().0.iter().all(|p| p[51] == 102), "alpha 0.4");+ let alpha = |p: &[u8]| {+ let i = u32::from_le_bytes(p.get(48..52)?.try_into().ok()?);+ glass.palette.get(crate::gpu::PaletteIndex(i)).map(|c| c[3])+ };+ assert!(glass.instanced[0].instances.as_chunks::<{ crate::gpu::INSTANCE_SIZE }>().0.iter().all(|p| alpha(p) == Some(102)), "alpha 0.4");assert!(glass.glass.is_empty(), "no triangle sorted one by one");assert!(!glass.clone().merged().glass.is_empty());// One placement active (as right after the part is made): the others faded.@@ -6874,7 +7426,8 @@ mod tests {let mut app = SolveApp::new(s, crate::Services::default());if gpu {// The callback is queued by egui; no device is needed to inspect scene updates.- app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: false });+ app.viewport.gpu =+ Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: false, oit: false });}app}@@ -7432,7 +7985,8 @@ mod tests {let mut app = SolveApp::new(s, crate::Services::default());app.set_origin_shown(false);if gpu {- app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: false });+ app.viewport.gpu =+ Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: false, oit: false });}app.cam.target = Vec3::new(20.0, 15.0, 10.0);hover_frame(&mut app, &ctx, vec![]);@@ -7517,7 +8071,7 @@ mod tests {};for tess in [true, false] {let mut app = cylinder_app();- app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess });+ app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess, oit: false });let body = app.session.world_state().bodies[0].clone();let before = build_scene(&app).merged();let key = scene_key(&app);@@ -7617,7 +8171,7 @@ mod tests {app.viewport.hover_bodies = vec!["Body1".into()];let before = build_highlight(&app);let bytes = before.blocks[0].bytes.clone();- assert!(!bytes.tris.is_empty());+ assert!(!bytes.vertices.is_empty());app.cam.zoom_at(4.0, None);let after = build_highlight(&app);assert!(std::sync::Arc::ptr_eq(&bytes, &after.blocks[0].bytes), "zoom must not regenerate or upload body feedback");@@ -7625,10 +8179,10 @@ mod tests {app.session.visibility.hidden_bodies.push("Body1".into());let hidden = build_highlight(&app);assert!(!std::sync::Arc::ptr_eq(&bytes, &hidden.blocks[0].bytes));- assert!(hidden.blocks[0].bytes.tris.is_empty(), "hidden bodies must lose their feedback");+ assert!(hidden.blocks[0].bytes.vertices.is_empty(), "hidden bodies must lose their feedback");app.session.visibility.hidden_bodies.clear();let shown = build_highlight(&app);- assert_eq!(shown.blocks[0].bytes.tris, bytes.tris);+ assert_eq!(shown.blocks[0].bytes.vertices, bytes.vertices);}#[test]@@ -7652,7 +8206,7 @@ mod tests {#[test]fn whole_body_highlights_reuse_the_models_own_triangles() {let mut app = cylinder_app();- app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: true });+ app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: true, oit: false });let body = app.session.world_state().bodies[0].clone();let plan = body.display_plan().expect("the test body is drawn from a plan");app.viewport.hover_bodies = vec![body.name.clone()];@@ -7660,13 +8214,13 @@ mod tests {assert_eq!(hovered.hover_planned.len(), 1, "the whole hovered body is lit from its plan");assert!(std::sync::Arc::ptr_eq(&hovered.hover_planned[0], &plan));assert_eq!(hovered.tris.len(), 0);- assert!(hovered.blocks.iter().all(|b| b.bytes.tris.is_empty()), "no copy of the body's triangles");+ assert!(hovered.blocks.iter().all(|b| b.bytes.vertices.is_empty()), "no copy of the body's triangles");app.viewport.hover_bodies.clear();app.session.selection = vec![Sel::Body { name: body.name.clone() }];let selected = build_highlight(&app);assert_eq!(selected.selected_planned.len(), 1, "a selected whole body is lit from its plan too");assert_eq!(selected.tris.len(), 0);- assert!(selected.blocks.iter().all(|b| b.bytes.tris.is_empty()));+ assert!(selected.blocks.iter().all(|b| b.bytes.vertices.is_empty()));// A body the model builds on the CPU (here: no GPU plans) is lit from its own vertices// in the model scene's blocks.app.session.selection.clear();@@ -7678,7 +8232,7 @@ mod tests {assert!(built.hover_planned.is_empty());assert_eq!(built.hover_blocks.len(), 1, "a CPU-built body is lit from the model's block");assert_eq!(built.tris.len(), 0);- assert!(built.blocks.iter().all(|b| b.bytes.tris.is_empty()), "no copy of the body's triangles");+ assert!(built.blocks.iter().all(|b| b.bytes.vertices.is_empty()), "no copy of the body's triangles");// Two occurrences of one component are drawn as placements of its shared triangles: the// highlight draws those placements again, in its colour.let mut s = solidcraft_engine::Session::default();@@ -7696,15 +8250,91 @@ mod tests {assert_eq!(instanced.hover_instanced.len(), 1, "the part's one shared mesh");assert_eq!(instanced.hover_instanced[0].count(), 2, "both of its placements");assert_eq!(instanced.tris.len(), 0);- assert!(instanced.blocks.iter().all(|b| b.bytes.tris.is_empty()), "no copy of the placements");- // A see-through body is not in the block's opaque triangles: its feedback is built here.+ assert!(instanced.blocks.iter().all(|b| b.bytes.vertices.is_empty()), "no copy of the placements");+ // A see-through body is not in the block's opaque runs: its own vertices in the block are+ // drawn again, recoloured in the highlight's palette, and still no triangle is copied.app.viewport.hover_bodies.clear();app.run("appearance.assign", json!({"bodies": [body.name.clone()], "color": [200, 200, 200], "opacity": 0.5})).unwrap();build_scene(&app);app.viewport.hover_bodies = vec![body.name.clone()];let see_through = build_highlight(&app);assert!(see_through.hover_planned.is_empty(), "a see-through body is not drawn from a plan");- assert!(!see_through.merged().tris.is_empty(), "its highlight is still lit");+ assert_eq!(see_through.recoloured.len(), 1, "it is lit from the model's own vertices");+ assert!(!see_through.recoloured[0].vertices.is_empty());+ assert!(see_through.blocks.iter().all(|b| b.bytes.vertices.is_empty()), "no copy of its triangles");+ }++ /// A whole faded or see-through body lit from the model's own vertices, recoloured in the+ /// highlight's palette, looks exactly as the copy of its triangles it replaces did: hovered,+ /// and selected. Skipped without a GPU adapter.+ #[cfg(not(target_arch = "wasm32"))]+ #[test]+ fn faded_and_see_through_bodies_light_as_their_copies_did() {+ const SIZE: u32 = 128;+ let mut s = solidcraft_engine::Session::default();+ s.execute("solid.box", &json!({"length": 30, "width": 20, "height": 10, "corner": [0, 0, 0], "body_name": "Plate"})).unwrap();+ s.execute("solid.cylinder", &json!({"base": [45, 10, 0], "diameter": 12, "height": 25, "body_name": "Post"})).unwrap();+ s.execute("component.from_bodies", &json!({"bodies": ["Post"]})).unwrap();+ let mut app = SolveApp::new(s, crate::Services::default());+ app.fit_view();+ let rect = Rect::from_min_size(Pos2::ZERO, vec2(SIZE as f32, SIZE as f32));+ let proj = projection(&app, rect);+ let e = proj.cam.eye().to_f32();+ let eye = [e[0], e[1], e[2], if proj.cam.fov > 0.0 { 1.0 } else { 0.0 }];+ let render = |model: GpuScene, highlight: GpuScene| {+ crate::gpu::render_offscreen(+ model,+ Some(highlight),+ proj.vp.to_f32(),+ proj.cam.back().to_f32(),+ eye,+ SIZE,+ None,+ [0.0; 8],+ crate::gpu::analysis_colors(&Tokens::get().analysis),+ )+ };+ for case in ["see-through", "faded"] {+ match case {+ "see-through" => drop(app.run("appearance.assign", json!({"bodies": ["Plate"], "color": "#88aacc", "opacity": 0.4})).unwrap()),+ _ => {+ app.run("appearance.assign", json!({"bodies": ["Plate"]})).unwrap();+ app.run("component.activate", json!({"component": "Post"})).unwrap();+ }+ }+ for selected in [false, true] {+ app.viewport.hover_bodies = if selected { Vec::new() } else { vec!["Plate".into()] };+ app.session.selection = if selected { vec![Sel::Body { name: "Plate".into() }] } else { Vec::new() };+ let model = build_scene(&app);+ let highlight = build_highlight(&app);+ assert_eq!(highlight.recoloured.len(), 1, "{case}: the plate is lit from the model's vertices");+ let highlight_handed = highlight.clone();+ // The copy it replaces: every triangle, lit, in the colour the copy was drawn in.+ let t = Tokens::get();+ let colour = if selected {+ c4(t.body_selected)+ } else {+ let c = body_color(&app.session.doc, &app_body(&app, "Plate")).unwrap_or(t.body);+ let k = t.hover_face_lift;+ [c.r().saturating_add(k), c.g().saturating_add(k), c.b().saturating_add(k), 255]+ };+ // The same highlight (its edges and widgets), the plate copied instead of recoloured.+ let mut copy = highlight.clone().merged();+ copy.recoloured.clear();+ let mesh = drawn_mesh(&app, &app_body(&app, "Plate"));+ mesh_tris(&mut copy, &mesh, colour, true, |_| true);+ let (Some(lit), Some(copied)) = (render(model.clone(), highlight_handed), render(model, copy)) else {+ eprintln!("skipping: no GPU adapter");+ return;+ };+ assert!(lit == copied, "{case}, selected {selected}: the recoloured body does not look as its copy did");+ }+ app.session.selection.clear();+ }+ }++ fn app_body(app: &SolveApp, name: &str) -> solidcraft_engine::doc::ModelBody {+ app.session.world_state().body(name).cloned().unwrap()}#[test]@@ -9111,7 +9741,7 @@ mod tests {let mut app = SolveApp::new(s, crate::Services::default());app.fit_view();app.run("inspect.draft", json!({"pull": [-1, -1, 0]})).unwrap();- app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: false });+ app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: false, oit: false });const SIZE: u32 = 256;let proj = projection(&app, Rect::from_min_size(Pos2::ZERO, vec2(SIZE as f32, SIZE as f32)));let e = proj.cam.eye().to_f32();@@ -9433,7 +10063,8 @@ mod grid_plane_tests {app.cam.yaw = 0.0;app.cam.target = Vec3::ZERO;app.cam.distance = 100.0;- let under = build_sketch_scene(&app, &projection(&app, rect)).under;+ let scene = build_sketch_scene(&app, &projection(&app, rect));+ let under = &scene.under;// Each line of the grid: two points, a colour and a width.let segments: Vec<([f32; 3], [f32; 3], u8)> = under.as_chunks::<32>()@@ -9441,7 +10072,9 @@ mod grid_plane_tests {.iter().map(|l| {let point = |at: usize| [0, 4, 8].map(|i| f32::from_le_bytes(l[at + i..at + i + 4].try_into().unwrap()));- (point(0), point(12), l[27])+ let index = u32::from_le_bytes(l[24..28].try_into().unwrap());+ let alpha = scene.palette.get(crate::gpu::PaletteIndex(index)).map_or(0, |c| c[3]);+ (point(0), point(12), alpha)}).collect();assert!(!segments.is_empty(), "the grid is drawn");@@ -9548,8 +10181,14 @@ mod grid_plane_tests {let faded = build_sketch_scene(&app, &proj).merged();// The same grid at full strength: every piece of it opaque.let mut full = faded.clone();- for piece in full.under.as_chunks_mut::<32>().0 {- piece[27] = 255;+ let palette = std::sync::Arc::make_mut(&mut full.palette);+ for piece in full.under.as_chunks::<32>().0 {+ let index = u32::from_le_bytes(piece[24..28].try_into().unwrap());+ let slot = crate::gpu::PaletteIndex(index);+ if let Some(mut colour) = palette.get(slot) {+ colour[3] = 255;+ palette.set(slot, colour);+ }}let (Some(faded), Some(full)) = (render(faded), render(full)) else {eprintln!("skipping: no GPU adapter");diff --git a/crates/ui-egui/src/viewport_appearance_tests.rs b/crates/ui-egui/src/viewport_appearance_tests.rsindex 50867e41fb..ab9d180a7a 100644--- a/crates/ui-egui/src/viewport_appearance_tests.rs+++ b/crates/ui-egui/src/viewport_appearance_tests.rs@@ -34,12 +34,19 @@ fn a_finished_sketch_on_a_face_draws_a_halo_under_its_own_curves_only() {let (lines, remainder) = bytes.as_chunks::<{ crate::gpu::LINE_SIZE }>();assert!(remainder.is_empty());let halo = super::c4(tokens.sketch_halo);- let halo_count = lines.iter().filter(|line| line[24..28] == halo).count();+ let halo_count = lines.iter().filter(|line| line_color(&scene, *line) == halo).count();crate::prefs::set(&mut app, &json!({"sketch_halo": false})).unwrap();assert_ne!(super::sketch_scene_key(&app, &projection), enabled_key, "changing the preference rebuilds the sketch scene");let disabled = super::build_sketch_scene(&app, &projection);- let without_halos: Vec<u8> = lines.iter().filter(|line| line[24..28] != halo).flat_map(|line| line.iter().copied()).collect();- assert_eq!(if finished { &disabled.lines } else { &disabled.overlay }, &without_halos, "off draws only the original curves");+ let disabled_bytes = if finished { &disabled.lines } else { &disabled.overlay };+ let (without_halos, _) = disabled_bytes.as_chunks::<{ crate::gpu::LINE_SIZE }>();+ let cores_only: Vec<&[u8]> = lines.iter().filter(|line| line_color(&scene, *line) != halo).map(|line| &line[..]).collect();+ assert_eq!(cores_only.len(), without_halos.len(), "off draws only the original curves");+ for (a, b) in cores_only.iter().zip(without_halos) {+ assert_eq!(a[..24], b[..24], "same segment");+ assert_eq!(line_color(&scene, a), line_color(&disabled, b), "same colour");+ assert_eq!(a[28..32], b[28..32], "same width");+ }if !finished {assert_eq!(halo_count, 0, "a sketch being edited has no halo");continue;@@ -49,13 +56,13 @@ fn a_finished_sketch_on_a_face_draws_a_halo_under_its_own_curves_only() {let projected = super::c4(tokens.sketch_projected);let mut cores = 0;let mut references = 0;- for (index, core) in lines.iter().enumerate().filter(|(_, line)| line[24..28] != halo) {- let rim = lines[..index].iter().find(|line| line[..24] == core[..24] && line[24..28] == halo);- if core[24..28] == projected {+ for (index, core) in lines.iter().enumerate().filter(|(_, line)| line_color(&scene, *line) != halo) {+ let rim = lines[..index].iter().find(|line| line[..24] == core[..24] && line_color(&scene, *line) == halo);+ if line_color(&scene, core) == projected {assert!(rim.is_none(), "the face's projected outline has no halo");references += 1;} else {- assert_eq!(core[24..28], super::c4(tokens.sketch_fixed));+ assert_eq!(line_color(&scene, core), super::c4(tokens.sketch_fixed));let rim = rim.unwrap();assert_eq!(width(rim), width(core) + super::SKETCH_HALO_WIDTH, "halo precedes the narrower core");cores += 1;@@ -109,17 +116,155 @@ fn placed_step_body_uses_imported_opacity_until_a_design_look_overrides_it() {);let (vertices, remainder) = scene.glass.as_chunks::<{ crate::gpu::TRI_SIZE }>();assert!(remainder.is_empty());- assert!(vertices.iter().all(|v| v[27] == 102));+ assert!(vertices.iter().all(|v| vertex_color(&scene, v)[3] == 102));app.run("appearance.assign", json!({"bodies":[source],"color":"#336699","opacity":0.7})).unwrap();- let scene = build_scene(&app);+ let scene = build_scene(&app).merged();let (vertices, remainder) = scene.glass.as_chunks::<{ crate::gpu::TRI_SIZE }>();assert!(remainder.is_empty());- assert!(vertices.iter().all(|v| v[27] == 179));+ assert!(vertices.iter().all(|v| vertex_color(&scene, v)[3] == 179));app.run("appearance.assign", json!({"bodies":[source]})).unwrap();- let scene = build_scene(&app);+ let scene = build_scene(&app).merged();let (vertices, remainder) = scene.glass.as_chunks::<{ crate::gpu::TRI_SIZE }>();assert!(remainder.is_empty());- assert!(vertices.iter().all(|v| v[27] == 102));+ assert!(vertices.iter().all(|v| vertex_color(&scene, v)[3] == 102));+}++/// The colour of a built triangle vertex: its palette index resolves through the scene.+fn vertex_color(scene: &crate::gpu::GpuScene, v: &[u8]) -> [u8; 4] {+ let index = v.get(crate::gpu::TRI_SIZE - 4..crate::gpu::TRI_SIZE).and_then(|b| b.try_into().ok()).map_or(0, u32::from_le_bytes);+ scene.palette.get(crate::gpu::PaletteIndex(index)).unwrap_or([0; 4])+}++/// The colour of a line record: its palette index resolves through the scene.+fn line_color(scene: &crate::gpu::GpuScene, line: &[u8]) -> [u8; 4] {+ let index = line.get(24..28).and_then(|b| b.try_into().ok()).map_or(0, u32::from_le_bytes);+ scene.palette.get(crate::gpu::PaletteIndex(index)).unwrap_or([0; 4])+}++/// The first vertex's palette index and its colour.+fn first_vertex(scene: &crate::gpu::GpuScene, vertices: &[u8]) -> (u32, Option<[u8; 4]>) {+ let index = vertices.get(24..28).and_then(|b| b.try_into().ok()).map_or(0, u32::from_le_bytes);+ (index, scene.palette.get(crate::gpu::PaletteIndex(index)))+}++#[test]+fn selection_does_not_rebuild_the_model_scene() {+ let mut h = crate::scenario::Harness::new();+ h.app.home.open = false;+ h.app.ui.ground_shadow = false;+ h.app.set_origin_shown(false);+ h.app.run("solid.box", json!({"length": 20, "width": 15, "height": 10})).unwrap();+ h.app.viewport.gpu =+ Some(super::GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: false, oit: false });+ h.frame();+ let key = h.app.viewport.key;+ let highlight = h.app.viewport.hl_key;+ // Clear the scene the first frame uploaded; an untouched model must not upload another.+ let _ = h.app.viewport.slot.lock().unwrap().take();+ let name = h.app.session.world_state().bodies[0].name.clone();+ h.app.session.selection = vec![solidcraft_engine::Sel::Body { name }];+ h.frame();+ assert_eq!(h.app.viewport.key, key, "a selection does not change the model scene key");+ assert!(h.app.viewport.slot.lock().unwrap().is_none(), "and does not rebuild it");+ assert_ne!(h.app.viewport.hl_key, highlight, "the highlight scene does rebuild");+}++#[test]+fn an_appearance_edit_resolves_only_the_bodies_it_changes() {+ let mut app = SolveApp::new(Session::default(), Services::default());+ app.ui.ground_shadow = false;+ app.set_origin_shown(false);+ app.run("solid.box", json!({"length": 20, "width": 15, "height": 10, "body_name": "A"})).unwrap();+ app.run("solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [40, 0, 0], "body_name": "B"})).unwrap();+ let _ = build_scene(&app);+ let before = app.viewport.appearance.lock().unwrap().resolved;+ app.run("appearance.assign", json!({"bodies": ["A"], "color": "#336699"})).unwrap();+ let _ = build_scene(&app);+ let after = app.viewport.appearance.lock().unwrap().resolved;+ assert_eq!(after.saturating_sub(before), 1, "only the body whose look changed is resolved again");+}++#[test]+fn a_colour_edit_reuses_every_block_vertex() {+ let mut app = SolveApp::new(Session::default(), Services::default());+ app.ui.ground_shadow = false;+ app.set_origin_shown(false);+ app.run("solid.box", json!({"length": 20, "width": 15, "height": 10})).unwrap();+ let name = app.session.world_state().bodies[0].name.clone();+ let first = build_scene(&app);+ let block = first.blocks.iter().find(|b| !b.bytes.vertices.is_empty()).expect("the box has a block");+ let (key, vertices) = (block.key, block.bytes.vertices.clone());+ app.run("appearance.assign", json!({"bodies": [name], "color": "#336699"})).unwrap();+ let second = build_scene(&app);+ let block = second.blocks.iter().find(|b| b.key == key).expect("the block comes back");+ assert!(std::sync::Arc::ptr_eq(&vertices, &block.bytes.vertices), "a colour edit must not rebuild a vertex");+ assert_eq!(first_vertex(&second, &block.bytes.vertices).1, Some([51, 102, 153, 255]), "the palette carries the new colour");+}++#[test]+fn an_opacity_class_change_keeps_vertices_and_rewrites_only_the_runs() {+ let mut app = SolveApp::new(Session::default(), Services::default());+ app.ui.ground_shadow = false;+ app.set_origin_shown(false);+ app.run("solid.box", json!({"length": 20, "width": 15, "height": 10})).unwrap();+ let name = app.session.world_state().bodies[0].name.clone();+ let first = build_scene(&app);+ let block = first.blocks.iter().find(|b| !b.bytes.vertices.is_empty()).expect("the box has a block");+ let (key, bytes) = (block.key, block.bytes.clone());+ app.run("appearance.assign", json!({"bodies": [name], "color": "#336699", "opacity": 0.5})).unwrap();+ let second = build_scene(&app);+ let block = second.blocks.iter().find(|b| b.key == key).expect("the block key is geometry's");+ assert!(std::sync::Arc::ptr_eq(&bytes.vertices, &block.bytes.vertices), "the class change keeps every vertex");+ assert!(!std::sync::Arc::ptr_eq(&bytes.opaque, &block.bytes.opaque), "the opaque runs change");+ assert!(block.bytes.opaque.is_empty() && !block.bytes.glass.is_empty(), "the triangles moved to the glass runs");+ let triangles: u32 = block.bytes.glass.iter().map(|r| r.len() as u32).sum::<u32>() / 3;+ assert_eq!(block.bytes.glass.len(), 1, "one body of one class is one run, drawn with no index buffer");+ assert_eq!(triangles, 12, "every triangle of the box");+ let vertex = block.bytes.glass.first().map_or(0, |r| r.start) as usize;+ let at = vertex * crate::gpu::TRI_SIZE;+ let colour = first_vertex(&second, block.bytes.vertices.get(at..).unwrap_or_default()).1;+ assert_eq!(colour.map(|c| c[3]), Some(128), "0.5 of 255");+}++/// On the GPU, a colour edit writes palette rows and no geometry, also while the body is+/// see-through (the sorted glass stream of the no-OIT path is kept).+#[cfg(not(target_arch = "wasm32"))]+#[test]+fn appearance_edits_upload_palette_rows_only() {+ const SIZE: u32 = 64;+ let Some(mut frames) = crate::gpu::OffscreenFrames::new(SIZE, false) else {+ eprintln!("skipping: no GPU adapter");+ return;+ };+ let mut app = SolveApp::new(Session::default(), Services::default());+ app.ui.ground_shadow = false;+ app.set_origin_shown(false);+ app.viewport.gpu =+ Some(crate::gpu::GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: false, oit: false });+ app.run("solid.box", json!({"length": 20, "width": 15, "height": 10})).unwrap();+ app.fit_view();+ let name = app.session.world_state().bodies[0].name.clone();+ let highlight: crate::gpu::SceneSlot = std::sync::Arc::new(std::sync::Mutex::new(None));+ let mut key = 0;+ let mut draw = |app: &SolveApp| {+ key += 1;+ let slot: crate::gpu::SceneSlot = std::sync::Arc::new(std::sync::Mutex::new(Some(build_scene(app))));+ frames.frame(crate::scale_tests::view_frame(app, SIZE, (key, &slot), (0, &highlight)));+ frames.uploads()+ };+ let cold = draw(&app);+ assert!(cold.geometry > 0 && cold.palette > 0, "the first scene uploads its geometry and palette: {cold:?}");+ app.run("appearance.assign", json!({"bodies": [&name], "color": "#336699"})).unwrap();+ let colour = draw(&app);+ assert_eq!(colour.geometry, 0, "a colour edit uploads no geometry: {colour:?}");+ assert!(colour.palette > 0, "it writes the palette: {colour:?}");+ app.run("appearance.assign", json!({"bodies": [&name], "color": "#336699", "opacity": 0.5})).unwrap();+ let class = draw(&app);+ assert!(class.geometry <= 12 * 3 * crate::gpu::TRI_SIZE as u64, "a class change uploads at most the sorted glass stream: {class:?}");+ app.run("appearance.assign", json!({"bodies": [&name], "color": "#993366", "opacity": 0.5})).unwrap();+ let glass = draw(&app);+ assert_eq!(glass.geometry, 0, "a see-through body's colour edit uploads no geometry: {glass:?}");+ assert!(glass.palette > 0, "it writes the palette: {glass:?}");}/// Exercise the live GPU scene slots: a fresh headless render always rebuilds and would hide@@ -131,7 +276,8 @@ fn theme_switches_refresh_cached_viewport_colours_without_remeshing() {h.app.ui.ground_shadow = false;h.app.set_origin_shown(false);h.app.run("solid.box", json!({"length": 20, "width": 15, "height": 10})).unwrap();- h.app.viewport.gpu = Some(super::GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: false });+ h.app.viewport.gpu =+ Some(super::GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: false, oit: false });let body = h.app.session.world_state().bodies[0].name.clone();h.app.session.selection = vec![solidcraft_engine::Sel::Body { name: body.clone() }];h.frame();@@ -153,7 +299,7 @@ fn theme_switches_refresh_cached_viewport_colours_without_remeshing() {let (vertices, remainder) = scene.tris.as_chunks::<{ crate::gpu::TRI_SIZE }>();assert!(remainder.is_empty() && !vertices.is_empty());let colour = super::c4(crate::theme::Tokens::get().body);- assert!(vertices.iter().all(|v| v[24..28] == colour), "{theme}: stale body colour");+ assert!(vertices.iter().all(|v| vertex_color(&scene, v) == colour), "{theme}: stale body colour");assert_eq!(h.app.session.revision, revision, "theme changes must not edit the design");assert!(std::sync::Arc::ptr_eq(&mesh, &h.app.session.world_state().bodies[0].cached_mesh().unwrap()));h.frame();@@ -167,7 +313,7 @@ fn theme_switches_refresh_cached_viewport_colours_without_remeshing() {let scene = h.app.viewport.slot.lock().unwrap().take().unwrap().merged();let (vertices, _) = scene.tris.as_chunks::<{ crate::gpu::TRI_SIZE }>();assert!(!vertices.is_empty());- assert!(vertices.iter().all(|v| v[24..28] == [51, 102, 153, 255]), "{theme}: explicit appearance preserved");+ assert!(vertices.iter().all(|v| vertex_color(&scene, v) == [51, 102, 153, 255]), "{theme}: explicit appearance preserved");}}