SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Viewport: order-independent transparency for see-through surfaces (#4734) (#4903)
Jackson Oursland75261cd79733
diff --git a/assets/shaders/viewport.wgsl b/assets/shaders/viewport.wgslindex 2cc978d853..6884ad8562 100644--- a/assets/shaders/viewport.wgsl+++ b/assets/shaders/viewport.wgsl@@ -147,6 +147,48 @@ fn fs_solid_cut_flat(i: FOut, @builtin(front_facing) front: bool) -> CutOut {return o;}+/// Weighted blended order-independent transparency (`view/oit.rs`): a see-through fragment's+/// colour, premultiplied and weighted by its alpha and nearness, into the accumulation target,+/// and its alpha into the revealage target (which keeps what is behind it by 1 - alpha).+struct Oit {+ @location(0) accum: vec4<f32>,+ @location(1) reveal: vec4<f32>,+};++fn oit(c: vec4<f32>, z: f32) -> Oit {+ let a = clamp(c.a, 0.0, 1.0);+ // Depth 0 near and 1 far, whichever way the buffer runs.+ let d = select(z, 1.0 - z, reversed());+ let w = clamp(a * max(1e-2, 3e3 * pow(1.0 - d, 3.0)), 1e-2, 3e3);+ var o: Oit;+ o.accum = vec4<f32>(c.rgb * a, a) * w;+ o.reveal = vec4<f32>(a);+ return o;+}++@fragment+fn fs_oit(i: TOut) -> Oit {+ if (clipped(i.wp)) { discard; }+ return oit(shade(i), i.pos.z);+}++@fragment+fn fs_oit_flat(i: FOut, @builtin(front_facing) front: bool) -> Oit {+ let t = flat_fragment(i, front);+ let o = oit(shade(t), t.pos.z);+ if (clipped(t.wp)) { discard; }+ return o;+}++/// A see-through flat-shaded placement (faded or glass), shaded like `fs_tri`.+@fragment+fn fs_tri_flat(i: FOut, @builtin(front_facing) front: bool) -> @location(0) vec4<f32> {+ let t = flat_fragment(i, front);+ let c = shade(t);+ if (clipped(t.wp)) { discard; }+ return c;+}+@fragmentfn fs_ao_depth_flat(i: FOut, @builtin(front_facing) front: bool) -> AoDepth {let t = flat_fragment(i, front);diff --git a/crates/geom/src/lib.rs b/crates/geom/src/lib.rsindex 7864c1ba39..19a8f77a0c 100644--- a/crates/geom/src/lib.rs+++ b/crates/geom/src/lib.rs@@ -27,6 +27,7 @@ pub mod network;mod plane;mod profile;pub mod section;+pub mod simplify;pub mod spline_space;pub mod tess;pub mod tspline;diff --git a/crates/geom/src/simplify.rs b/crates/geom/src/simplify.rsnew file mode 100644index 0000000000..7a4c0f3fb4--- /dev/null+++ b/crates/geom/src/simplify.rs@@ -0,0 +1,551 @@+//! Triangle mesh simplification, for drawing a large mesh coarser where it is small on screen+//! (display levels of detail). Display only: nothing measured, exported or picked reads a+//! simplified mesh.+//!+//! Edge collapse ordered by quadric error (Garland and Heckbert, "Surface Simplification Using+//! Quadric Error Metrics", SIGGRAPH 1997): each vertex carries the sum of the squared-distance+//! quadrics of the planes of its faces; the edge whose two ends merge at the point of least+//! summed squared distance goes first. A collapse that would fold a face over (its normal turning+//! by more than about 80°) or join two sheets of the surface (the ends sharing more neighbours+//! than the faces between them) is skipped. Open boundaries carry extra planes across them, so+//! they keep their place.+//!+//! [`levels`] simplifies once, keeping a copy of the mesh each time it reaches the next target+//! triangle count, with its error measured: how far its vertices and the centres of its triangles+//! lie from the original surface, at most.++use std::cmp::Ordering;+use std::collections::BinaryHeap;++use crate::Vec3;++/// Most triangles [`levels`] simplifies (more: no levels).+pub const MAX_TRIANGLES: usize = 50_000_000;++/// How much more an open boundary's planes count than a face's.+const BOUNDARY_WEIGHT: f64 = 10.0;+/// A collapse may turn a face's normal by at most this (cosine): about 80°.+const MIN_TURN_COS: f64 = 0.2;++/// A simplified copy of a mesh.+#[derive(Clone, Debug, Default)]+pub struct Level {+ pub positions: Vec<Vec3>,+ pub triangles: Vec<[u32; 3]>,+ /// How far (mm) its vertices and triangle centres lie from the original surface, at most.+ pub error: f64,+}++/// The mesh (`positions`, and `triangles` indexing them; corners at the same position are one+/// vertex) simplified to each of `targets` triangles in turn (largest first), one [`Level`] per+/// target reached. Simplification stops early when no edge can collapse any more; the levels made+/// by then are returned, but none that is not at least a fifth smaller than the one before it.+/// Triangles with an index out of range or a point not finite are left out; an empty or oversized+/// mesh ([`MAX_TRIANGLES`]) has no levels.+pub fn levels(positions: &[Vec3], triangles: &[[u32; 3]], targets: &[usize]) -> Vec<Level> {+ if triangles.is_empty() || triangles.len() > MAX_TRIANGLES {+ return Vec::new();+ }+ let Some(mut m) = Collapser::new(positions, triangles) else { return Vec::new() };+ let original = Surface::new(&m.pos, &m.tris);+ let mut out: Vec<Level> = Vec::new();+ let mut previous = m.live_triangles;+ for &target in targets {+ if target >= previous {+ continue;+ }+ m.collapse_to(target);+ if m.live_triangles * 5 > previous * 4 {+ break;+ }+ previous = m.live_triangles;+ let (mut level, seeds) = m.level();+ // Never less than a coarser level's own error.+ level.error = original.deviation(&level, &seeds).max(out.last().map_or(0.0, |l| l.error));+ out.push(level);+ }+ out+}++/// The original surface, for measuring how far a level strays from it.+struct Surface {+ tris: Vec<[Vec3; 3]>,+ bvh: crate::Bvh,+}++impl Surface {+ fn new(pos: &[[f64; 3]], tris: &[[u32; 3]]) -> Surface {+ let tris: Vec<[Vec3; 3]> = tris.iter().map(|t| t.map(|i| pos.get(i as usize).map_or(Vec3::ZERO, |p| Vec3::new(p[0], p[1], p[2])))).collect();+ let boxes: Vec<crate::Aabb3> = tris+ .iter()+ .map(|t| {+ let mut b = crate::Aabb3::EMPTY;+ t.iter().for_each(|p| b.add(*p));+ b+ })+ .collect();+ Surface { bvh: crate::Bvh::new(&boxes), tris }+ }++ fn to_triangle(&self, p: Vec3, t: u32) -> f64 {+ self.tris.get(t as usize).map_or(f64::INFINITY, |[a, b, c]| crate::compare::closest_on_triangle(p, *a, *b, *c).dist(p))+ }++ /// How far `p` lies from the surface, when that is more than `beyond`; otherwise+ /// `beyond` or less (the search stops at the first triangle within `beyond`). `near`: an+ /// original triangle `p` is likely near (where it came from), so the search starts close.+ fn distance_beyond(&self, p: Vec3, beyond: f64, near: u32) -> f64 {+ let best = std::cell::Cell::new(self.to_triangle(p, near));+ let gap = |b: &crate::Aabb3| {+ let d = |v: f64, lo: f64, hi: f64| (lo - v).max(v - hi).max(0.0);+ Vec3::new(d(p.x, b.min.x, b.max.x), d(p.y, b.min.y, b.max.y), d(p.z, b.min.z, b.max.z)).len()+ };+ self.bvh.visit(|b| best.get() > beyond && gap(b) < best.get(), |t| best.set(best.get().min(self.to_triangle(p, t))));+ best.get()+ }++ /// How far `level`'s vertices and triangle centres lie from the surface, at most (`seeds`:+ /// an original triangle each vertex came from).+ fn deviation(&self, level: &Level, seeds: &[u32]) -> f64 {+ let at = |i: u32| level.positions.get(i as usize).copied().unwrap_or(Vec3::ZERO);+ let seed = |i: u32| seeds.get(i as usize).copied().unwrap_or(0);+ let vertices = level.positions.iter().copied().zip(seeds.iter().copied());+ let centres = level.triangles.iter().map(|t| {+ let [a, b, c] = t.map(at);+ ((a + b + c) * (1.0 / 3.0), seed(t[0]))+ });+ let worst = vertices.chain(centres).fold(0.0, |worst: f64, (p, near)| worst.max(self.distance_beyond(p, worst, near)));+ if worst.is_finite() { worst } else { 0.0 }+ }+}++/// A symmetric 4 × 4 quadric: a a, a b, a c, a d, b b, b c, b d, c c, c d, d d.+#[derive(Clone, Copy, Default)]+struct Quadric([f64; 10]);++impl Quadric {+ /// The squared distance to the plane n · p + d = 0 (`n` unit), times `w`.+ fn plane(n: [f64; 3], d: f64, w: f64) -> Quadric {+ let [a, b, c] = n;+ Quadric([a * a * w, a * b * w, a * c * w, a * d * w, b * b * w, b * c * w, b * d * w, c * c * w, c * d * w, d * d * w])+ }++ fn add(&mut self, o: &Quadric) {+ for (x, y) in self.0.iter_mut().zip(o.0) {+ *x += y;+ }+ }++ fn sum(&self, o: &Quadric) -> Quadric {+ let mut q = *self;+ q.add(o);+ q+ }++ /// The summed squared distance at `p`.+ fn at(&self, p: [f64; 3]) -> f64 {+ let [aa, ab, ac, ad, bb, bc, bd, cc, cd, dd] = self.0;+ let [x, y, z] = p;+ (aa * x * x+ + 2.0 * ab * x * y+ + 2.0 * ac * x * z+ + 2.0 * ad * x+ + bb * y * y+ + 2.0 * bc * y * z+ + 2.0 * bd * y+ + cc * z * z+ + 2.0 * cd * z+ + dd)+ .max(0.0)+ }++ /// The point of least summed squared distance, when it is well defined.+ fn best(&self) -> Option<[f64; 3]> {+ let [aa, ab, ac, ad, bb, bc, bd, cc, cd, _] = self.0;+ let det = aa * (bb * cc - bc * bc) - ab * (ab * cc - bc * ac) + ac * (ab * bc - bb * ac);+ let scale = (aa.abs() + bb.abs() + cc.abs()).powi(3);+ if !(det.abs() > 1e-12 * scale) {+ return None;+ }+ let (r0, r1, r2) = (-ad, -bd, -cd);+ let x = (r0 * (bb * cc - bc * bc) - ab * (r1 * cc - bc * r2) + ac * (r1 * bc - bb * r2)) / det;+ let y = (aa * (r1 * cc - bc * r2) - r0 * (ab * cc - bc * ac) + ac * (ab * r2 - r1 * ac)) / det;+ let z = (aa * (bb * r2 - r1 * bc) - ab * (ab * r2 - r1 * ac) + r0 * (ab * bc - bb * ac)) / det;+ [x, y, z].iter().all(|v| v.is_finite()).then_some([x, y, z])+ }+}++fn sub(a: [f64; 3], b: [f64; 3]) -> [f64; 3] {+ [a[0] - b[0], a[1] - b[1], a[2] - b[2]]+}++fn cross(a: [f64; 3], b: [f64; 3]) -> [f64; 3] {+ [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]]+}++fn dot(a: [f64; 3], b: [f64; 3]) -> f64 {+ a[0] * b[0] + a[1] * b[1] + a[2] * b[2]+}++fn unit(a: [f64; 3]) -> Option<[f64; 3]> {+ let l = dot(a, a).sqrt();+ (l > 0.0 && l.is_finite()).then(|| [a[0] / l, a[1] / l, a[2] / l])+}++/// A candidate collapse: its cost, its ends, and their versions when it was costed (a later+/// change to either end makes it stale).+#[derive(Clone, Copy)]+struct Candidate {+ cost: f64,+ u: u32,+ v: u32,+ stamps: (u32, u32),+}++impl PartialEq for Candidate {+ fn eq(&self, o: &Self) -> bool {+ self.cmp(o) == Ordering::Equal+ }+}+impl Eq for Candidate {}+impl PartialOrd for Candidate {+ fn partial_cmp(&self, o: &Self) -> Option<Ordering> {+ Some(self.cmp(o))+ }+}+impl Ord for Candidate {+ /// The cheapest first (the heap pops the greatest), ties by the ends, so the result never+ /// depends on the heap's order.+ fn cmp(&self, o: &Self) -> Ordering {+ o.cost.total_cmp(&self.cost).then_with(|| (o.u, o.v).cmp(&(self.u, self.v)))+ }+}++/// A quick hasher for welding by position (the keys are coordinates' bits).+#[derive(Default)]+struct BitsHasher(u64);++impl std::hash::Hasher for BitsHasher {+ fn finish(&self) -> u64 {+ self.0+ }+ fn write(&mut self, bytes: &[u8]) {+ for b in bytes {+ self.write_u64(u64::from(*b));+ }+ }+ fn write_u64(&mut self, x: u64) {+ self.0 = (self.0.rotate_left(5) ^ x).wrapping_mul(0x51_7c_c1_b7_27_22_0a_95);+ }+}++/// The lists a collapse works with, kept between collapses.+#[derive(Default)]+struct Scratch {+ at_u: Vec<u32>,+ at_v: Vec<u32>,+ shared: Vec<u32>,+ nu: Vec<u32>,+ nv: Vec<u32>,+}++impl Scratch {+ fn clear(&mut self) {+ for l in [&mut self.at_u, &mut self.at_v, &mut self.shared, &mut self.nu, &mut self.nv] {+ l.clear();+ }+ }+}++struct Collapser {+ pos: Vec<[f64; 3]>,+ quadric: Vec<Quadric>,+ alive: Vec<bool>,+ stamp: Vec<u32>,+ tris: Vec<[u32; 3]>,+ tri_alive: Vec<bool>,+ /// The triangles at each vertex (dead ones are dropped lazily).+ around: Vec<Vec<u32>>,+ /// An original triangle at each vertex (where it came from), to start a search near it.+ seed: Vec<u32>,+ /// Lists a collapse reuses.+ scratch: Scratch,+ heap: BinaryHeap<Candidate>,+ live_triangles: usize,+}++impl Collapser {+ fn new(positions: &[Vec3], triangles: &[[u32; 3]]) -> Option<Collapser> {+ // Weld corners at the same position.+ let mut index: std::collections::HashMap<[u64; 3], u32, std::hash::BuildHasherDefault<BitsHasher>> =+ std::collections::HashMap::with_capacity_and_hasher(positions.len() / 2, Default::default());+ let mut remap: Vec<Option<u32>> = Vec::with_capacity(positions.len());+ let mut pos: Vec<[f64; 3]> = Vec::new();+ for p in positions {+ if !p.is_finite() {+ remap.push(None);+ continue;+ }+ let next = u32::try_from(pos.len()).ok()?;+ let key = [(p.x + 0.0).to_bits(), (p.y + 0.0).to_bits(), (p.z + 0.0).to_bits()];+ remap.push(Some(*index.entry(key).or_insert_with(|| {+ pos.push([p.x, p.y, p.z]);+ next+ })));+ }+ drop(index);+ let mut tris: Vec<[u32; 3]> = Vec::with_capacity(triangles.len());+ for t in triangles {+ let r = |i: u32| remap.get(i as usize).copied().flatten();+ let (Some(a), Some(b), Some(c)) = (r(t[0]), r(t[1]), r(t[2])) else { continue };+ if a != b && b != c && c != a {+ tris.push([a, b, c]);+ }+ }+ if tris.is_empty() {+ return None;+ }+ let n = pos.len();+ let mut quadric = vec![Quadric::default(); n];+ let mut around: Vec<Vec<u32>> = vec![Vec::new(); n];+ let mut sides: Vec<(u32, u32, u32)> = Vec::with_capacity(tris.len() * 3);+ for (ti, t) in tris.iter().enumerate() {+ let ti = u32::try_from(ti).ok()?;+ let [a, b, c] = t.map(|i| pos.get(i as usize).copied().unwrap_or_default());+ if let Some(nrm) = unit(cross(sub(b, a), sub(c, a))) {+ let q = Quadric::plane(nrm, -dot(nrm, a), 1.0);+ for &i in t {+ if let Some(x) = quadric.get_mut(i as usize) {+ x.add(&q);+ }+ }+ }+ for (k, &i) in t.iter().enumerate() {+ if let Some(list) = around.get_mut(i as usize) {+ list.push(ti);+ }+ let j = t[(k + 1) % 3];+ sides.push((i.min(j), i.max(j), ti));+ }+ }+ // Open boundaries (sides of one triangle only): a plane across each, weighted, so the+ // boundary keeps its place.+ sides.sort_unstable();+ let mut k = 0;+ while k < sides.len() {+ let (a, b, t) = sides[k];+ let mut e = k + 1;+ while e < sides.len() && sides[e].0 == a && sides[e].1 == b {+ e += 1;+ }+ if e - k == 1+ && let (Some(pa), Some(pb), Some(tri)) = (pos.get(a as usize), pos.get(b as usize), tris.get(t as usize))+ {+ let [p0, p1, p2] = tri.map(|i| pos.get(i as usize).copied().unwrap_or_default());+ let face = cross(sub(p1, p0), sub(p2, p0));+ if let Some(across) = unit(cross(sub(*pb, *pa), face)) {+ let q = Quadric::plane(across, -dot(across, *pa), BOUNDARY_WEIGHT);+ for i in [a, b] {+ if let Some(x) = quadric.get_mut(i as usize) {+ x.add(&q);+ }+ }+ }+ }+ k = e;+ }+ let live_triangles = tris.len();+ let seed: Vec<u32> = around.iter().map(|list| list.first().copied().unwrap_or(0)).collect();+ let mut m = Collapser {+ alive: vec![true; n],+ stamp: vec![0; n],+ tri_alive: vec![true; tris.len()],+ heap: BinaryHeap::with_capacity(sides.len() / 2 + 1),+ pos,+ quadric,+ tris,+ around,+ seed,+ scratch: Scratch::default(),+ live_triangles,+ };+ let mut last = None;+ for &(a, b, _) in &sides {+ if last != Some((a, b)) {+ m.offer(a, b);+ last = Some((a, b));+ }+ }+ Some(m)+ }++ /// Where `u` and `v` would merge, and its cost.+ fn target(&self, u: u32, v: u32) -> Option<([f64; 3], f64)> {+ let (qu, qv) = (self.quadric.get(u as usize)?, self.quadric.get(v as usize)?);+ let q = qu.sum(qv);+ let (pu, pv) = (*self.pos.get(u as usize)?, *self.pos.get(v as usize)?);+ let mid = [(pu[0] + pv[0]) * 0.5, (pu[1] + pv[1]) * 0.5, (pu[2] + pv[2]) * 0.5];+ // The best point when it lies near the edge; else the best of its ends and middle.+ let reach = dot(sub(pu, pv), sub(pu, pv)) * 4.0;+ let best = q.best().filter(|p| dot(sub(*p, mid), sub(*p, mid)) <= reach);+ best.into_iter().chain([pu, pv, mid]).map(|p| (p, q.at(p))).min_by(|a, b| a.1.total_cmp(&b.1))+ }++ fn offer(&mut self, u: u32, v: u32) {+ let Some((_, cost)) = self.target(u, v) else { return };+ let stamps = (self.stamp.get(u as usize).copied().unwrap_or(0), self.stamp.get(v as usize).copied().unwrap_or(0));+ self.heap.push(Candidate { cost, u, v, stamps });+ }++ /// The live vertices sharing a live triangle with `v`.+ fn neighbours(&self, v: u32, out: &mut Vec<u32>) {+ out.clear();+ out.extend(+ self.around+ .get(v as usize)+ .into_iter()+ .flatten()+ .filter(|t| self.tri_alive.get(**t as usize).copied().unwrap_or(false))+ .filter_map(|t| self.tris.get(*t as usize))+ .flat_map(|t| t.iter().copied())+ .filter(|i| *i != v),+ );+ out.sort_unstable();+ out.dedup();+ }++ fn collapse_to(&mut self, target: usize) {+ while self.live_triangles > target {+ let Some(c) = self.heap.pop() else { return };+ let current = |i: u32| self.alive.get(i as usize).copied().unwrap_or(false);+ let stamp = |i: u32| self.stamp.get(i as usize).copied().unwrap_or(u32::MAX);+ if !current(c.u) || !current(c.v) || (stamp(c.u), stamp(c.v)) != c.stamps {+ continue;+ }+ self.collapse(c.u, c.v);+ }+ }++ /// Merge `v` into `u` at their best point, unless that would fold a face over or join two+ /// sheets of the surface.+ fn collapse(&mut self, u: u32, v: u32) {+ let Some((p, _)) = self.target(u, v) else { return };+ let live = |t: &u32| self.tri_alive.get(*t as usize).copied().unwrap_or(false);+ let mut s = std::mem::take(&mut self.scratch);+ s.clear();+ s.at_v.extend(self.around.get(v as usize).into_iter().flatten().copied().filter(live));+ s.at_u.extend(self.around.get(u as usize).into_iter().flatten().copied().filter(live));+ s.shared.extend(s.at_v.iter().copied().filter(|t| self.tris.get(*t as usize).is_some_and(|tri| tri.contains(&u))));+ let done = self.collapse_with(u, v, p, &mut s);+ self.scratch = s;+ if done {+ self.reoffer(u);+ }+ }++ /// [`Collapser::collapse`] with its lists in `s`: whether it collapsed.+ fn collapse_with(&mut self, u: u32, v: u32, p: [f64; 3], s: &mut Scratch) -> bool {+ if s.shared.is_empty() {+ return false;+ }+ // Two sheets meeting only at these ends would be joined.+ self.neighbours(u, &mut s.nu);+ self.neighbours(v, &mut s.nv);+ let common = s.nu.iter().filter(|x| s.nv.binary_search(x).is_ok()).count();+ if common > s.shared.len() {+ return false;+ }+ // No face folds over.+ for &t in s.at_u.iter().chain(&s.at_v).filter(|t| !s.shared.contains(t)) {+ let Some(tri) = self.tris.get(t as usize) else { continue };+ let corners = tri.map(|i| self.pos.get(i as usize).copied().unwrap_or_default());+ let moved = tri.map(|i| if i == u || i == v { p } else { self.pos.get(i as usize).copied().unwrap_or_default() });+ let before = cross(sub(corners[1], corners[0]), sub(corners[2], corners[0]));+ let after = cross(sub(moved[1], moved[0]), sub(moved[2], moved[0]));+ let (lb, la) = (dot(before, before).sqrt(), dot(after, after).sqrt());+ if !(la > 0.0) || (lb > 0.0 && dot(before, after) < MIN_TURN_COS * lb * la) {+ return false;+ }+ }+ for t in &s.shared {+ if let Some(a) = self.tri_alive.get_mut(*t as usize) {+ *a = false;+ }+ self.live_triangles = self.live_triangles.saturating_sub(1);+ }+ let mut list = self.around.get_mut(u as usize).map(std::mem::take).unwrap_or_default();+ let tri_alive = &self.tri_alive;+ list.retain(|t| tri_alive.get(*t as usize).copied().unwrap_or(false));+ for &t in s.at_v.iter().filter(|t| !s.shared.contains(t)) {+ if let Some(tri) = self.tris.get_mut(t as usize) {+ for i in tri.iter_mut() {+ if *i == v {+ *i = u;+ }+ }+ list.push(t);+ }+ }+ if let Some(slot) = self.around.get_mut(u as usize) {+ *slot = list;+ }+ if let Some(slot) = self.around.get_mut(v as usize) {+ *slot = Vec::new();+ }+ let qv = self.quadric.get(v as usize).copied().unwrap_or_default();+ if let Some(q) = self.quadric.get_mut(u as usize) {+ q.add(&qv);+ }+ if let Some(x) = self.pos.get_mut(u as usize) {+ *x = p;+ }+ if let Some(a) = self.alive.get_mut(v as usize) {+ *a = false;+ }+ for i in [u, v] {+ if let Some(stamp) = self.stamp.get_mut(i as usize) {+ *stamp = stamp.wrapping_add(1);+ }+ }+ true+ }++ /// Cost again every edge at `u` (it moved).+ fn reoffer(&mut self, u: u32) {+ let mut around = std::mem::take(&mut self.scratch.nu);+ self.neighbours(u, &mut around);+ for &w in &around {+ self.offer(u.min(w), u.max(w));+ }+ self.scratch.nu = around;+ }++ /// The mesh as it is now, and an original triangle each of its vertices came from.+ fn level(&self) -> (Level, Vec<u32>) {+ let mut index: Vec<Option<u32>> = vec![None; self.pos.len()];+ let mut out = Level::default();+ let mut seeds = Vec::new();+ out.triangles.reserve(self.live_triangles);+ for (t, alive) in self.tris.iter().zip(&self.tri_alive) {+ if !alive {+ continue;+ }+ let mut tri = [0u32; 3];+ for (k, &i) in t.iter().enumerate() {+ let Some(slot) = index.get_mut(i as usize) else { continue };+ tri[k] = *slot.get_or_insert_with(|| {+ let p = self.pos.get(i as usize).copied().unwrap_or_default();+ out.positions.push(Vec3::new(p[0], p[1], p[2]));+ seeds.push(self.seed.get(i as usize).copied().unwrap_or(0));+ u32::try_from(out.positions.len() - 1).unwrap_or(u32::MAX)+ });+ }+ out.triangles.push(tri);+ }+ (out, seeds)+ }+}++#[cfg(test)]+#[path = "simplify_tests.rs"]+mod tests;diff --git a/crates/geom/src/simplify_tests.rs b/crates/geom/src/simplify_tests.rsnew file mode 100644index 0000000000..dcb5898834--- /dev/null+++ b/crates/geom/src/simplify_tests.rs@@ -0,0 +1,158 @@+use super::*;++/// A sphere of radius `r` as a scan reads it: `n` × 2`n` quads, each triangle's corners its own+/// points (the same position repeated where triangles meet).+fn sphere(r: f64, n: u32) -> (Vec<Vec3>, Vec<[u32; 3]>) {+ let at = |i: u32, j: u32| {+ let (t, p) = (std::f64::consts::PI * f64::from(i) / f64::from(n), std::f64::consts::TAU * f64::from(j) / f64::from(2 * n));+ let (st, ct, sp, cp) = (t.sin(), t.cos(), p.sin(), p.cos());+ // The poles exactly, and the seam the same as the start, so corners weld.+ let (st, sp, cp) = (if i == 0 || i == n { 0.0 } else { st }, if j == 2 * n { 0.0 } else { sp }, if j == 2 * n { 1.0 } else { cp });+ Vec3::new(r * st * cp, r * st * sp, r * ct)+ };+ let (mut pos, mut tris) = (Vec::new(), Vec::new());+ let mut tri = |a: Vec3, b: Vec3, c: Vec3| {+ let k = pos.len() as u32;+ pos.extend([a, b, c]);+ tris.push([k, k + 1, k + 2]);+ };+ for i in 0..n {+ for j in 0..2 * n {+ let (a, b, c, d) = (at(i, j), at(i + 1, j), at(i + 1, j + 1), at(i, j + 1));+ if i > 0 {+ tri(a, c, d);+ }+ if i + 1 < n {+ tri(a, b, c);+ }+ }+ }+ (pos, tris)+}++fn volume(l: &Level) -> f64 {+ l.triangles+ .iter()+ .map(|t| {+ let [a, b, c] = t.map(|i| l.positions[i as usize]);+ a.dot(b.cross(c)) / 6.0+ })+ .sum()+}++/// Each side of a closed surface is shared by exactly two triangles, once each way.+fn closed(l: &Level) -> bool {+ let mut sides: Vec<(u32, u32)> = l.triangles.iter().flat_map(|t| [(t[0], t[1]), (t[1], t[2]), (t[2], t[0])]).collect();+ sides.sort_unstable();+ let n = sides.len();+ sides.dedup();+ sides.len() == n && sides.iter().all(|(a, b)| sides.binary_search(&(*b, *a)).is_ok())+}++/// A finely meshed sphere comes down to each target, closed, with its volume and shape kept+/// within the error each level reports, and the errors grow as the levels coarsen.+#[test]+fn a_sphere_comes_down_to_each_target_within_its_error() {+ let (pos, tris) = sphere(50.0, 100);+ let full = tris.len();+ let made = levels(&pos, &tris, &[full / 4, full / 16, full / 64]);+ assert_eq!(made.len(), 3);+ let exact = 4.0 / 3.0 * std::f64::consts::PI * 50.0f64.powi(3);+ let mut last = 0.0;+ for (l, target) in made.iter().zip([full / 4, full / 16, full / 64]) {+ assert!(l.triangles.len() <= target, "{} > {target}", l.triangles.len());+ assert!(closed(l), "closed and consistently wound");+ assert!(l.error >= last, "the error grows: {} after {last}", l.error);+ last = l.error;+ // Each point within the error of the sphere (its faces' planes lie within their sag of it).+ let sag = 50.0 * (1.0 - (std::f64::consts::PI / 100.0).cos());+ for p in &l.positions {+ assert!((p.len() - 50.0).abs() <= l.error + sag + 1e-9, "{} from the centre, error {}", p.len(), l.error);+ }+ assert!((volume(l) - exact).abs() < exact * 0.02, "volume {} vs {exact}", volume(l));+ // A 600-triangle sphere of radius 50 bows in by about 0.4 at its triangles' centres at+ // best; finer levels a fraction of that.+ assert!(l.error < 1.0, "error {}", l.error);+ }+ // The same mesh simplifies the same way.+ let again = levels(&pos, &tris, &[full / 4, full / 16, full / 64]);+ assert!(made.iter().zip(&again).all(|(a, b)| a.triangles == b.triangles && a.positions == b.positions));+}++/// A flat sheet comes down to a few triangles with no error, and its open outline stays put.+#[test]+fn a_flat_sheet_keeps_its_outline() {+ let n = 40u32;+ let at = |i: u32, j: u32| Vec3::new(f64::from(i), f64::from(j) * 0.5, 0.0);+ let (mut pos, mut tris) = (Vec::new(), Vec::new());+ for i in 0..n {+ for j in 0..n {+ for t in [[at(i, j), at(i + 1, j), at(i + 1, j + 1)], [at(i, j), at(i + 1, j + 1), at(i, j + 1)]] {+ let k = pos.len() as u32;+ pos.extend(t);+ tris.push([k, k + 1, k + 2]);+ }+ }+ }+ let made = levels(&pos, &tris, &[tris.len() / 16]);+ let l = made.first().unwrap();+ assert!(l.triangles.len() <= tris.len() / 16);+ assert!(l.error < 1e-6, "flat: {}", l.error);+ assert!(l.positions.iter().all(|p| p.z.abs() < 1e-9));+ let b = l.positions.iter().fold(crate::Aabb3::EMPTY, |mut b, p| {+ b.add(*p);+ b+ });+ assert!(b.min.dist(Vec3::ZERO) < 1e-9 && b.max.dist(Vec3::new(40.0, 20.0, 0.0)) < 1e-9, "{b:?}");+ let area: f64 = l+ .triangles+ .iter()+ .map(|t| {+ let [a, b, c] = t.map(|i| l.positions[i as usize]);+ (b - a).cross(c - a).len() / 2.0+ })+ .sum();+ assert!((area - 800.0).abs() < 1e-6, "the sheet is still whole: {area}");+}++/// Input from a file is hostile: points that are not finite, indices out of range, triangles+/// with a repeated corner and empty meshes are left out, never a panic.+#[test]+fn hostile_meshes_never_panic() {+ let p = |x: f64, y: f64| Vec3::new(x, y, 0.0);+ assert!(levels(&[], &[], &[1]).is_empty());+ assert!(levels(&[p(0.0, 0.0)], &[[0, 0, 0]], &[1]).is_empty());+ assert!(levels(&[p(f64::NAN, 0.0), p(1.0, 0.0), p(0.0, 1.0)], &[[0, 1, 2]], &[0]).is_empty());+ assert!(levels(&[p(0.0, 0.0), p(1.0, 0.0), p(0.0, 1.0)], &[[0, 1, 99]], &[0]).is_empty());+ let (pos, mut tris) = sphere(5.0, 12);+ tris.push([0, 1, u32::MAX]);+ tris.push([2, 2, 3]);+ let made = levels(&pos, &tris, &[usize::MAX, 100, 0]);+ assert!(made.iter().all(|l| l.triangles.iter().flatten().all(|i| (*i as usize) < l.positions.len())));+}++/// Timing, not a check (`SOLIDCRAFT_BENCH_STL=part.stl cargo test --release -p solidcraft-geom+/// --lib simplify_timing -- --ignored --nocapture`): the levels of a binary STL.+#[test]+#[ignore]+fn simplify_timing() {+ let Some(path) = std::env::var_os("SOLIDCRAFT_BENCH_STL") else { return };+ let bytes = std::fs::read(path).unwrap();+ let n = u32::from_le_bytes(bytes[80..84].try_into().unwrap()) as usize;+ let f = |o: usize| f64::from(f32::from_le_bytes(bytes[o..o + 4].try_into().unwrap()));+ let (mut pos, mut tris) = (Vec::with_capacity(n * 3), Vec::with_capacity(n));+ for t in 0..n {+ let o = 84 + t * 50 + 12;+ let k = pos.len() as u32;+ for v in 0..3 {+ pos.push(Vec3::new(f(o + v * 12), f(o + v * 12 + 4), f(o + v * 12 + 8)));+ }+ tris.push([k, k + 1, k + 2]);+ }+ let started = std::time::Instant::now();+ let made = levels(&pos, &tris, &[n / 4, n / 16, n / 64]);+ eprintln!("{n} triangles: levels in {:.2} s", started.elapsed().as_secs_f64());+ for l in &made {+ eprintln!(" {} triangles, error {:.3} mm", l.triangles.len(), l.error);+ }+}diff --git a/crates/gpu/src/view.rs b/crates/gpu/src/view.rsindex e7798a73f1..6b96e5fd86 100644--- a/crates/gpu/src/view.rs+++ b/crates/gpu/src/view.rs@@ -15,6 +15,7 @@ use wgpu::util::DeviceExt;use crate::pbr;mod ao;+mod oit;/// Triangle vertex: position (3 × f32), normal (3 × f32), sRGB colour (4 × u8).pub const TRI_SIZE: usize = 28;@@ -121,6 +122,29 @@ impl SharedTris {out}+ /// A simplified copy of a mesh ([`solidcraft_geom::simplify::Level`]): its vertices already+ /// shared, its triangles lit flat (each fragment with its triangle's own normal).+ pub fn from_level(level: &solidcraft_geom::simplify::Level) -> SharedTris {+ let mut out = SharedTris { flat: true, ..Default::default() };+ out.vertices.reserve_exact(level.positions.len() * SHARED_SIZE);+ let mut lo = [f32::INFINITY; 3];+ let mut hi = [f32::NEG_INFINITY; 3];+ for p in &level.positions {+ let p = p.to_f32();+ for k in 0..3 {+ lo[k] = lo[k].min(p[k]);+ hi[k] = hi[k].max(p[k]);+ }+ for v in p.iter().chain(&[0.0f32; 3]) {+ out.vertices.extend_from_slice(&v.to_le_bytes());+ }+ }+ let n = u32::try_from(level.positions.len()).unwrap_or(u32::MAX);+ out.indices = level.triangles.iter().filter(|t| t.iter().all(|i| *i < n)).flatten().copied().collect();+ out.bounds = [lo, hi];+ out+ }+/// Vertex `i`: position and normal.fn vertex(&self, i: u32) -> ([f32; 3], [f32; 3]) {let at = i as usize * SHARED_SIZE;@@ -160,6 +184,18 @@ impl SharedTris {}}+/// How an [`InstancedMesh`]'s placements are drawn: opaque, or see-through (their colour's alpha)+/// as faded context (another component active) or as glass (an appearance's opacity).+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]+pub enum InstanceLook {+ #[default]+ Opaque,+ /// With the translucent triangles ([`GpuScene::trans`]): no depth written.+ Faded,+ /// With the see-through bodies ([`GpuScene::glass`]): far sides, then near sides.+ Glass,+}+/// Triangles drawn at several places: a part placed by many occurrences keeps one copy of its/// triangles on the GPU, drawn once per placement, however often it is placed.#[derive(Clone)]@@ -171,6 +207,12 @@ pub struct InstancedMesh {pub tris: Arc<SharedTris>,/// The placements, [`INSTANCE_SIZE`] bytes each ([`InstancedMesh::place`]).pub instances: Vec<u8>,+ /// How its placements are drawn (see-through ones are drawn back to front).+ pub look: InstanceLook,+ /// Coarser copies of the triangles, finest first, each with how far it strays from them (mm,+ /// in the part's frame): a placement small on screen is drawn from the coarsest whose error+ /// stays under [`LOD_PX`] there ([`Batches::cull`]).+ pub levels: Vec<(Arc<SharedTris>, f32)>,}impl InstancedMesh {@@ -262,7 +304,11 @@ impl GpuScene {out.hidden.extend_from_slice(&block.bytes.hidden);}for m in std::mem::take(&mut self.instanced) {- m.expand_into(&mut out.tris);+ match m.look {+ InstanceLook::Opaque => m.expand_into(&mut out.tris),+ InstanceLook::Faded => m.expand_into(&mut out.trans),+ InstanceLook::Glass => m.expand_into(&mut out.glass),+ }}out.tris.append(&mut self.tris);out.trans.append(&mut self.trans);@@ -588,6 +634,61 @@ impl SharedGpu {}}+/// How far (pixels) a level of detail may stray from the full triangles where a placement is+/// drawn from it.+pub const LOD_PX: f32 = 0.75;++/// Pixels per millimetre where a placement (`rows`, see [`INSTANCE_SIZE`]) of a box (`bounds`)+/// is nearest the eye, along whichever of its axes shows largest, in the view `vp` (columns) of+/// `size` pixels. Infinite when a corner of it is at or behind the eye, or for a box that is not+/// finite: such a placement is drawn in full.+pub fn placement_scale(rows: &[[f32; 4]; 3], bounds: &[[f32; 3]; 2], vp: &[[f32; 4]; 4], size: [f32; 2]) -> f32 {+ let [lo, hi] = bounds;+ if !lo.iter().chain(hi).all(|x| x.is_finite()) {+ return f32::INFINITY;+ }+ let clip = |p: [f32; 3]| -> [f32; 4] {+ let w = rows.map(|r| r[0] * p[0] + r[1] * p[1] + r[2] * p[2] + r[3]);+ std::array::from_fn(|k| vp[0][k] * w[0] + vp[1][k] * w[1] + vp[2][k] * w[2] + vp[3][k])+ };+ let corners: [[f32; 3]; 8] = std::array::from_fn(|i| {+ [if i & 1 == 0 { lo[0] } else { hi[0] }, if i & 2 == 0 { lo[1] } else { hi[1] }, if i & 4 == 0 { lo[2] } else { hi[2] }]+ });+ let mut nearest = (f32::INFINITY, corners[0]);+ for c in corners {+ let w = clip(c)[3];+ if !(w > 1e-6) {+ return f32::INFINITY;+ }+ if w < nearest.0 {+ nearest = (w, c);+ }+ }+ let screen = |c: [f32; 4]| [c[0] / c[3] * size[0] * 0.5, c[1] / c[3] * size[1] * 0.5];+ let (_, c) = nearest;+ let at = screen(clip(c));+ let mut scale = 0.0f32;+ for k in 0..3 {+ // A step of a hundredth of the box (at least a micrometre) along each axis.+ let step = ((hi[k] - lo[k]) * 0.01).max(1e-3);+ let mut q = c;+ q[k] += step;+ let qc = clip(q);+ if !(qc[3] > 1e-6) {+ return f32::INFINITY;+ }+ let s = screen(qc);+ scale = scale.max(((s[0] - at[0]).powi(2) + (s[1] - at[1]).powi(2)).sqrt() / step);+ }+ if scale.is_finite() { scale } else { f32::INFINITY }+}++/// The coarsest level whose error (mm; level 0, the full triangles, has none) stays under+/// [`LOD_PX`] at `scale` pixels per millimetre.+pub fn level_for(errors: &[f32], scale: f32) -> usize {+ errors.iter().rposition(|e| *e * scale <= LOD_PX).unwrap_or(0)+}+/// Whether a box (`bounds`, min and max) moved by a placement (`rows`, see [`INSTANCE_SIZE`])/// may be seen in the view `vp` (the view-projection, columns, depth 0 near and 1 far): `false`/// only when all its corners lie beyond the same side of the view (left, right, top, bottom,@@ -612,23 +713,43 @@ pub fn placed_box_in_view(rows: &[[f32; 4]; 3], bounds: &[[f32; 3]; 2], vp: &[[f!out.iter().any(|o| *o)}-/// An [`InstancedMesh`] on the GPU: its triangles (shared with the next scene while its key-/// comes back) and the placements in view.-struct InstancedDraw {+/// One level of an [`InstancedDraw`]: its triangles and the placements drawn from it.+struct LevelDraw {tris: Arc<SharedGpu>,flat: bool,+ /// How far it strays from the full triangles (mm; 0 for them).+ error: f32,+ /// The placements drawn from it, first `count` of them ([`Batches::cull`]).+ instances: wgpu::Buffer,+ count: u32,+}++/// An [`InstancedMesh`] on the GPU: its triangles and coarser levels (shared with the next scene+/// while they come back), and the placements in view, each drawn from its level.+struct InstancedDraw {+ look: InstanceLook,+ /// The full triangles first, then coarser ones.+ levels: Vec<LevelDraw>,bounds: [[f32; 3]; 2],/// Every placement ([`INSTANCE_SIZE`] bytes each), as the scene has them.placements: Vec<u8>,- /// The placements in view, first `count` of them ([`Batches::cull`]).- instances: wgpu::Buffer,- count: u32,- /// Which placements `instances` holds now (none drawn yet: `None`).- shown: Option<Vec<u32>>,+ /// Which placements the levels hold now, with their level (none drawn yet: `None`).+ shown: Option<Vec<(u32, u8)>>,}impl InstancedDraw {- /// Draw every placement with `pipeline` (the placements in vertex buffer 1).+ /// Draw every placement in view, from its level, with `smooth` or `flat` as the level's+ /// triangles are lit.+ pub(crate) fn draw(&self, pass: &mut wgpu::RenderPass<'_>, smooth: &wgpu::RenderPipeline, flat: &wgpu::RenderPipeline) {+ for level in &self.levels {+ pass.set_pipeline(if level.flat { flat } else { smooth });+ level.draw(pass);+ }+ }+}++impl LevelDraw {+ /// Draw its placements (in vertex buffer 1).fn draw(&self, pass: &mut wgpu::RenderPass<'_>) {if self.count == 0 {return;@@ -696,9 +817,9 @@ struct Batches {guide_lines: Option<Batch>,planned: Vec<PlannedDraw>,instanced: Vec<InstancedDraw>,- /// The instanced meshes' triangles on the GPU by key, with the triangles they were uploaded- /// from.- instanced_tris: std::collections::HashMap<u64, (Arc<SharedTris>, Arc<SharedGpu>)>,+ /// The instanced meshes' triangles (and their levels) on the GPU, by the address of the+ /// triangles they were uploaded from (held, so it stays theirs).+ instanced_tris: std::collections::HashMap<usize, (Arc<SharedTris>, Arc<SharedGpu>)>,/// Evaluated chunks by their plans' addresses, holding the plans so the addresses stay/// theirs: a chunk whose plans are unchanged is not evaluated again when the scene is rebuilt.resident: std::collections::HashMap<Vec<usize>, (Vec<Arc<solidcraft_geom::tess::TessPlan>>, Arc<crate::GpuMesh>)>,@@ -765,21 +886,30 @@ impl Batches {if count == 0 {continue;}- let tris = match kept.remove(&m.key).or_else(|| self.instanced_tris.remove(&m.key)).filter(|(b, _)| Arc::ptr_eq(b, &m.tris)) {- Some(t) => t,- None => match SharedGpu::new(device, &m.tris) {- Some(g) => (m.tris.clone(), Arc::new(g)),- None => continue,- },- };let placements = m.instances.get(..count as usize * INSTANCE_SIZE).unwrap_or_default().to_vec();- let instances = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {- label: Some("sc_instances"),- contents: &placements,- usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,- });- out.push(InstancedDraw { tris: tris.1.clone(), flat: m.tris.flat, bounds: m.tris.bounds, placements, instances, count, shown: None });- self.instanced_tris.insert(m.key, tris);+ let mut levels = Vec::with_capacity(1 + m.levels.len());+ for (i, (tris, error)) in std::iter::once((&m.tris, 0.0f32)).chain(m.levels.iter().map(|(t, e)| (t, *e))).enumerate() {+ let key = Arc::as_ptr(tris) as usize;+ 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)),+ None => continue,+ },+ };+ // Until the first cull, every placement is drawn in full.+ let instances = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {+ label: Some("sc_instances"),+ contents: &placements,+ usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,+ });+ 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);+ }+ if !levels.is_empty() {+ out.push(InstancedDraw { look: m.look, levels, bounds: m.tris.bounds, placements, shown: None });+ }}out}@@ -787,34 +917,57 @@ impl Batches {/// Keep only the placements of the instanced meshes that may be seen in the view `vp` (see/// [`placed_box_in_view`]): a part placed many times, most of it out of the view, draws/// only what is in it. The placements are written again only when that set changes.- fn cull(&mut self, queue: &wgpu::Queue, vp: &[[f32; 4]; 4]) {+ /// Each placement's level of detail is chosen here too: the coarsest whose error stays under+ /// [`LOD_PX`] where it is drawn ([`placement_scale`], [`level_for`]), in a view of `size`+ /// pixels.+ fn cull(&mut self, queue: &wgpu::Queue, vp: &[[f32; 4]; 4], size: [f32; 2]) {let f = |b: &[u8], i: usize| b.get(i..i + 4).and_then(|x| x.try_into().ok()).map_or(0.0, f32::from_le_bytes);for d in &mut self.instanced {- let shown: Vec<u32> = d+ let errors: Vec<f32> = d.levels.iter().map(|l| l.error).collect();+ let mut shown: Vec<(u32, u8)> = d.placements.as_chunks::<INSTANCE_SIZE>().0.iter().enumerate()- .filter(|(_, p)| {+ .filter_map(|(i, p)| {let rows = [0, 1, 2].map(|r| [f(&p[..], 16 * r), f(&p[..], 16 * r + 4), f(&p[..], 16 * r + 8), f(&p[..], 16 * r + 12)]);- placed_box_in_view(&rows, &d.bounds, vp)+ placed_box_in_view(&rows, &d.bounds, vp).then(|| {+ let level = if errors.len() > 1 { level_for(&errors, placement_scale(&rows, &d.bounds, vp, size)) } else { 0 };+ (i as u32, u8::try_from(level).unwrap_or(0))+ })})- .map(|(i, _)| i as u32).collect();+ // See-through placements back to front (by their box's centre), so each blends over+ // what lies behind it.+ if d.look != InstanceLook::Opaque {+ let depth = |i: u32| {+ let p = d.placements.get(i as usize * INSTANCE_SIZE..(i as usize + 1) * INSTANCE_SIZE).unwrap_or_default();+ let rows = [0, 1, 2].map(|r| [f(p, 16 * r), f(p, 16 * r + 4), f(p, 16 * r + 8), f(p, 16 * r + 12)]);+ let [lo, hi] = d.bounds;+ let c = [0, 1, 2].map(|k| (lo[k] + hi[k]) * 0.5);+ let w = rows.map(|r| r[0] * c[0] + r[1] * c[1] + r[2] * c[2] + r[3]);+ let clip: [f32; 4] = std::array::from_fn(|k| vp[0][k] * w[0] + vp[1][k] * w[1] + vp[2][k] * w[2] + vp[3][k]);+ if clip[3].abs() > 1e-12 { clip[2] / clip[3] } else { f32::INFINITY }+ };+ shown.sort_by(|a, b| depth(b.0).total_cmp(&depth(a.0)).then(a.0.cmp(&b.0)));+ }if d.shown.as_ref() == Some(&shown) {continue;}- let bytes: Vec<u8> = shown- .iter()- .filter_map(|i| d.placements.get(*i as usize * INSTANCE_SIZE..(*i as usize + 1) * INSTANCE_SIZE))- .flatten()- .copied()- .collect();- if !bytes.is_empty() {- queue.write_buffer(&d.instances, 0, &bytes);+ for (k, level) in d.levels.iter_mut().enumerate() {+ let bytes: Vec<u8> = shown+ .iter()+ .filter(|(_, l)| usize::from(*l) == k)+ .filter_map(|(i, _)| d.placements.get(*i as usize * INSTANCE_SIZE..(*i as usize + 1) * INSTANCE_SIZE))+ .flatten()+ .copied()+ .collect();+ if !bytes.is_empty() {+ queue.write_buffer(&level.instances, 0, &bytes);+ }+ level.count = u32::try_from(bytes.len() / INSTANCE_SIZE).unwrap_or(u32::MAX);}- d.count = u32::try_from(shown.len()).unwrap_or(u32::MAX);d.shown = Some(shown);}}@@ -900,6 +1053,10 @@ pub struct Renderer {tri_cut_instanced: Option<(wgpu::RenderPipeline, wgpu::RenderPipeline)>,/// `tri_instanced` and `tri_cut_instanced` for flat triangles.tri_instanced_flat: wgpu::RenderPipeline,+ /// `glass_far`, `glass_near` and `trans` for instanced meshes, smooth and flat.+ glass_far_instanced: (wgpu::RenderPipeline, wgpu::RenderPipeline),+ glass_near_instanced: (wgpu::RenderPipeline, wgpu::RenderPipeline),+ trans_instanced: (wgpu::RenderPipeline, wgpu::RenderPipeline),tri_cut_instanced_flat: Option<(wgpu::RenderPipeline, wgpu::RenderPipeline)>,/// The tessellation compute pipeline, where the device runs compute shaders.tess: Option<crate::TessGpu>,@@ -949,6 +1106,15 @@ pub struct Renderer {max_texture: u32,/// Supersampling (#1288): the filter that draws the supersampled frame into the viewport.ss_blit: wgpu::RenderPipeline,+ /// The frame drawn offscreen at the viewport's own size (for the see-through surfaces' order-+ /// independent transparency), copied as it is.+ copy_blit: wgpu::RenderPipeline,+ /// The offscreen frame is not at the viewport's size: filtered ([`Renderer::ss_blit`]).+ ss_scaled: bool,+ /// Order-independent transparency for the model's see-through surfaces (`None` where the+ /// device cannot blend into float targets: they are sorted instead), and its targets.+ oit: Option<oit::Pipelines>,+ oit_targets: Option<oit::Targets>,ss_bgl: wgpu::BindGroupLayout,/// The supersampled frame's textures, kept while its size stays.ss: Option<Supersampled>,@@ -1023,6 +1189,11 @@ fn vs(@builtin(vertex_index) i: u32) -> O {o.uv = vec2<f32>(x, y);return o;}+/// The frame as it is (drawn at the viewport's own size).+@fragment+fn fs_copy(i: O) -> @location(0) vec4<f32> {+ return textureSampleLevel(src, smp, i.uv, 0.0);+}@fragmentfn fs(i: O) -> @location(0) vec4<f32> {let d = vec2<f32>(dpdx(i.uv.x), dpdy(i.uv.y)) * 0.25;@@ -1293,6 +1464,37 @@ impl Renderer {cache: None,})};+ // See-through instanced meshes: blended, depth tested, not written; `cull` for glass.+ let placed_see_through = [Some(shared_layout()), Some(instance_layout())];+ let see_through = |label: &str, source: TriSource, cull: Option<wgpu::Face>| {+ device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {+ label: Some(label),+ layout: Some(&layout),+ vertex: wgpu::VertexState {+ module: &module,+ entry_point: Some(source.entry()),+ buffers: &placed_see_through,+ compilation_options: Default::default(),+ },+ primitive: wgpu::PrimitiveState { topology: wgpu::PrimitiveTopology::TriangleList, cull_mode: cull, ..Default::default() },+ depth_stencil: depth(wgpu::CompareFunction::LessEqual, false),+ multisample: wgpu::MultisampleState { count: t.samples.max(1), mask: !0, alpha_to_coverage_enabled: false },+ fragment: Some(wgpu::FragmentState {+ module: &module,+ entry_point: Some(&source.fragment("fs_tri")),+ targets: &[Some(wgpu::ColorTargetState { format: t.format, blend: alpha, write_mask: wgpu::ColorWrites::ALL })],+ compilation_options: Default::default(),+ }),+ multiview_mask: None,+ cache: None,+ })+ };+ let both = |label: &str, cull: Option<wgpu::Face>| {+ (see_through(label, TriSource::Instanced, cull), see_through(&format!("{label}_flat"), TriSource::InstancedFlat, cull))+ };+ let glass_far_instanced = both("sc_glass_far_instanced", Some(wgpu::Face::Front));+ let glass_near_instanced = both("sc_glass_near_instanced", Some(wgpu::Face::Back));+ let trans_instanced = both("sc_trans_instanced", None);let image_bgl = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {label: Some("sc_image"),entries: &[@@ -1460,26 +1662,30 @@ impl Renderer {});// The frame is premultiplied (drawn over transparent black), so it goes over the// viewport's background premultiplied; the viewport's depth is left as it is.- let ss_blit = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {- label: Some("sc_ssaa"),- layout: Some(&ss_layout),- vertex: wgpu::VertexState { module: &ss_module, entry_point: Some("vs"), buffers: &[], compilation_options: Default::default() },- primitive: wgpu::PrimitiveState { topology: wgpu::PrimitiveTopology::TriangleList, ..Default::default() },- depth_stencil: depth(wgpu::CompareFunction::Always, false),- multisample: wgpu::MultisampleState { count: t.samples.max(1), mask: !0, alpha_to_coverage_enabled: false },- fragment: Some(wgpu::FragmentState {- module: &ss_module,- entry_point: Some("fs"),- targets: &[Some(wgpu::ColorTargetState {- format: t.format,- blend: Some(wgpu::BlendState::PREMULTIPLIED_ALPHA_BLENDING),- write_mask: wgpu::ColorWrites::ALL,- })],- compilation_options: Default::default(),- }),- multiview_mask: None,- cache: None,- });+ let blit = |entry: &str| {+ device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {+ label: Some("sc_ssaa"),+ layout: Some(&ss_layout),+ vertex: wgpu::VertexState { module: &ss_module, entry_point: Some("vs"), buffers: &[], compilation_options: Default::default() },+ primitive: wgpu::PrimitiveState { topology: wgpu::PrimitiveTopology::TriangleList, ..Default::default() },+ depth_stencil: depth(wgpu::CompareFunction::Always, false),+ multisample: wgpu::MultisampleState { count: t.samples.max(1), mask: !0, alpha_to_coverage_enabled: false },+ fragment: Some(wgpu::FragmentState {+ module: &ss_module,+ entry_point: Some(entry),+ targets: &[Some(wgpu::ColorTargetState {+ format: t.format,+ blend: Some(wgpu::BlendState::PREMULTIPLIED_ALPHA_BLENDING),+ write_mask: wgpu::ColorWrites::ALL,+ })],+ compilation_options: Default::default(),+ }),+ multiview_mask: None,+ cache: None,+ })+ };+ let (ss_blit, copy_blit) = (blit("fs"), blit("fs_copy"));+ let oit = oit::Pipelines::new(device, &module, &layout, t.format, t.depth, t.samples);let depth_reset = t.depth.filter(|_| reversed).map(|format| {let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {label: Some("sc_depth_reset"),@@ -1519,6 +1725,10 @@ impl Renderer {target: t,max_texture: device.limits().max_texture_dimension_2d,ss_blit,+ copy_blit,+ ss_scaled: false,+ oit,+ oit_targets: None,ss_bgl,ss: None,ss_ready: false,@@ -1541,6 +1751,9 @@ impl Renderer {TriSource::InstancedFlat,),tri_cut_instanced_flat: cut(TriSource::InstancedFlat),+ glass_far_instanced,+ glass_near_instanced,+ trans_instanced,tess,access_bgl,access_bind,@@ -1652,6 +1865,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)+ }+/// Re-sort the glass for a new view direction (when it turned more than about 2 degrees).fn sort_glass(&mut self, queue: &wgpu::Queue, back: [f32; 3]) {let (Some(g), false) = (&self.glass, self.glass_cpu.is_empty()) else { return };@@ -1714,8 +1932,13 @@ impl Renderer {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.sort_glass(queue, cb.back);- res.model.cull(queue, &cb.view_proj);+ // 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();+ if !see_through {+ res.model.sort_glass(queue, cb.back);+ }+ res.model.cull(queue, &cb.view_proj, cb.size_px);queue.write_buffer(&res.uniform, 0, &uniform_bytes(cb, cb.size_px[0], cb.size_px[1], res.linear_out, res.target.reversed_depth()));if let Some(a) = &cb.access&& a.version != res.access_version@@ -1773,7 +1996,7 @@ impl Renderer {res.quads.push((img.id, b));}}- res.ss_ready = cb.ssaa != 1.0 && res.supersample(device, encoder, cb);+ res.ss_ready = (cb.ssaa != 1.0 || see_through) && res.supersample(device, encoder, cb, see_through);}/// Draw the frame into `pass` within `viewport` (x, y, width, height in physical pixels):@@ -1787,7 +2010,7 @@ impl Renderer {if self.ss_ready&& let Some(ss) = &self.ss{- pass.set_pipeline(&self.ss_blit);+ pass.set_pipeline(if self.ss_scaled { &self.ss_blit } else { &self.copy_blit });pass.set_bind_group(0, &ss.bind, &[]);pass.draw(0..3, 0..1);return;@@ -1796,7 +2019,7 @@ impl Renderer {pass.set_pipeline(reset);pass.draw(0..3, 0..1);}- self.draw(frame, pass);+ self.draw(frame, pass, Phase::All);}/// The target the pipelines draw into.@@ -1807,7 +2030,7 @@ impl Renderer {impl Renderer {/// Draw the frame's scenes into `pass` (its viewport already set).- fn draw(&self, cb: &Frame, pass: &mut wgpu::RenderPass<'static>) {+ fn draw(&self, cb: &Frame, pass: &mut wgpu::RenderPass<'static>, phase: Phase) {let res = self;pass.set_bind_group(0, &res.bind, &[]);let tris = |pass: &mut wgpu::RenderPass<'static>, p: &wgpu::RenderPipeline, b: &Option<Batch>| {@@ -1835,6 +2058,12 @@ impl Renderer {} else {(&res.model, &res.sketch, &res.highlight, &res.preview)};+ 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;+ }lines(pass, &res.overlay, &m.under);lines(pass, &res.overlay, &sk.under);pass.set_bind_group(1, &res.access_bind, &[]);@@ -1850,9 +2079,8 @@ impl Renderer {};// Instanced meshes, with the pipeline for smooth and for flat triangles.let instanced = |pass: &mut wgpu::RenderPass<'static>, smooth: &wgpu::RenderPipeline, flat: &wgpu::RenderPipeline| {- for d in &m.instanced {- pass.set_pipeline(if d.flat { flat } else { smooth });- d.draw(pass);+ for d in m.instanced.iter().filter(|d| d.look == InstanceLook::Opaque) {+ d.draw(pass, smooth, flat);}};let sectioned = cb.clip[..3].iter().map(|c| c * c).sum::<f32>() > 0.25;@@ -1900,9 +2128,37 @@ impl Renderer {}}tris(pass, &res.ghost, &pv.ghost);+ if phase == Phase::BeforeSeeThrough {+ return;+ }+ // See-through instanced meshes (placements back to front) with the rest of their kind.+ let see_through =+ |pass: &mut wgpu::RenderPass<'static>, look: InstanceLook, (smooth, flat): &(wgpu::RenderPipeline, wgpu::RenderPipeline)| {+ for d in m.instanced.iter().filter(|d| d.look == look) {+ d.draw(pass, smooth, flat);+ }+ };tris(pass, &res.glass_far, &m.glass);+ see_through(pass, InstanceLook::Glass, &res.glass_far_instanced);tris(pass, &res.glass_near, &m.glass);+ see_through(pass, InstanceLook::Glass, &res.glass_near_instanced);tris(pass, &res.trans, &m.trans);+ see_through(pass, InstanceLook::Faded, &res.trans_instanced);+ Self::draw_over(res, pass, sk, h, pv, m, &tris, &lines);+ }++ /// What is drawn over the model's see-through surfaces.+ #[allow(clippy::too_many_arguments)]+ fn draw_over(+ res: &Renderer,+ pass: &mut wgpu::RenderPass<'static>,+ sk: &Batches,+ h: &Batches,+ pv: &Batches,+ m: &Batches,+ tris: &dyn Fn(&mut wgpu::RenderPass<'static>, &wgpu::RenderPipeline, &Option<Batch>),+ lines: &dyn Fn(&mut wgpu::RenderPass<'static>, &wgpu::RenderPipeline, &Option<Batch>),+ ) {tris(pass, &res.trans, &sk.trans);tris(pass, &res.trans, &h.trans);tris(pass, &res.guide_trans, &h.guide_trans);@@ -1912,48 +2168,94 @@ impl Renderer {lines(pass, &res.overlay, &sk.overlays);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) {+ let m = &self.model;+ pass.set_bind_group(0, &self.bind, &[]);+ pass.set_pipeline(&p.built);+ for batch in [&m.glass, &m.trans].into_iter().flatten() {+ for (buffer, count) in &batch.parts {+ pass.set_vertex_buffer(0, buffer.slice(..));+ pass.draw(0..*count, 0..1);+ }+ }+ for d in m.instanced.iter().filter(|d| d.look != InstanceLook::Opaque) {+ d.draw(pass, &p.instanced, &p.instanced_flat);+ }+ }}impl Renderer {/// Draw the frame supersampled (`cb.ssaa` times the viewport's pixels each way, within the/// device's texture limit and the memory budget) into textures of the viewport's kind./// `false` when it cannot be (too small a gain, a zero-sized viewport): drawn as usual.- fn supersample(&mut self, device: &wgpu::Device, encoder: &mut wgpu::CommandEncoder, cb: &Frame) -> bool {- let Some(size) = supersampled_size(cb.size_px, cb.ssaa, self.max_texture, self.target.samples) else {+ fn supersample(&mut self, device: &wgpu::Device, encoder: &mut wgpu::CommandEncoder, cb: &Frame, see_through: bool) -> bool {+ // Supersampled when asked (and worth it); else, for order-independent transparency, at+ // the viewport's own size.+ let own = || {+ let [w, h] = cb.size_px;+ (w >= 1.0 && h >= 1.0)+ .then(|| [(w.round() as u32).clamp(1, self.max_texture.max(1)), (h.round() as u32).clamp(1, self.max_texture.max(1))])+ };+ let scaled = if cb.ssaa != 1.0 { supersampled_size(cb.size_px, cb.ssaa, self.max_texture, self.target.samples) } else { None };+ let Some(size) = scaled.or_else(|| if see_through { own() } else { None }) else {self.ss = None;return false;};+ self.ss_scaled = scaled.is_some();if self.ss.as_ref().is_none_or(|ss| ss.size != size) {self.ss = Some(self.supersampled(device, size));}+ if see_through+ && let Some(p) = &self.oit+ && self.oit_targets.as_ref().is_none_or(|t| t.size != size)+ {+ self.oit_targets = Some(p.targets(device, size, self.target.samples));+ }let Some(ss) = &self.ss else { return false };let depth_format = self.target.depth;- let mut pass = encoder- .begin_render_pass(&wgpu::RenderPassDescriptor {- label: Some("sc_ssaa"),- color_attachments: &[Some(wgpu::RenderPassColorAttachment {- view: &ss.color,- depth_slice: None,- resolve_target: ss.resolve.as_ref(),- ops: wgpu::Operations { load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT), store: wgpu::StoreOp::Store },- })],- depth_stencil_attachment: ss.depth.as_ref().map(|view| wgpu::RenderPassDepthStencilAttachment {- view,- depth_ops: Some(wgpu::Operations {- load: wgpu::LoadOp::Clear(far_depth(self.target.reversed_depth())),- store: wgpu::StoreOp::Discard,+ let stencil = depth_format.is_some_and(|f| f.has_stencil_aspect());+ // The depth is kept for the passes after the first when there are see-through surfaces.+ let keep = if see_through { wgpu::StoreOp::Store } else { wgpu::StoreOp::Discard };+ let pass = |encoder: &mut wgpu::CommandEncoder, first: bool| {+ let load = |clear| if first { wgpu::LoadOp::Clear(clear) } else { wgpu::LoadOp::Load };+ encoder+ .begin_render_pass(&wgpu::RenderPassDescriptor {+ label: Some("sc_ssaa"),+ color_attachments: &[Some(wgpu::RenderPassColorAttachment {+ view: &ss.color,+ depth_slice: None,+ resolve_target: ss.resolve.as_ref(),+ ops: wgpu::Operations { load: load(wgpu::Color::TRANSPARENT), store: wgpu::StoreOp::Store },+ })],+ depth_stencil_attachment: ss.depth.as_ref().map(|view| wgpu::RenderPassDepthStencilAttachment {+ view,+ depth_ops: Some(wgpu::Operations { load: load_depth(first, far_depth(self.target.reversed_depth())), store: keep }),+ stencil_ops: stencil.then_some(wgpu::Operations { load: load_depth(first, 0), store: keep }),}),- stencil_ops: depth_format- .filter(|f| f.has_stencil_aspect())- .map(|_| wgpu::Operations { load: wgpu::LoadOp::Clear(0), store: wgpu::StoreOp::Discard }),- }),- timestamp_writes: None,- occlusion_query_set: None,- multiview_mask: None,- })- .forget_lifetime();- pass.set_viewport(0.0, 0.0, size[0] as f32, size[1] as f32, 0.0, 1.0);- self.draw(cb, &mut pass);+ timestamp_writes: None,+ occlusion_query_set: None,+ multiview_mask: None,+ })+ .forget_lifetime()+ };+ let (Some(p), Some(t), true) = (&self.oit, &self.oit_targets, see_through) else {+ let mut first = pass(encoder, true);+ first.set_viewport(0.0, 0.0, size[0] as f32, size[1] as f32, 0.0, 1.0);+ self.draw(cb, &mut first, Phase::All);+ return true;+ };+ {+ let mut first = pass(encoder, true);+ first.set_viewport(0.0, 0.0, size[0] as f32, size[1] as f32, 0.0, 1.0);+ self.draw(cb, &mut first, Phase::BeforeSeeThrough);+ }+ p.accumulate(encoder, t, ss.depth.as_ref(), stencil, |pass| self.draw_see_through(pass, p));+ p.composite(encoder, t, &ss.color, ss.resolve.as_ref());+ let mut over = pass(encoder, false);+ over.set_viewport(0.0, 0.0, size[0] as f32, size[1] as f32, 0.0, 1.0);+ self.draw(cb, &mut over, Phase::AfterSeeThrough);true}@@ -1994,6 +2296,22 @@ impl Renderer {}}+/// Which part of a frame [`Renderer::draw`] draws.+#[derive(Clone, Copy, PartialEq, Eq, Debug)]+enum Phase {+ /// All of it, the model's see-through surfaces sorted.+ All,+ /// Up to the model's see-through surfaces, which order-independent transparency draws.+ BeforeSeeThrough,+ /// What is drawn over them (sketch fills, highlights, X-ray, overlays).+ AfterSeeThrough,+}++/// A depth (or stencil) attachment's load: cleared to `clear` for the first pass, else kept.+fn load_depth<T>(first: bool, clear: T) -> wgpu::LoadOp<T> {+ if first { wgpu::LoadOp::Clear(clear) } else { wgpu::LoadOp::Load }+}+/// Uniform bytes for a frame.pub fn uniform_bytes(cb: &Frame, w: f32, h: f32, linear: bool, reversed: bool) -> Vec<u8> {let mut v: Vec<f32> = gpu_view_proj(cb.view_proj, reversed).iter().flatten().copied().collect();@@ -2060,6 +2378,41 @@ mod tests {assert!(placed_box_in_view(&at(30.0, 0.0, -10.0), &[[f32::NAN; 3], [1.0; 3]], &persp));}+ /// A placement's pixels per millimetre: in an orthographic view the same anywhere, along the+ /// axis that shows largest (a turned box too); in perspective, larger nearer the eye, and+ /// infinite (drawn in full) with a corner behind it. The level chosen is the coarsest whose+ /// error stays under `LOD_PX` there.+ #[test]+ fn levels_of_detail_follow_the_size_on_screen() {+ use super::{LOD_PX, level_for, placement_scale};+ let unit = [[0.0f32, 0.0, 0.0], [1.0, 1.0, 1.0]];+ let at = |x: f32, y: f32, z: f32| [[1.0, 0.0, 0.0, x], [0.0, 1.0, 0.0, y], [0.0, 0.0, 1.0, z]];+ // Orthographic over x, y in -10..10 on a 200 × 200 view: 10 px a millimetre.+ let ortho = [[0.1, 0.0, 0.0, 0.0], [0.0, 0.1, 0.0, 0.0], [0.0, 0.0, 0.005, 0.0], [0.0, 0.0, 0.5, 1.0]];+ let size = [200.0, 200.0];+ assert!((placement_scale(&at(0.0, 0.0, 0.0), &unit, &ortho, size) - 10.0).abs() < 1e-3);+ assert!((placement_scale(&at(5.0, -3.0, 0.0), &unit, &ortho, size) - 10.0).abs() < 1e-3);+ let (c, s) = (0.6f32.cos(), 0.6f32.sin());+ let turned = [[c, -s, 0.0, 0.0], [s, c, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0]];+ assert!((placement_scale(&turned, &unit, &ortho, size) - 10.0).abs() < 1e-2);+ // Perspective looking down -z from the origin (w = -z), 90° over 200 px.+ let persp = [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, -1.0, -1.0], [0.0, 0.0, -1.0, 0.0]];+ let near = placement_scale(&at(0.0, 0.0, -10.0), &unit, &persp, size);+ let far = placement_scale(&at(0.0, 0.0, -100.0), &unit, &persp, size);+ assert!((near - 100.0 / 9.0).abs() < 0.2, "nearest corner at depth 9: {near}");+ assert!(far < near / 9.0 && far > 0.0, "{far} vs {near}");+ assert!(placement_scale(&at(0.0, 0.0, 0.5), &unit, &persp, size).is_infinite(), "a corner behind the eye");+ assert!(placement_scale(&at(0.0, 0.0, -10.0), &[[f32::NAN; 3], [1.0; 3]], &persp, size).is_infinite());+ // The coarsest level within LOD_PX: errors 0 (full), 0.05, 0.2, 1.0 mm.+ let errors = [0.0, 0.05, 0.2, 1.0];+ assert_eq!(level_for(&errors, f32::INFINITY), 0);+ assert_eq!(level_for(&errors, 100.0), 0, "5 px for the first level");+ assert_eq!(level_for(&errors, 10.0), 1);+ assert_eq!(level_for(&errors, LOD_PX / 0.2), 2);+ assert_eq!(level_for(&errors, 0.5), 3);+ assert_eq!(level_for(&[0.0], 0.001), 0);+ }+/// Shared vertices: a flat mesh's by position alone (an STL's facets: one normal per/// triangle), a smooth mesh's by position and normal; corners that differ in either stay/// apart. The corners come back as they went in, a flat triangle's lit with its own normal.@@ -2214,6 +2567,149 @@ mod glass_tests {assert!(buffer_chunk(TRI_SIZE, 1) >= TRI_SIZE * 6, "a tiny limit still holds one unit");}+ /// 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.+ fn middle_pixel(scene: GpuScene, oit: bool) -> Option<[u8; 4]> {+ const SIZE: u32 = 64;+ 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: 1, tess: false }, None);+ assert!(r.oit.is_some(), "this device does order-independent transparency");+ if !oit {+ r.oit = None;+ }+ let none = || Arc::new(Mutex::new(None));+ let frame = Frame {+ product: false,+ key: 1,+ slot: Arc::new(Mutex::new(Some(scene))),+ sketch_key: 0,+ sketch_slot: none(),+ hl_key: 0,+ hl_slot: none(),+ pv_key: 0,+ pv_slot: none(),+ pv_hide: false,+ view_proj: [[0.1, 0.0, 0.0, 0.0], [0.0, 0.1, 0.0, 0.0], [0.0, 0.0, -0.01, 0.0], [0.0, 0.0, 0.5, 1.0]],+ back: [0.0, 0.0, 1.0],+ size_px: [SIZE as f32; 2],+ clip: [0.0; 4],+ cap: [0.0; 4],+ images: Vec::new(),+ analysis: [0.0; 8],+ analysis_colors: [0.0; 36],+ access: None,+ outline: false,+ eye: [0.0, 0.0, 100.0, 0.0],+ ao_radius: 0.0,+ ssaa: 1.0,+ };+ let texture = |format, usage| {+ device.create_texture(&wgpu::TextureDescriptor {+ label: None,+ 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: &[],+ })+ };+ let color = texture(format, wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC);+ let depth_tex = texture(depth, wgpu::TextureUsages::RENDER_ATTACHMENT);+ let (color_view, depth_view) = (color.create_view(&Default::default()), depth_tex.create_view(&Default::default()));+ let mut encoder = device.create_command_encoder(&Default::default());+ r.prepare(&device, &queue, &mut encoder, &frame);+ {+ let mut pass = encoder+ .begin_render_pass(&wgpu::RenderPassDescriptor {+ label: None,+ color_attachments: &[Some(wgpu::RenderPassColorAttachment {+ view: &color_view,+ 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: &depth_view,+ depth_ops: Some(wgpu::Operations {+ load: wgpu::LoadOp::Clear(far_depth(reversed_depth(Some(depth)))),+ store: wgpu::StoreOp::Store,+ }),+ stencil_ops: depth+ .has_stencil_aspect()+ .then_some(wgpu::Operations { load: wgpu::LoadOp::Clear(0), store: wgpu::StoreOp::Store }),+ }),+ timestamp_writes: None,+ occlusion_query_set: None,+ multiview_mask: None,+ })+ .forget_lifetime();+ r.paint(&frame, &mut pass, [0.0, 0.0, SIZE as f32, SIZE as f32]);+ }+ let read = device.create_buffer(&wgpu::BufferDescriptor {+ label: None,+ size: u64::from(SIZE * SIZE * 4),+ usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,+ mapped_at_creation: false,+ });+ encoder.copy_texture_to_buffer(+ color.as_image_copy(),+ wgpu::TexelCopyBufferInfo {+ buffer: &read,+ layout: wgpu::TexelCopyBufferLayout { offset: 0, bytes_per_row: Some(SIZE * 4), rows_per_image: Some(SIZE) },+ },+ wgpu::Extent3d { width: SIZE, height: SIZE, depth_or_array_layers: 1 },+ );+ queue.submit([encoder.finish()]);+ read.slice(..).map_async(wgpu::MapMode::Read, |_| {});+ device.poll(wgpu::PollType::wait_indefinitely()).ok()?;+ let bytes = read.slice(..).get_mapped_range().ok()?.to_vec();+ let at = ((SIZE / 2 * SIZE + SIZE / 2) * 4) as usize;+ bytes.get(at..at + 4).and_then(|p| p.try_into().ok())+ }++ /// Two see-through squares, one at z = 5 (near) and one at z = -5, in `near` and `far`+ /// colours, given near first or far first.+ fn two_layers(near: [u8; 4], far: [u8; 4], near_first: bool) -> GpuScene {+ let mut sc = GpuScene::default();+ let mut layers = [(5.0f32, near), (-5.0, far)];+ if !near_first {+ layers.reverse();+ }+ for (z, c) in layers {+ 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);+ }+ }+ sc+ }++ /// Order-independent transparency: the same see-through layers give the same picture in+ /// whichever order they come, the same as sorting them where they share a colour, and close to+ /// it where they do not (the weighted average of their colours, by how much they cover).+ /// Skipped without a GPU adapter.+ #[test]+ fn see_through_layers_blend_in_any_order() {+ let (blue, red) = ([40, 80, 220, 128], [220, 40, 40, 128]);+ let Some(either) = middle_pixel(two_layers(blue, red, true), true) else {+ eprintln!("skipping: no GPU adapter");+ return;+ };+ let other = middle_pixel(two_layers(blue, red, false), true).unwrap();+ assert!(either.iter().zip(other).all(|(a, b)| a.abs_diff(b) <= 1), "{either:?} vs {other:?}");+ let near = |a: [u8; 4], b: [u8; 4], by: u8| a.iter().zip(b).all(|(x, y)| x.abs_diff(y) <= by);+ let same = middle_pixel(two_layers(blue, blue, false), true).unwrap();+ let sorted = middle_pixel(two_layers(blue, blue, false), false).unwrap();+ assert!(near(same, sorted, 3), "one colour: {same:?} vs sorted {sorted:?}");+ let sorted = middle_pixel(two_layers(blue, red, false), false).unwrap();+ assert!(near(either, sorted, 48), "two colours: {either:?} vs sorted {sorted:?}");+ assert!(either[0] > 100 && either[2] > 100, "both colours show: {either:?}");+ }+#[test]fn glass_is_drawn_far_to_near() {// Two triangles at z = 5 and z = -5, given near first; looking down from +Z.diff --git a/crates/gpu/src/view/ao.rs b/crates/gpu/src/view/ao.rsindex ff876ad053..8844671059 100644--- a/crates/gpu/src/view/ao.rs+++ b/crates/gpu/src/view/ao.rs@@ -168,9 +168,8 @@ impl Resources {pass.set_index_buffer(draw.mesh.indices.slice(..), wgpu::IndexFormat::Uint32);pass.draw_indexed(0..draw.mesh.index_count, 0, 0..1);}- for draw in &batch.instanced {- pass.set_pipeline(if draw.flat { &self.instanced_flat_pipeline } else { &self.instanced_pipeline });- draw.draw(&mut pass);+ for draw in batch.instanced.iter().filter(|d| d.look == super::InstanceLook::Opaque) {+ draw.draw(&mut pass, &self.instanced_pipeline, &self.instanced_flat_pipeline);}}}diff --git a/crates/gpu/src/view/oit.rs b/crates/gpu/src/view/oit.rsnew file mode 100644index 0000000000..54245ceecb--- /dev/null+++ b/crates/gpu/src/view/oit.rs@@ -0,0 +1,284 @@+//! Weighted blended order-independent transparency (McGuire and Bavoil, "Weighted Blended+//! Order-Independent Transparency", JCGT 2013) for the model's see-through surfaces: glass (an+//! appearance's opacity) and faded context, instanced or not.+//!+//! Each see-through fragment adds its colour, weighted by its alpha and its depth, into an+//! accumulation target, and multiplies its transparency into a revealage target; a full-screen+//! pass then lays the weighted average over what is behind it, by how much is covered. Nothing is+//! 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};++/// The accumulated colour (premultiplied, weighted) and alpha.+const ACCUM: wgpu::TextureFormat = wgpu::TextureFormat::Rgba16Float;+/// How much of what is behind still shows (1: all of it).+const REVEAL: wgpu::TextureFormat = wgpu::TextureFormat::R8Unorm;++const COMPOSITE: &str = r#"+@group(0) @binding(0) var accum_t: texture_2d<f32>;+@group(0) @binding(1) var reveal_t: texture_2d<f32>;+@vertex+fn vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> {+ let x = f32((i << 1u) & 2u);+ let y = f32(i & 2u);+ return vec4<f32>(x * 2.0 - 1.0, 1.0 - y * 2.0, 0.0, 1.0);+}+@fragment+fn fs(@builtin(position) pos: vec4<f32>) -> @location(0) vec4<f32> {+ let p = vec2<i32>(pos.xy);+ let reveal = textureLoad(reveal_t, p, 0).r;+ let accum = textureLoad(accum_t, p, 0);+ if (reveal >= 1.0) { discard; }+ return vec4<f32>(accum.rgb / max(accum.a, 1e-5), 1.0 - reveal);+}+"#;++/// The pipelines, made once per target kind.+pub(super) struct Pipelines {+ /// Built triangles ([`tri_layout`]), and instanced meshes smooth and flat.+ pub built: wgpu::RenderPipeline,+ pub instanced: wgpu::RenderPipeline,+ pub instanced_flat: wgpu::RenderPipeline,+ composite: wgpu::RenderPipeline,+ bgl: wgpu::BindGroupLayout,+}++/// The targets, kept while the frame's size stays.+pub(super) struct Targets {+ pub size: [u32; 2],+ accum: wgpu::TextureView,+ accum_resolve: Option<wgpu::TextureView>,+ reveal: wgpu::TextureView,+ reveal_resolve: Option<wgpu::TextureView>,+ bind: wgpu::BindGroup,+}++impl Pipelines {+ /// The pipelines for frames of `format` with `depth` and `samples`, using the viewport's+ /// shader `module` and uniform `layout`; `None` where the device cannot blend into a float+ /// target (the model's see-through surfaces are then sorted as before).+ pub fn new(+ device: &wgpu::Device,+ module: &wgpu::ShaderModule,+ layout: &wgpu::PipelineLayout,+ format: wgpu::TextureFormat,+ depth: Option<wgpu::TextureFormat>,+ samples: u32,+ ) -> Option<Pipelines> {+ let scopes = [wgpu::ErrorFilter::OutOfMemory, wgpu::ErrorFilter::Internal, wgpu::ErrorFilter::Validation].map(|f| device.push_error_scope(f));+ let reversed = super::reversed_depth(depth);+ let samples = samples.max(1);+ let multisample = wgpu::MultisampleState { count: samples, mask: !0, alpha_to_coverage_enabled: false };+ let add =+ wgpu::BlendComponent { src_factor: wgpu::BlendFactor::One, dst_factor: wgpu::BlendFactor::One, operation: wgpu::BlendOperation::Add };+ let keep = wgpu::BlendComponent {+ src_factor: wgpu::BlendFactor::Zero,+ dst_factor: wgpu::BlendFactor::OneMinusSrc,+ operation: wgpu::BlendOperation::Add,+ };+ let targets = [+ Some(wgpu::ColorTargetState {+ format: ACCUM,+ blend: Some(wgpu::BlendState { color: add, alpha: add }),+ write_mask: wgpu::ColorWrites::ALL,+ }),+ Some(wgpu::ColorTargetState {+ format: REVEAL,+ blend: Some(wgpu::BlendState { color: keep, alpha: keep }),+ write_mask: wgpu::ColorWrites::RED,+ }),+ ];+ let built_buffers = [Some(tri_layout())];+ let placed = [Some(shared_layout()), Some(instance_layout())];+ let pipeline = |label: &str, source: TriSource| {+ device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {+ label: Some(label),+ layout: Some(layout),+ vertex: wgpu::VertexState {+ module,+ entry_point: Some(source.entry()),+ buffers: if source == TriSource::Built { &built_buffers[..] } else { &placed[..] },+ compilation_options: Default::default(),+ },+ primitive: wgpu::PrimitiveState { topology: wgpu::PrimitiveTopology::TriangleList, ..Default::default() },+ depth_stencil: depth.map(|format| wgpu::DepthStencilState {+ format,+ depth_write_enabled: Some(false),+ depth_compare: Some(depth_compare(reversed, wgpu::CompareFunction::LessEqual)),+ stencil: Default::default(),+ bias: Default::default(),+ }),+ multisample,+ fragment: Some(wgpu::FragmentState {+ module,+ entry_point: Some(&source.fragment("fs_oit")),+ targets: &targets,+ compilation_options: Default::default(),+ }),+ multiview_mask: None,+ cache: None,+ })+ };+ let built = pipeline("sc_oit", TriSource::Built);+ let instanced = pipeline("sc_oit_instanced", TriSource::Instanced);+ let instanced_flat = pipeline("sc_oit_instanced_flat", TriSource::InstancedFlat);+ let texture = |binding| wgpu::BindGroupLayoutEntry {+ binding,+ visibility: wgpu::ShaderStages::FRAGMENT,+ ty: wgpu::BindingType::Texture {+ sample_type: wgpu::TextureSampleType::Float { filterable: false },+ view_dimension: wgpu::TextureViewDimension::D2,+ multisampled: false,+ },+ count: None,+ };+ let bgl = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { label: Some("sc_oit"), entries: &[texture(0), texture(1)] });+ let composite_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {+ label: Some("sc_oit_composite"),+ bind_group_layouts: &[Some(&bgl)],+ immediate_size: 0,+ });+ let composite_module = device.create_shader_module(wgpu::ShaderModuleDescriptor {+ label: Some("sc_oit_composite"),+ source: wgpu::ShaderSource::Wgsl(COMPOSITE.into()),+ });+ // Over the frame (premultiplied over transparent black): the average colour by how much+ // is covered.+ let over = wgpu::BlendState {+ color: wgpu::BlendComponent {+ src_factor: wgpu::BlendFactor::SrcAlpha,+ dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,+ operation: wgpu::BlendOperation::Add,+ },+ alpha: wgpu::BlendComponent {+ src_factor: wgpu::BlendFactor::One,+ dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,+ operation: wgpu::BlendOperation::Add,+ },+ };+ let composite = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {+ label: Some("sc_oit_composite"),+ layout: Some(&composite_layout),+ vertex: wgpu::VertexState { module: &composite_module, entry_point: Some("vs"), buffers: &[], compilation_options: Default::default() },+ primitive: wgpu::PrimitiveState { topology: wgpu::PrimitiveTopology::TriangleList, ..Default::default() },+ depth_stencil: None,+ multisample,+ fragment: Some(wgpu::FragmentState {+ module: &composite_module,+ entry_point: Some("fs"),+ targets: &[Some(wgpu::ColorTargetState { format, blend: Some(over), write_mask: wgpu::ColorWrites::ALL })],+ compilation_options: Default::default(),+ }),+ multiview_mask: None,+ cache: None,+ });+ let mut failed = None;+ for scope in scopes.into_iter().rev() {+ if let Some(e) = crate::popped(scope.pop()) {+ failed.get_or_insert(e.to_string());+ }+ }+ if let Some(e) = failed {+ log::info!("see-through surfaces are sorted (no order-independent transparency here: {e})");+ return None;+ }+ Some(Pipelines { built, instanced, instanced_flat, composite, bgl })+ }++ /// The targets for a frame of `size` pixels at `samples` per pixel.+ pub fn targets(&self, device: &wgpu::Device, size: [u32; 2], samples: u32) -> Targets {+ let samples = samples.max(1);+ let texture = |label: &str, format, samples, usage| {+ device+ .create_texture(&wgpu::TextureDescriptor {+ label: Some(label),+ size: wgpu::Extent3d { width: size[0].max(1), height: size[1].max(1), depth_or_array_layers: 1 },+ mip_level_count: 1,+ sample_count: samples,+ dimension: wgpu::TextureDimension::D2,+ format,+ usage,+ view_formats: &[],+ })+ .create_view(&Default::default())+ };+ let read = wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING;+ let pair = |label: &str, format| {+ if samples > 1 {+ (texture(label, format, samples, wgpu::TextureUsages::RENDER_ATTACHMENT), Some(texture(label, format, 1, read)))+ } else {+ (texture(label, format, 1, read), None)+ }+ };+ let (accum, accum_resolve) = pair("sc_oit_accum", ACCUM);+ let (reveal, reveal_resolve) = pair("sc_oit_reveal", REVEAL);+ let bind = device.create_bind_group(&wgpu::BindGroupDescriptor {+ label: Some("sc_oit"),+ layout: &self.bgl,+ entries: &[+ wgpu::BindGroupEntry { binding: 0, resource: wgpu::BindingResource::TextureView(accum_resolve.as_ref().unwrap_or(&accum)) },+ wgpu::BindGroupEntry { binding: 1, resource: wgpu::BindingResource::TextureView(reveal_resolve.as_ref().unwrap_or(&reveal)) },+ ],+ });+ Targets { size, accum, accum_resolve, reveal, reveal_resolve, bind }+ }++ /// The pass that gathers the see-through surfaces (`draw` records them), against `depth`.+ pub fn accumulate(+ &self,+ encoder: &mut wgpu::CommandEncoder,+ t: &Targets,+ depth: Option<&wgpu::TextureView>,+ stencil: bool,+ draw: impl FnOnce(&mut wgpu::RenderPass<'static>),+ ) {+ let attach = |view, resolve_target, clear| {+ Some(wgpu::RenderPassColorAttachment {+ view,+ depth_slice: None,+ resolve_target,+ ops: wgpu::Operations { load: wgpu::LoadOp::Clear(clear), store: wgpu::StoreOp::Store },+ })+ };+ let mut pass = encoder+ .begin_render_pass(&wgpu::RenderPassDescriptor {+ label: Some("sc_oit"),+ color_attachments: &[+ attach(&t.accum, t.accum_resolve.as_ref(), wgpu::Color::TRANSPARENT),+ attach(&t.reveal, t.reveal_resolve.as_ref(), wgpu::Color::WHITE),+ ],+ depth_stencil_attachment: depth.map(|view| wgpu::RenderPassDepthStencilAttachment {+ view,+ depth_ops: Some(wgpu::Operations { load: wgpu::LoadOp::Load, store: wgpu::StoreOp::Store }),+ stencil_ops: stencil.then_some(wgpu::Operations { load: wgpu::LoadOp::Load, store: wgpu::StoreOp::Store }),+ }),+ timestamp_writes: None,+ occlusion_query_set: None,+ multiview_mask: None,+ })+ .forget_lifetime();+ pass.set_viewport(0.0, 0.0, t.size[0] as f32, t.size[1] as f32, 0.0, 1.0);+ draw(&mut pass);+ }++ /// Lay what was gathered over the frame's `color` (resolved into `resolve`).+ pub fn composite(&self, encoder: &mut wgpu::CommandEncoder, t: &Targets, color: &wgpu::TextureView, resolve: Option<&wgpu::TextureView>) {+ let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {+ label: Some("sc_oit_composite"),+ color_attachments: &[Some(wgpu::RenderPassColorAttachment {+ view: color,+ depth_slice: None,+ resolve_target: resolve,+ ops: wgpu::Operations { load: wgpu::LoadOp::Load, store: wgpu::StoreOp::Store },+ })],+ depth_stencil_attachment: None,+ timestamp_writes: None,+ occlusion_query_set: None,+ multiview_mask: None,+ });+ pass.set_pipeline(&self.composite);+ pass.set_bind_group(0, &t.bind, &[]);+ pass.draw(0..3, 0..1);+ }+}diff --git a/crates/ui-egui/src/gpu.rs b/crates/ui-egui/src/gpu.rsindex f638f70d6d..d4ca383f0c 100644--- a/crates/ui-egui/src/gpu.rs+++ b/crates/ui-egui/src/gpu.rs@@ -8,8 +8,8 @@ use std::sync::{Arc, Mutex};use egui_wgpu::wgpu;pub use solidcraft_gpu::view::{- AccessMap, BlockBytes, Frame, GpuImage, GpuScene, GpuTarget, InstancedMesh, LINE_SIZE, PBR_SIZE, PlannedBody, Renderer, SHARED_SIZE, SceneBlock,- SceneSlot, SharedTris, TRI_SIZE, supersampled_size,+ AccessMap, BlockBytes, 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,};/// A frame of the viewport as an egui paint callback.diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex 40dbc43c94..ca2ea57207 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -92,6 +92,7 @@ mod material_card_review;mod measurement_ui_tests;#[cfg(test)]mod menu_tests;+pub(crate) mod mesh_lod;pub mod messages;#[cfg(test)]mod pattern_arrow_tests;diff --git a/crates/ui-egui/src/mesh_lod.rs b/crates/ui-egui/src/mesh_lod.rsnew file mode 100644index 0000000000..0e31ec34d6--- /dev/null+++ b/crates/ui-egui/src/mesh_lod.rs@@ -0,0 +1,108 @@+//! Levels of detail for large meshes drawn as instances: coarser copies of a shared mesh+//! ([`solidcraft_engine::geom::simplify`]), made once per mesh off the window thread, so a+//! placement small on screen is drawn from far fewer triangles ([`crate::gpu::LOD_PX`] decides+//! which). Until a mesh's levels are made it is drawn in full; when they are, the scene is built+//! again with them ([`MeshLods::generation`]).+//!+//! Display only: the reference mesh (picking, measuring, exports) is never simplified.++use std::collections::{HashMap, HashSet};+use std::sync::{Arc, Mutex};++use solidcraft_engine::geom::Mesh;++use crate::gpu::SharedTris;++/// A mesh gets levels of detail from this many triangles.+pub(crate) const MIN_TRIANGLES: usize = 20_000;+/// Fewest triangles a level keeps.+const MIN_LEVEL: usize = 1_000;+/// Meshes simplified at once.+const MAX_JOBS: usize = 2;++/// A mesh's levels: coarser copies, finest first, each with its error (mm).+pub(crate) type Levels = Arc<Vec<(Arc<SharedTris>, f32)>>;++/// The levels made (and being made), by mesh address with the mesh held, so its address stays+/// its own.+#[derive(Clone, Default)]+pub(crate) struct MeshLods(Arc<Mutex<State>>);++#[derive(Default)]+struct State {+ by_mesh: HashMap<usize, (Arc<Mesh>, Option<Levels>)>,+ /// Counts the levels made: the scene is built again when it changes.+ generation: u64,+ making: usize,+}++impl MeshLods {+ /// `mesh`'s levels when made; otherwise `None`, and they are started (once) on a worker+ /// when one is free.+ pub(crate) fn levels(&self, mesh: &Arc<Mesh>) -> Option<Levels> {+ if mesh.triangles.len() < MIN_TRIANGLES {+ return None;+ }+ let key = Arc::as_ptr(mesh) as usize;+ let mut state = self.0.lock().ok()?;+ if let Some((_, levels)) = state.by_mesh.get(&key).filter(|(held, _)| Arc::ptr_eq(held, mesh)) {+ return levels.clone();+ }+ if state.making >= MAX_JOBS {+ return None;+ }+ state.by_mesh.insert(key, (mesh.clone(), None));+ state.making += 1;+ let (shared, source) = (self.0.clone(), mesh.clone());+ let started = std::thread::Builder::new().name("mesh-lod".into()).spawn(move || {+ let levels = Arc::new(make(&source));+ if let Ok(mut state) = shared.lock() {+ if let Some(slot) = state.by_mesh.get_mut(&key).filter(|(held, _)| Arc::ptr_eq(held, &source)) {+ slot.1 = Some(levels);+ }+ state.making = state.making.saturating_sub(1);+ state.generation = state.generation.wrapping_add(1);+ }+ });+ if started.is_err() {+ // No threads (the browser): drawn in full.+ state.making = state.making.saturating_sub(1);+ if let Some(slot) = state.by_mesh.get_mut(&key) {+ slot.1 = Some(Arc::new(Vec::new()));+ }+ }+ None+ }++ /// Changes whenever a mesh's levels are made.+ pub(crate) fn generation(&self) -> u64 {+ self.0.lock().map_or(0, |s| s.generation)+ }++ /// Levels are being made (keep frames coming to pick them up).+ pub(crate) fn busy(&self) -> bool {+ self.0.lock().is_ok_and(|s| s.making > 0)+ }++ /// Let go of the levels of meshes not in `used` (by address); those being made stay.+ pub(crate) fn retain(&self, used: &HashSet<usize>) {+ if let Ok(mut state) = self.0.lock() {+ state.by_mesh.retain(|k, (_, levels)| levels.is_none() || used.contains(k));+ }+ }+}++/// `mesh`'s levels: a quarter, a sixteenth and a sixty-fourth of its triangles (none under+/// [`MIN_LEVEL`]).+fn make(mesh: &Mesh) -> Vec<(Arc<SharedTris>, f32)> {+ let n = mesh.triangles.len();+ let targets: Vec<usize> = [4, 16, 64].into_iter().map(|d| n / d).filter(|t| *t >= MIN_LEVEL).collect();+ solidcraft_engine::geom::simplify::levels(&mesh.positions, &mesh.triangles, &targets)+ .iter()+ .map(|l| (Arc::new(SharedTris::from_level(l)), l.error as f32))+ .collect()+}++#[cfg(test)]+#[path = "mesh_lod_tests.rs"]+mod tests;diff --git a/crates/ui-egui/src/mesh_lod_tests.rs b/crates/ui-egui/src/mesh_lod_tests.rsnew file mode 100644index 0000000000..319ac58515--- /dev/null+++ b/crates/ui-egui/src/mesh_lod_tests.rs@@ -0,0 +1,64 @@+use super::*;++/// A sphere mesh of about `2 n²` triangles, each corner its own point.+fn sphere(n: u32) -> Arc<Mesh> {+ use solidcraft_engine::geom::Vec3;+ let at = |i: u32, j: u32| {+ let (t, p) = (std::f64::consts::PI * f64::from(i) / f64::from(n), std::f64::consts::TAU * f64::from(j) / f64::from(2 * n));+ let (st, sp, cp) =+ (if i == 0 || i == n { 0.0 } else { t.sin() }, if j == 2 * n { 0.0 } else { p.sin() }, if j == 2 * n { 1.0 } else { p.cos() });+ Vec3::new(50.0 * st * cp, 50.0 * st * sp, 50.0 * t.cos())+ };+ let mut m = Mesh::default();+ for i in 0..n {+ for j in 0..2 * n {+ let (a, b, c, d) = (at(i, j), at(i + 1, j), at(i + 1, j + 1), at(i, j + 1));+ for [x, y, z] in [[a, c, d], [a, b, c]] {+ let k = m.positions.len() as u32;+ let nrm = (y - x).cross(z - x).normalized().unwrap_or(Vec3::Z);+ m.positions.extend([x, y, z]);+ m.normals.extend([nrm; 3]);+ m.triangles.push([k, k + 1, k + 2]);+ }+ }+ }+ Arc::new(m)+}++/// A large mesh's levels are made once, on a worker: asked for, `None` comes back at once and+/// the work starts; when done, the generation moves on and the levels come back, coarser and+/// coarser, each with its error. A small mesh gets none.+#[test]+fn a_large_meshs_levels_are_made_once_on_a_worker() {+ let lods = MeshLods::default();+ assert!(lods.levels(&sphere(20)).is_none(), "small: none");+ assert!(!lods.busy());+ let mesh = sphere(110);+ assert!(mesh.triangles.len() >= MIN_TRIANGLES);+ let before = lods.generation();+ assert!(lods.levels(&mesh).is_none(), "not made in the asking frame");+ let began = std::time::Instant::now();+ let levels = loop {+ if let Some(l) = lods.levels(&mesh) {+ break l;+ }+ assert!(began.elapsed() < std::time::Duration::from_secs(60), "made on a worker");+ std::thread::sleep(std::time::Duration::from_millis(5));+ };+ assert_ne!(lods.generation(), before);+ assert!(!lods.busy());+ // A quarter and a sixteenth (a sixty-fourth would be under `MIN_LEVEL`).+ assert_eq!(levels.len(), 2, "{} triangles", mesh.triangles.len());+ let mut last = (mesh.triangles.len(), 0.0f32);+ for (tris, error) in levels.iter() {+ let n = tris.indices.len() / 3;+ assert!(n * 3 <= last.0, "{n} after {}", last.0);+ assert!(*error >= last.1 && *error < 2.0, "error {error}");+ assert!(tris.flat);+ last = (n, *error);+ }+ assert!(Arc::ptr_eq(&levels, &lods.levels(&mesh).unwrap()), "made once");+ // Let go when no longer drawn.+ lods.retain(&HashSet::new());+ assert!(lods.levels(&mesh).is_none(), "made again when asked again");+}diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rsindex 62aa0e1e68..d890ae7b62 100644--- a/crates/ui-egui/src/viewport.rs+++ b/crates/ui-egui/src/viewport.rs@@ -66,6 +66,8 @@ pub struct ViewportState {/// The triangles of each mesh the last scene drew as instances, by the mesh's address (the/// mesh held, so its address stays its own).instanced_tris: std::sync::Mutex<InstancedTris>,+ /// The levels of detail of large instanced meshes ([`crate::mesh_lod`]).+ pub(crate) mesh_lods: crate::mesh_lod::MeshLods,/// View-dependent display refinement (#1320): which bodies are drawn finer than the chosen/// display quality, and their refined plans.pub(crate) lod: std::sync::Mutex<crate::display_lod::Lod>,@@ -319,6 +321,7 @@ fn scene_key(app: &SolveApp) -> u64 {app.ui.ground_shadow.hash(&mut h);solidcraft_engine::doc::display_quality::current().hash(&mut h);lod_generation(app).hash(&mut h);+ app.viewport.mesh_lods.generation().hash(&mut h);// The section plane (its cut outlines are part of the model scene).section_plane(app).map(|(o, n)| [o.x, o.y, o.z, n.x, n.y, n.z].map(f64::to_bits)).hash(&mut h);app.cam.up.hash(&mut h);@@ -714,6 +717,7 @@ struct Instances {/// 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)>,kept: InstancedTris,+ lods: crate::mesh_lod::MeshLods,}impl Instances {@@ -733,31 +737,42 @@ 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 }+ Instances { candidates, meshes: Vec::new(), kept, lods: app.viewport.mesh_lods.clone() }}- /// Draw `b` (in colour `col`) as an instance when it is one: its shared mesh and placement.+ /// Draw `b` as an instance when it is one, in colour `col` (its alpha for a see-through+ /// `look`): its shared mesh and placement.fn place(&mut self,b: &solidcraft_engine::doc::ModelBody,col: [u8; 4],+ 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, _)| std::sync::Arc::ptr_eq(k, &mesh)) {+ let at = match self.meshes.iter().position(|(k, i)| std::sync::Arc::ptr_eq(k, &mesh) && i.look == look) {Some(at) => at,None => {- let tris = match self.kept.get(&key).filter(|(k, _)| std::sync::Arc::ptr_eq(k, &mesh)) {- Some((_, t)) => t.clone(),- None => taken_shared_tris(&mesh).unwrap_or_else(|| std::sync::Arc::new(crate::gpu::SharedTris::new(&mesh))),+ // The same triangles (and levels) for each look of a mesh.+ let made = self.meshes.iter().find(|(k, _)| std::sync::Arc::ptr_eq(k, &mesh)).map(|(_, i)| (i.tris.clone(), i.levels.clone()));+ let (tris, levels) = match made {+ Some(made) => made,+ None => (+ match self.kept.get(&key).filter(|(k, _)| std::sync::Arc::ptr_eq(k, &mesh)) {+ Some((_, t)) => t.clone(),+ None => taken_shared_tris(&mesh).unwrap_or_else(|| std::sync::Arc::new(crate::gpu::SharedTris::new(&mesh))),+ },+ // A large mesh's levels of detail, once made (until then, drawn in full).+ self.lods.levels(&mesh).map(|l| l.as_ref().clone()).unwrap_or_default(),+ ),};- self.meshes.push((mesh.clone(), crate::gpu::InstancedMesh { key: key as u64, tris, instances: Vec::new() }));+ self.meshes.push((mesh.clone(), crate::gpu::InstancedMesh { key: key as u64, tris, instances: Vec::new(), look, levels }));self.meshes.len() - 1}};let (_, inst) = self.meshes.get_mut(at)?;- inst.place(rows, [col[0], col[1], col[2], 255]);+ inst.place(rows, col);Some((mesh, m))}@@ -765,6 +780,7 @@ impl Instances {fn finish(self, app: &SolveApp) -> Vec<crate::gpu::InstancedMesh> {let kept: InstancedTris =self.meshes.iter().map(|(mesh, inst)| (std::sync::Arc::as_ptr(mesh) as usize, (mesh.clone(), inst.tris.clone()))).collect();+ self.lods.retain(&kept.keys().copied().collect());if let Ok(mut k) = app.viewport.instanced_tris.lock() {*k = kept;}@@ -833,7 +849,21 @@ pub(crate) fn build_scene(app: &SolveApp) -> GpuScene {.collect();sc.planned.push(crate::gpu::PlannedBody { plan, face_colors });}- let instanced = (!on_gpu && !faded && face_looks.is_empty() && opacity >= 0.999).then(|| instances.place(b, col)).flatten();+ // Opaque, faded and see-through bodies alike, in one colour (faces of their own colour+ // are built as before).+ let look = if faded {+ crate::gpu::InstanceLook::Faded+ } else if opacity < 0.999 {+ crate::gpu::InstanceLook::Glass+ } else {+ crate::gpu::InstanceLook::Opaque+ };+ let alpha = match look {+ crate::gpu::InstanceLook::Faded => col[3],+ 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();let body = match instanced {Some((mesh, place)) => BodyDraw { mesh, place: Some(place), col, faded, opacity, face_looks, on_gpu: true },None => BodyDraw { mesh: drawn_mesh(app, b), place: None, col, faded, opacity, face_looks, on_gpu },@@ -2625,6 +2655,10 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {// ---- model ----crate::frame_watch::step(app, "viewport before the model");update_refinement(app, ui.ctx(), &proj);+ // Levels of detail being made: keep frames coming to draw them when they are.+ if app.viewport.mesh_lods.busy() {+ ui.ctx().request_repaint_after(std::time::Duration::from_millis(100));+ }crate::frame_watch::step(app, "display refinement");let key = scene_key(app);let t0 = crate::now_ms();@@ -4883,6 +4917,10 @@ mod tests {for k in 1..25 {app.run("occurrence.copy", json!({"component":component,"translate":[f64::from(k % 5) * step, f64::from(k / 5) * step, 0.0]})).unwrap();}+ // `SOLIDCRAFT_BENCH_OPACITY=0.5`: every placement see-through.+ if let Some(opacity) = std::env::var("SOLIDCRAFT_BENCH_OPACITY").ok().and_then(|v| v.parse::<f64>().ok()) {+ app.run("appearance.assign", json!({"components": [component.to_string()], "color": "#b4b8bc", "opacity": opacity})).unwrap();+ }let Some((_, device, queue)) = crate::gpu::offscreen_device() else {eprintln!("skipping: no GPU adapter");return;@@ -4928,11 +4966,50 @@ mod tests {eprintln!("close up: {seen} of {} placements' centres in view", st.bodies.len());}let yaw = app.cam.yaw;- for (label, scene) in [("own triangles", scene.clone().merged()), ("instanced", scene)] {+ // The levels of detail, made off the window thread meanwhile.+ let t = std::time::Instant::now();+ while app.viewport.mesh_lods.busy() {+ std::thread::sleep(std::time::Duration::from_millis(20));+ }+ let lod = build_scene(&app);+ eprintln!(+ "levels of detail made in {:.1} s: {:?}",+ t.elapsed().as_secs_f64(),+ lod.instanced.iter().map(|m| m.levels.iter().map(|(t, e)| (t.indices.len() / 3, *e)).collect::<Vec<_>>()).collect::<Vec<_>>()+ );+ // `SOLIDCRAFT_BENCH_PNG=dir`: the view drawn from each placement's own triangles, in full+ // as instances, and from the levels (`SOLIDCRAFT_BENCH_PNG_ONLY=1`: then stop).+ if let Some(dir) = std::env::var_os("SOLIDCRAFT_BENCH_PNG") {+ const SIDE: u32 = 1024;+ let rect = Rect::from_min_size(Pos2::ZERO, vec2(SIDE as f32, SIDE 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 }];+ for (name, scene) in [("own", scene.clone().merged()), ("full", scene.clone()), ("lod", lod.clone())] {+ if let Some(rgba) = crate::gpu::render_offscreen(+ scene,+ None,+ proj.vp.to_f32(),+ proj.cam.back().to_f32(),+ eye,+ SIDE,+ None,+ [0.0; 8],+ crate::gpu::analysis_colors(&Tokens::get().analysis),+ ) && let Some(png) = solidcraft_engine::render::png(SIDE as usize, SIDE as usize, rgba)+ {+ let _ = std::fs::write(std::path::Path::new(&dir).join(format!("{name}.png")), png);+ }+ }+ }+ if std::env::var_os("SOLIDCRAFT_BENCH_PNG_ONLY").is_some() {+ 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 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 = Vec::new();+ let (mut times, mut prepared) = (Vec::new(), Vec::new());for k in 0..40 {app.cam.yaw = yaw + f64::from(k) * 0.05;let proj = projection(&app, rect);@@ -4965,6 +5042,9 @@ mod tests {let t0 = std::time::Instant::now();let mut encoder = device.create_command_encoder(&Default::default());renderer.prepare(&device, &queue, &mut encoder, &frame);+ if k >= 5 {+ prepared.push(t0.elapsed().as_secs_f64() * 1e3);+ }{let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {@@ -4997,7 +5077,14 @@ mod tests {}}times.sort_by(f64::total_cmp);- eprintln!("{label}: median {:.1} ms a frame (min {:.1}, max {:.1})", times[times.len() / 2], times[0], times[times.len() - 1]);+ prepared.sort_by(f64::total_cmp);+ eprintln!(+ "{label}: median {:.1} ms a frame (min {:.1}, max {:.1}), of which {:.1} ms preparing on the CPU",+ times[times.len() / 2],+ times[0],+ times[times.len() - 1],+ prepared[prepared.len() / 2]+ );}}@@ -5031,6 +5118,154 @@ mod tests {assert!(!WARMED.lock().unwrap().iter().any(|(m, _)| std::sync::Arc::ptr_eq(m, &mesh)), "taken");}+ /// A design with one imported mesh of about 100 000 triangles (a sphere of radius 50, each+ /// corner its own point, as an STL is read), drawn on a device that builds bodies on the CPU.+ fn large_scan() -> SolveApp {+ use solidcraft_engine::doc::{Document, FeatureKind, MeshData};+ let n = 160u32;+ let at = |i: u32, j: u32| {+ let (t, p) = (std::f64::consts::PI * f64::from(i) / f64::from(n), std::f64::consts::TAU * f64::from(j) / f64::from(2 * n));+ let (st, sp, cp) =+ (if i == 0 || i == n { 0.0 } else { t.sin() }, if j == 2 * n { 0.0 } else { p.sin() }, if j == 2 * n { 1.0 } else { p.cos() });+ [50.0 * st * cp, 50.0 * st * sp, 50.0 * t.cos()]+ };+ let corners: Vec<[f64; 3]> = (0..n)+ .flat_map(|i| (0..2 * n).flat_map(move |j| [at(i, j), at(i + 1, j + 1), at(i, j + 1), at(i, j), at(i + 1, j), at(i + 1, j + 1)]))+ .collect();+ let mut doc = Document::default();+ let meshes = vec![MeshData {+ name: "Scan".into(),+ positions: corners.iter().flatten().copied().collect(),+ triangles: (0..u32::try_from(corners.len()).unwrap()).collect(),+ color: None,+ }];+ doc.add_feature(FeatureKind::MeshImport { file: "scan.stl".into(), meshes }, Some("Scan")).unwrap();+ let mut app = SolveApp::new(solidcraft_engine::Session::new(doc), crate::Services::default());+ app.ui.ground_shadow = false;+ app.ui.show_origin = false;+ app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: false });+ app+ }++ /// A large mesh is drawn in full until its levels of detail are made off the window thread;+ /// then the scene is built again with them, and seen small, a coarse level draws it as the+ /// full triangles do (within a fraction of a pixel). Skipped without a GPU adapter (the+ /// levels are checked anyway).+ #[test]+ fn a_large_mesh_seen_small_is_drawn_from_its_levels_of_detail() {+ let mut app = large_scan();+ let (mesh, _) = app.session.world_state().bodies[0].mesh_in_place();+ assert!(mesh.triangles.len() >= INSTANCE_ALONE);+ let key = scene_key(&app);+ let first = build_scene(&app);+ assert_eq!(first.instanced.len(), 1);+ assert!(first.instanced[0].levels.is_empty(), "drawn in full meanwhile");+ let began = std::time::Instant::now();+ while app.viewport.mesh_lods.busy() {+ assert!(began.elapsed() < std::time::Duration::from_secs(120), "the levels are made");+ std::thread::sleep(std::time::Duration::from_millis(10));+ }+ assert_ne!(scene_key(&app), key, "the scene is built again when they are");+ let scene = build_scene(&app);+ let levels = &scene.instanced[0].levels;+ assert!(levels.len() >= 2, "{} levels", levels.len());+ // Small on screen: the sphere about 30 px across.+ app.fit_view();+ app.cam.distance *= 4.0;+ const SIZE: u32 = 256;+ 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 = |scene: GpuScene| {+ crate::gpu::render_offscreen(+ scene,+ None,+ proj.vp.to_f32(),+ proj.cam.back().to_f32(),+ eye,+ SIZE,+ None,+ [0.0; 8],+ crate::gpu::analysis_colors(&Tokens::get().analysis),+ )+ };+ // The level the placement is drawn from there.+ let rows = [[1.0f32, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0]];+ let scale = crate::gpu::placement_scale(&rows, &scene.instanced[0].tris.bounds, &proj.vp.to_f32(), [SIZE as f32; 2]);+ let errors: Vec<f32> = std::iter::once(0.0).chain(levels.iter().map(|(_, e)| *e)).collect();+ assert!(crate::gpu::level_for(&errors, scale) >= 1, "a coarse level: scale {scale} px/mm, errors {errors:?}");+ let (Some(lod), Some(full)) = (render(scene.clone()), render(scene.merged())) else {+ eprintln!("skipping: no GPU adapter");+ return;+ };+ let drawn = full.chunks(4).filter(|p| p[..3] != [255, 255, 255]).count();+ assert!(drawn > 300, "the sphere is drawn: {drawn} pixels");+ let differ = lod.chunks(4).zip(full.chunks(4)).filter(|(a, b)| a.iter().zip(b.iter()).any(|(x, y)| x.abs_diff(*y) > 24)).count();+ assert!(differ * 20 < drawn, "{differ} of {drawn} pixels differ");+ }++ /// See-through and faded placements of a part are drawn as instances too, with their alpha:+ /// glass with an appearance's opacity, faded context with another component active. None+ /// of their triangles go to the glass sorted triangle by triangle, and they look as their+ /// own triangles did. GPU pictures skipped without an adapter.+ #[test]+ fn see_through_and_faded_placements_are_drawn_as_instances() {+ use crate::gpu::InstanceLook;+ let mut app = three_placed_parts(PARTS[0]);+ app.run("appearance.assign", json!({"components": ["Part"], "color": "#3366cc", "opacity": 0.4})).unwrap();+ 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");+ 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.+ let mut context = SolveApp::new(solidcraft_engine::Session::default(), crate::Services::default());+ context.viewport.gpu = app.viewport.gpu;+ context.ui.ground_shadow = false;+ context.ui.show_origin = false;+ context.run("component.create", json!({"name":"Part"})).unwrap();+ context.run(PARTS[0].0, serde_json::from_str(PARTS[0].1).unwrap()).unwrap();+ context.run("occurrence.copy", json!({"component":"Part","translate":[40,0,0]})).unwrap();+ context.run("occurrence.copy", json!({"component":"Part","translate":[0,40,0]})).unwrap();+ let faded = build_scene(&context);+ let looks: Vec<_> = faded.instanced.iter().map(|m| (m.look, m.count())).collect();+ assert!(looks.contains(&(InstanceLook::Faded, 2)), "the other placements faded: {looks:?}");+ assert!(faded.trans.is_empty());+ for (name, scene) in [("glass", glass), ("faded", faded)] {+ app.fit_view();+ const SIZE: u32 = 256;+ 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 = |scene: GpuScene| {+ crate::gpu::render_offscreen(+ scene,+ None,+ proj.vp.to_f32(),+ proj.cam.back().to_f32(),+ eye,+ SIZE,+ None,+ [0.0; 8],+ crate::gpu::analysis_colors(&Tokens::get().analysis),+ )+ };+ let (Some(instanced), Some(own)) = (render(scene.clone()), render(scene.merged())) else {+ eprintln!("skipping: no GPU adapter");+ return;+ };+ let drawn = own.chunks(4).filter(|p| p[..3] != [255, 255, 255]).count();+ assert!(drawn > 1000, "{name}: drawn {drawn}");+ let differ = instanced.chunks(4).zip(own.chunks(4)).filter(|(a, b)| a.iter().zip(b.iter()).any(|(x, y)| x.abs_diff(*y) > 24)).count();+ // A pixel here and there along the boxes' edges, where moving the corners on the GPU+ // rounds them differently.+ assert!(differ * 50 < drawn, "{name}: {differ} of {drawn} pixels differ");+ }+ }+/// Each placement of a part is picked where it stands, the turned one too, from the part's/// shared mesh: the face under the cursor names that placement's body, at the point the/// cursor is over, and no placement makes a moved copy of the mesh to be picked.