SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Viewport: leave out placements of an instanced mesh that are out of view (#4646) (#4647)
Jackson Oursland3d3dd2743999
diff --git a/assets/shaders/viewport.wgsl b/assets/shaders/viewport.wgslindex 7e8c27a58c..2cc978d853 100644--- a/assets/shaders/viewport.wgsl+++ b/assets/shaders/viewport.wgsl@@ -64,7 +64,96 @@ fn vs_tri(@location(0) p: vec3<f32>, @location(1) n: vec3<f32>, @location(2) c:return o;}-/// Opaque model surfaces: cut by the section plane, the inside shows as a flat cap colour.+/// Shared triangles (in their part's own frame) drawn at one placement: the rows of its rigid+/// move (`r0`..`r2`, a point's coordinates are their dot products with (p, 1)) and its colour.+/// The vertex colour (location 2) is not read.+@vertex+fn vs_tri_inst(+ @location(0) p: vec3<f32>,+ @location(1) n: vec3<f32>,+ @location(3) r0: vec4<f32>,+ @location(4) r1: vec4<f32>,+ @location(5) r2: vec4<f32>,+ @location(6) c: vec4<f32>,+) -> TOut {+ let q = vec4<f32>(p, 1.0);+ let wp = vec3<f32>(dot(r0, q), dot(r1, q), dot(r2, q));+ var o: TOut;+ o.pos = u.vp * vec4<f32>(wp, 1.0);+ o.n = vec3<f32>(dot(r0.xyz, n), dot(r1.xyz, n), dot(r2.xyz, n));+ o.c = c;+ o.wp = wp;+ return o;+}++/// A flat-shaded placement (`vs_tri_inst_flat`): its vertices are shared between triangles, so+/// the face's normal is the triangle's own plane, worked out per fragment. The fragment gets its+/// position from the eye (`rp`): small near what is looked at, so the plane comes out exact at+/// any zoom however far from the origin the part stands, and few values per vertex (a tiled GPU+/// stores every vertex's outputs: more of them cost more than the triangles' shared vertices+/// save).+struct FOut {+ @builtin(position) pos: vec4<f32>,+ @location(0) rp: vec3<f32>,+ @location(1) c: vec4<f32>,+};++@vertex+fn vs_tri_inst_flat(+ @location(0) p: vec3<f32>,+ @location(3) r0: vec4<f32>,+ @location(4) r1: vec4<f32>,+ @location(5) r2: vec4<f32>,+ @location(6) c: vec4<f32>,+) -> FOut {+ let q = vec4<f32>(p, 1.0);+ let wp = vec3<f32>(dot(r0, q), dot(r1, q), dot(r2, q));+ var o: FOut;+ o.pos = u.vp * vec4<f32>(wp, 1.0);+ o.rp = wp - u.eye.xyz;+ o.c = c;+ return o;+}++/// The fragment of a flat-shaded placement as the other triangles' fragments are: its normal+/// the outward normal of its triangle (toward the eye on a front face, away on a back face, as+/// the triangles are wound outward).+fn flat_fragment(i: FOut, front: bool) -> TOut {+ var n = cross(dpdx(i.rp), dpdy(i.rp));+ let toward = select(u.back.xyz, -i.rp, u.eye.w > 0.5);+ n = n * inverseSqrt(max(dot(n, n), 1e-30));+ if ((dot(n, toward) < 0.0) == front) { n = -n; }+ var o: TOut;+ o.pos = i.pos;+ o.n = n;+ o.c = i.c;+ o.wp = i.rp + u.eye.xyz;+ return o;+}++@fragment+fn fs_solid_flat(i: FOut, @builtin(front_facing) front: bool) -> @location(0) vec4<f32> {+ let t = flat_fragment(i, front);+ let c = solid(t, front);+ return c;+}++@fragment+fn fs_solid_cut_flat(i: FOut, @builtin(front_facing) front: bool) -> CutOut {+ let t = flat_fragment(i, front);+ var o: CutOut;+ o.depth = pushed(cap_depth(t.wp, t.pos.z));+ o.c = solid(t, front);+ return o;+}++@fragment+fn fs_ao_depth_flat(i: FOut, @builtin(front_facing) front: bool) -> AoDepth {+ let t = flat_fragment(i, front);+ return opaque_depth(t, front);+}++/// Opaque model surfaces: cut by the section plane/// Opaque model surfaces: cut by the section plane, the inside shows as a flat cap colour.@fragmentfn fs_solid(i: TOut, @builtin(front_facing) front: bool) -> @location(0) vec4<f32> {let c = solid(i, front);@@ -150,6 +239,11 @@ struct AoDepth {@fragmentfn fs_ao_depth(i: TOut, @builtin(front_facing) front: bool) -> AoDepth {+ return opaque_depth(i, front);+}++/// The AO prepass's depth of an opaque surface's fragment.+fn opaque_depth(i: TOut, front: bool) -> AoDepth {if (clipped(i.wp) || length(i.n) < 0.5) { discard; }var depth = i.pos.z;if (!front && length(u.clip.xyz) > 0.5) { depth = cap_depth(i.wp, i.pos.z); }diff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rsindex 4927c55204..fad3082660 100644--- a/crates/doc/src/eval.rs+++ b/crates/doc/src/eval.rs@@ -163,6 +163,50 @@ impl ModelBody {.clone()}+ /// Identity of this body's display geometry, without meshing it: the cell its mesh is kept+ /// in, shared by every clone of the body (timeline snapshots, world states that place it+ /// unchanged) and, while it is held, by no other body.+ pub fn display_identity(&self) -> Arc<dyn std::any::Any + Send + Sync> {+ self.mesh.clone()+ }++ /// [`ModelBody::mesh`] as a shared mesh and the move that places it: for a rigid placement+ /// of a definition, the definition's own mesh (the same one for every placement of it) and+ /// the placement; for any other body its own mesh, unmoved. The mesh moved by the matrix is+ /// `mesh()`, so a viewport can draw every placement of a part from one copy of its+ /// triangles, without making the moved copies.+ pub fn mesh_in_place(&self) -> (Arc<Mesh>, crate::Mat) {+ match self.mesh_placement.as_deref() {+ Some(placed) => placed.source_mesh(),+ None => (self.mesh(), crate::IDENTITY),+ }+ }++ /// The box of [`ModelBody::mesh`] without making a placement's moved copy: the shared mesh's+ /// points, moved.+ pub fn mesh_bounds(&self) -> solidcraft_geom::Aabb3 {+ if let Some(mesh) = self.cached_mesh() {+ return mesh.bounds();+ }+ let (mesh, m) = self.mesh_in_place();+ if crate::is_identity(&m) {+ return mesh.bounds();+ }+ mesh.positions.iter().fold(solidcraft_geom::Aabb3::EMPTY, |mut b, p| {+ b.add(crate::apply_point(&m, *p));+ b+ })+ }++ /// [`ModelBody::plan_mesh_at`] as a shared mesh and the move that places it, as+ /// [`ModelBody::mesh_in_place`] does for the reference mesh.+ pub fn plan_mesh_in_place_at(&self, q: crate::display_quality::DisplayQuality) -> Option<(Arc<Mesh>, crate::Mat)> {+ match self.mesh_placement.as_deref() {+ Some(placed) => placed.source_plan_mesh(q, &self.name),+ None => Some((self.plan_mesh_at(q)?, crate::IDENTITY)),+ }+ }+/// [`ModelBody::plan_mesh`] if it is made already; otherwise it is made on a worker thread/// (once, however often this is asked) and `None` comes back meanwhile, so a caller drawing a/// frame (a face highlighted under the pointer) is not held up by a large body's plandiff --git a/crates/doc/src/placed_mesh.rs b/crates/doc/src/placed_mesh.rsindex 6da3c4e083..2131f89db8 100644--- a/crates/doc/src/placed_mesh.rs+++ b/crates/doc/src/placed_mesh.rs@@ -59,6 +59,18 @@ impl PlacedMesh {/// The definition's display plan mesh at quality `q`, moved here.pub(super) fn plan_mesh(&self, q: crate::display_quality::DisplayQuality, name: &str) -> Option<Arc<Mesh>> {+ let (source, _) = self.source_plan_mesh(q, name)?;+ Some(Arc::new(self.moved(&source)))+ }++ /// The definition's reference mesh (shared by every placement of it) and this placement.+ pub(super) fn source_mesh(&self) -> (Arc<Mesh>, crate::Mat) {+ (reference_mesh(&self.body, &self.mesh, self.tolerance), self.transform)+ }++ /// The definition's display plan mesh at quality `q` (shared by every placement of it) and+ /// this placement.+ pub(super) fn source_plan_mesh(&self, q: crate::display_quality::DisplayQuality, name: &str) -> Option<(Arc<Mesh>, crate::Mat)> {let cell = self.plan_meshes.get(q.index())?;let source = cell.get_or_init(|| {@@ -66,7 +78,7 @@ impl PlacedMesh {self.body.display_mesh_of(&plan).ok().map(Arc::new)}).clone()?;- Some(Arc::new(self.moved(&source)))+ Some((source, self.transform))}/// `source` (in the definition's place) moved by this placement.@@ -150,6 +162,44 @@ mod tests {assert!(Arc::ptr_eq(&mesh, &nested.mesh()));}+ /// A placement hands out its definition's own meshes and its move without making the moved+ /// copy: every placement of a part gives the same mesh, and that mesh moved is the+ /// placement's own.+ #[test]+ fn placements_share_their_definitions_meshes_in_place() {+ use crate::display_quality::DisplayQuality;+ let source = ModelBody::new("Part".into(), kernel::cylinder(Vec3::ZERO, Vec3::Z, 2., 8.).unwrap(), 1);+ let placed: Vec<ModelBody> =+ [crate::rigid(Vec3::new(10., 20., 30.), Vec3::ZERO, Vec3::Z, 0.7), crate::rigid(Vec3::new(-4., 5., 1.), Vec3::ZERO, Vec3::X, 1.1)]+ .iter()+ .map(|m| {+ let mut p = ModelBody::new("Copy".into(), kernel::transform_matrix(&source.body, *m).unwrap(), 1);+ p.mesh_placement = Some(Arc::new(PlacedMesh::new(&source, m).unwrap()));+ p+ })+ .collect();+ let (own, identity) = source.mesh_in_place();+ assert_eq!(identity, crate::IDENTITY);+ let q = DisplayQuality::parse("normal").unwrap();+ for p in &placed {+ let (mesh, m) = p.mesh_in_place();+ assert!(Arc::ptr_eq(&mesh, &own), "the definition's mesh, not a copy");+ let bounds = p.mesh_bounds();+ assert!(p.cached_mesh().is_none(), "no moved copy is made");+ let (plan_mesh, pm) = p.plan_mesh_in_place_at(q).unwrap();+ assert!(Arc::ptr_eq(&plan_mesh, &source.plan_mesh_at(q).unwrap()));+ assert_eq!(pm, m);+ let moved = p.mesh();+ let exact = moved.bounds();+ assert!(bounds.min.dist(exact.min) < 1e-9 && bounds.max.dist(exact.max) < 1e-9, "{bounds:?} vs {exact:?}");+ for (a, b) in mesh.positions.iter().zip(&moved.positions) {+ assert!(crate::apply_point(&m, *a).dist(*b) < 1e-9);+ }+ assert!(!Arc::ptr_eq(&p.display_identity(), &source.display_identity()), "each placement is its own body");+ assert!(Arc::ptr_eq(&p.display_identity(), &p.clone().display_identity()), "clones are the same body");+ }+ }+/// Placed parts share their definition's display plan (#3044): the definition is planned/// once, every placement moves that plan, and a moved plan evaluates to the definition's/// points moved, on every kind of surface (planes, revolved and spline surfaces).diff --git a/crates/engine/src/view.rs b/crates/engine/src/view.rsindex 64863cc01e..c45f30fd80 100644--- a/crates/engine/src/view.rs+++ b/crates/engine/src/view.rs@@ -110,7 +110,7 @@ pub fn bounds(s: &Session) -> Aabb3 {/// [`bounds`], with the browser's Sketches folder shown (`sketches`) or hidden.pub fn visible_bounds(s: &Session, sketches: bool) -> Aabb3 {- bounds_by(s, sketches, |body| body.mesh().bounds())+ bounds_by(s, sketches, |body| body.mesh_bounds())}/// [`visible_bounds`] without meshing anything: a body not meshed yet counts with its outlinediff --git a/crates/gpu/src/view.rs b/crates/gpu/src/view.rsindex c1b162c740..72a757301d 100644--- a/crates/gpu/src/view.rs+++ b/crates/gpu/src/view.rs@@ -21,6 +21,9 @@ pub const TRI_SIZE: usize = 28;pub const PBR_SIZE: usize = pbr::VERTEX_SIZE;/// Line instance: a, b (3 × f32 each), colour (4 × u8), width in pixels (f32).pub const LINE_SIZE: usize = 32;+/// Placement of an [`InstancedMesh`]: the rows of its rigid move (3 × 4 f32; a point's x, y and z+/// are each row's dot product with (p, 1)), then its colour (4 × u8).+pub const INSTANCE_SIZE: usize = 52;/// The shader's `U`: the view-projection matrix, 10 `vec4`s (the tenth carries the ambient/// occlusion radius), the 8 analysis colours, their flags and the depth direction/// (`uniform_bytes`).@@ -34,6 +37,154 @@ pub struct PlannedBody {pub face_colors: Vec<[u8; 4]>,}+/// A vertex of [`SharedTris`]: position and normal (3 × f32 each).+pub const SHARED_SIZE: usize = 24;++/// A mesh's triangles as an [`InstancedMesh`] draws them: each vertex once, shared by the+/// triangles that meet there, and the triangles as indices into them, so the GPU transforms each+/// vertex once rather than once per triangle corner.+#[derive(Default)]+pub struct SharedTris {+ /// [`SHARED_SIZE`] bytes per vertex, in the part's own frame.+ pub vertices: Vec<u8>,+ /// Three per triangle.+ pub indices: Vec<u32>,+ /// Every triangle is flat (its corners share one normal, as an STL's facets do): vertices+ /// are shared by position alone, and each fragment takes its triangle's own normal.+ pub flat: bool,+ /// The box around the vertices (min, max), in the part's own frame: a placement whose box+ /// is out of the view is not drawn.+ pub bounds: [[f32; 3]; 2],+}++impl SharedTris {+ /// `mesh`'s triangles with their vertices shared: by position and normal, or by position+ /// alone when every triangle is flat.+ pub fn new(mesh: &solidcraft_geom::Mesh) -> SharedTris {+ let corner = |i: u32| Some((mesh.positions.get(i as usize)?.to_f32(), mesh.normals.get(i as usize)?.to_f32()));+ let bits = |v: [f32; 3]| v.map(|x| (x + 0.0).to_bits());+ let flat = mesh.triangles.iter().all(|t| {+ let [a, b, c] = t.map(|i| corner(i).map(|(_, n)| bits(n)));+ a == b && b == c+ });+ let mut out = SharedTris { flat, ..Default::default() };+ out.indices.reserve_exact(mesh.triangles.len() * 3);+ let mut seen: std::collections::HashMap<[u32; 6], u32> = std::collections::HashMap::with_capacity(mesh.positions.len());+ for t in &mesh.triangles {+ let Some(corners) = t.iter().map(|i| corner(*i)).collect::<Option<Vec<_>>>() else { continue };+ for (p, n) in corners {+ let [x, y, z] = bits(p);+ let [a, b, c] = if flat { [0; 3] } else { bits(n) };+ let next = u32::try_from(out.vertices.len() / SHARED_SIZE).unwrap_or(u32::MAX);+ let index = *seen.entry([x, y, z, a, b, c]).or_insert_with(|| {+ for v in p.iter().chain(&n) {+ out.vertices.extend_from_slice(&v.to_le_bytes());+ }+ next+ });+ out.indices.push(index);+ }+ }+ out.vertices.shrink_to_fit();+ let mut lo = [f32::INFINITY; 3];+ let mut hi = [f32::NEG_INFINITY; 3];+ for v in 0..out.vertices.len() / SHARED_SIZE {+ let (p, _) = out.vertex(v as u32);+ for k in 0..3 {+ lo[k] = lo[k].min(p[k]);+ hi[k] = hi[k].max(p[k]);+ }+ }+ 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;+ let f = |k: usize| self.vertices.get(at + 4 * k..at + 4 * k + 4).and_then(|x| x.try_into().ok()).map_or(0.0, f32::from_le_bytes);+ ([f(0), f(1), f(2)], [f(3), f(4), f(5)])+ }++ /// Each triangle's corners (position, and the normal they are lit with: a flat triangle's+ /// own), in the part's frame.+ pub fn corners(&self) -> impl Iterator<Item = [([f32; 3], [f32; 3]); 3]> + '_ {+ self.indices.as_chunks::<3>().0.iter().map(move |t| {+ let c = t.map(|i| self.vertex(i));+ if !self.flat {+ return c;+ }+ let [a, b, d] = c.map(|(p, _)| p);+ let (u, v) = ([b[0] - a[0], b[1] - a[1], b[2] - a[2]], [d[0] - a[0], d[1] - a[1], d[2] - a[2]]);+ let n = [u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2], u[0] * v[1] - u[1] * v[0]];+ let len = (n[0] * n[0] + n[1] * n[1] + n[2] * n[2]).sqrt();+ let n = if len > 0.0 { n.map(|x| x / len) } else { [0.0; 3] };+ c.map(|(p, _)| (p, n))+ })+ }++ /// The triangles unshared ([`SHARED_SIZE`] bytes per corner, three per triangle): for a mesh+ /// too large for one buffer.+ fn unshared(&self) -> Vec<u8> {+ let mut out = Vec::with_capacity(self.indices.len() * SHARED_SIZE);+ for t in self.corners() {+ for (p, n) in t {+ for v in p.iter().chain(&n) {+ out.extend_from_slice(&v.to_le_bytes());+ }+ }+ }+ out+ }+}++/// 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)]+pub struct InstancedMesh {+ /// Names exactly these triangles: while it comes back with the same triangles, their buffers+ /// are kept and only the placements are uploaded again.+ pub key: u64,+ /// The opaque triangles, in the part's own frame.+ pub tris: Arc<SharedTris>,+ /// The placements, [`INSTANCE_SIZE`] bytes each ([`InstancedMesh::place`]).+ pub instances: Vec<u8>,+}++impl InstancedMesh {+ /// Add a placement: `rows` of its rigid move (see [`INSTANCE_SIZE`]) and its colour.+ pub fn place(&mut self, rows: [[f32; 4]; 3], color: [u8; 4]) {+ for v in rows.iter().flatten() {+ self.instances.extend_from_slice(&v.to_le_bytes());+ }+ self.instances.extend_from_slice(&color);+ }++ /// Its triangles at every placement, as the GPU draws them, appended to `out` (laid out as+ /// [`GpuScene::tris`]).+ pub fn expand_into(&self, out: &mut Vec<u8>) {+ 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 inst in self.instances.as_chunks::<INSTANCE_SIZE>().0 {+ let row = |r: usize| [f(inst, 16 * r), f(inst, 16 * r + 4), f(inst, 16 * r + 8), f(inst, 16 * r + 12)];+ let rows = [row(0), row(1), row(2)];+ let color = inst.get(48..52).unwrap_or(&[0; 4]);+ for (p, n) in self.tris.corners().flatten() {+ let moved = rows.map(|r| r[0] * p[0] + r[1] * p[1] + r[2] * p[2] + r[3]);+ let turned = rows.map(|r| r[0] * n[0] + r[1] * n[1] + r[2] * n[2]);+ for x in moved.iter().chain(&turned) {+ out.extend_from_slice(&x.to_le_bytes());+ }+ out.extend_from_slice(color);+ }+ }+ }++ /// How many placements it is drawn at.+ pub fn count(&self) -> usize {+ self.instances.len() / INSTANCE_SIZE+ }+}+/// CPU-side geometry waiting to be uploaded. The model scene changes with the design; the/// highlight scene (hover, selection, the origin widget) changes often and is small.#[derive(Default, Clone)]@@ -68,6 +219,8 @@ pub struct GpuScene {pub guide_lines: Vec<u8>,/// Opaque bodies drawn from their plans on the GPU, like `tris`.pub planned: Vec<PlannedBody>,+ /// Opaque bodies drawn as placements of shared triangles, like `tris`.+ pub instanced: Vec<InstancedMesh>,/// The model's bodies, a few at a time, drawn before the loose geometry above (`tris`,/// `trans`, `lines` and `hidden` of each block, in order, then the scene's own). A block/// that comes back unchanged keeps its buffers: a design changing one body at a time (an@@ -86,6 +239,9 @@ impl GpuScene {out.lines.extend_from_slice(&block.bytes.lines);out.hidden.extend_from_slice(&block.bytes.hidden);}+ for m in std::mem::take(&mut self.instanced) {+ m.expand_into(&mut out.tris);+ }out.tris.append(&mut self.tris);out.trans.append(&mut self.trans);out.lines.append(&mut self.lines);@@ -380,6 +536,98 @@ struct PlannedDraw {colors: wgpu::Buffer,}+/// An [`InstancedMesh`]'s triangles on the GPU (kept while its key comes back).+enum SharedGpu {+ /// Shared vertices and their indices.+ Indexed { vertices: wgpu::Buffer, indices: wgpu::Buffer, count: u32 },+ /// Too large for one buffer: unshared, in as many buffers as it takes.+ Unshared(Batch),+}++impl SharedGpu {+ fn new(device: &wgpu::Device, tris: &SharedTris) -> Option<SharedGpu> {+ let limit = device.limits().max_buffer_size;+ let index_bytes = (tris.indices.len() * 4) as u64;+ if tris.vertices.is_empty() || tris.indices.is_empty() {+ return None;+ }+ if tris.vertices.len() as u64 > limit || index_bytes > limit {+ return upload(device, "sc_instanced_unshared", &tris.unshared(), SHARED_SIZE).map(SharedGpu::Unshared);+ }+ let buffer = |label: &str, contents: &[u8], usage: wgpu::BufferUsages| {+ device.create_buffer_init(&wgpu::util::BufferInitDescriptor { label: Some(label), contents, usage })+ };+ let indices: Vec<u8> = tris.indices.iter().flat_map(|i| i.to_le_bytes()).collect();+ Some(SharedGpu::Indexed {+ vertices: buffer("sc_instanced_vertices", &tris.vertices, wgpu::BufferUsages::VERTEX),+ indices: buffer("sc_instanced_indices", &indices, wgpu::BufferUsages::INDEX),+ count: u32::try_from(tris.indices.len()).unwrap_or(u32::MAX),+ })+ }+}++/// 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,+/// before the near plane or past the far one). Tested on the clip-space corners, so it holds for+/// corners behind the eye too.+pub fn placed_box_in_view(rows: &[[f32; 4]; 3], bounds: &[[f32; 3]; 2], vp: &[[f32; 4]; 4]) -> bool {+ let [lo, hi] = bounds;+ if !lo.iter().chain(hi).all(|x| x.is_finite()) {+ return true;+ }+ // Per plane, whether every corner so far is outside it: x > w, -x > w, y > w, -y > w, z < 0, z > w.+ let mut out = [true; 6];+ for i in 0..8 {+ let p = [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 w = rows.map(|r| r[0] * p[0] + r[1] * p[1] + r[2] * p[2] + r[3]);+ let c: [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]);+ let outside = [c[0] > c[3], -c[0] > c[3], c[1] > c[3], -c[1] > c[3], c[2] < 0.0, c[2] > c[3]];+ for (o, x) in out.iter_mut().zip(outside) {+ *o &= x;+ }+ }+ !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 {+ tris: Arc<SharedGpu>,+ flat: bool,+ 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>>,+}++impl InstancedDraw {+ /// Draw every placement with `pipeline` (the placements in vertex buffer 1).+ fn draw(&self, pass: &mut wgpu::RenderPass<'_>) {+ if self.count == 0 {+ return;+ }+ pass.set_vertex_buffer(1, self.instances.slice(..));+ match &*self.tris {+ SharedGpu::Indexed { vertices, indices, count } => {+ pass.set_vertex_buffer(0, vertices.slice(..));+ pass.set_index_buffer(indices.slice(..), wgpu::IndexFormat::Uint32);+ pass.draw_indexed(0..*count, 0, 0..self.count);+ }+ SharedGpu::Unshared(batch) => {+ for (buffer, count) in &batch.parts {+ pass.set_vertex_buffer(0, buffer.slice(..));+ pass.draw(0..*count, 0..self.count);+ }+ }+ }+ }+}+/// A scene block on the GPU, with the bytes it was uploaded from.struct BlockGpu {bytes: Arc<BlockBytes>,@@ -425,6 +673,10 @@ struct Batches {guide_trans: Option<Batch>,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>)>,/// 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>)>,@@ -442,6 +694,7 @@ impl Batches {Some((tess, encoder)) => self.planned(device, tess, encoder, &sc.planned),None => Vec::new(),};+ self.instanced = self.instanced(device, &sc.instanced);let mut kept = std::mem::take(&mut self.blocks);let mut blocks: Vec<&BlockGpu> = Vec::with_capacity(sc.blocks.len());for block in &sc.blocks {@@ -480,6 +733,70 @@ impl Batches {}}+ /// The instanced meshes on the GPU: triangles uploaded once per key (kept while the key comes+ /// back with the same bytes), placements every time.+ fn instanced(&mut self, device: &wgpu::Device, meshes: &[InstancedMesh]) -> Vec<InstancedDraw> {+ let mut kept = std::mem::take(&mut self.instanced_tris);+ let mut out = Vec::with_capacity(meshes.len());+ for m in meshes {+ let count = u32::try_from(m.count()).unwrap_or(u32::MAX);+ 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);+ }+ out+ }++ /// 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]) {+ 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+ .placements+ .as_chunks::<INSTANCE_SIZE>()+ .0+ .iter()+ .enumerate()+ .filter(|(_, 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)+ })+ .map(|(i, _)| i as u32)+ .collect();+ 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);+ }+ d.count = u32::try_from(shown.len()).unwrap_or(u32::MAX);+ d.shown = Some(shown);+ }+ }+/// The planned bodies on the GPU: in chunks of at most `MAX_BATCH` vertices (one for any/// ordinary scene), each uploaded and evaluated in one dispatch and drawn in one call. A/// chunk whose plans are unchanged is not evaluated again; colours are rebuilt each time.@@ -555,6 +872,13 @@ pub struct Renderer {/// colours per vertex, indexed).tri_planned: wgpu::RenderPipeline,tri_cut_planned: Option<(wgpu::RenderPipeline, wgpu::RenderPipeline)>,+ /// `tri` and `tri_cut` for instanced meshes (shared triangles, a move and colour per+ /// placement).+ tri_instanced: wgpu::RenderPipeline,+ tri_cut_instanced: Option<(wgpu::RenderPipeline, wgpu::RenderPipeline)>,+ /// `tri_instanced` and `tri_cut_instanced` for flat triangles.+ tri_instanced_flat: 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>,/// While a section is shown (when the depth buffer has a stencil): `tri` marking where the@@ -741,6 +1065,50 @@ fn planned_layout() -> wgpu::VertexBufferLayout<'static> {wgpu::VertexBufferLayout { array_stride: crate::VERTEX_STRIDE, step_mode: wgpu::VertexStepMode::Vertex, attributes: &A }}+/// An instanced mesh's vertices ([`SHARED_SIZE`]).+fn shared_layout() -> wgpu::VertexBufferLayout<'static> {+ const A: [wgpu::VertexAttribute; 2] = wgpu::vertex_attr_array![0 => Float32x3, 1 => Float32x3];+ wgpu::VertexBufferLayout { array_stride: SHARED_SIZE as u64, step_mode: wgpu::VertexStepMode::Vertex, attributes: &A }+}++/// An instanced mesh's placements ([`INSTANCE_SIZE`]), one per instance.+fn instance_layout() -> wgpu::VertexBufferLayout<'static> {+ const A: [wgpu::VertexAttribute; 4] = wgpu::vertex_attr_array![3 => Float32x4, 4 => Float32x4, 5 => Float32x4, 6 => Unorm8x4];+ wgpu::VertexBufferLayout { array_stride: INSTANCE_SIZE as u64, step_mode: wgpu::VertexStepMode::Instance, attributes: &A }+}++/// Where an opaque triangle pipeline reads its vertices from.+#[derive(Clone, Copy, PartialEq, Eq, Debug)]+enum TriSource {+ /// Built on the CPU ([`tri_layout`]).+ Built,+ /// Evaluated from display plans on the GPU ([`planned_layout`], [`color_layout`]), indexed.+ Planned,+ /// Shared vertices ([`shared_layout`]) drawn at each placement ([`instance_layout`]).+ Instanced,+ /// [`TriSource::Instanced`] for flat triangles: each fragment takes its triangle's normal.+ InstancedFlat,+}++impl TriSource {+ /// The vertex shader entry point.+ fn entry(self) -> &'static str {+ match self {+ TriSource::Instanced => "vs_tri_inst",+ TriSource::InstancedFlat => "vs_tri_inst_flat",+ TriSource::Built | TriSource::Planned => "vs_tri",+ }+ }++ /// The fragment shader entry point standing for `fs` (written for [`TriSource::Built`]).+ fn fragment(self, fs: &str) -> String {+ match self {+ TriSource::InstancedFlat => format!("{fs}_flat"),+ _ => fs.to_string(),+ }+ }+}+/// A planned body's colours, one per vertex.fn color_layout() -> wgpu::VertexBufferLayout<'static> {const A: [wgpu::VertexAttribute; 1] = wgpu::vertex_attr_array![2 => Unorm8x4];@@ -976,14 +1344,20 @@ impl Renderer {});let built = [Some(tri_layout())];let evaluated = [Some(planned_layout()), Some(color_layout())];- let solid = |label: &str, fs: &str, cull: Option<wgpu::Face>, ds: Option<wgpu::DepthStencilState>, planned: bool| {+ let placed = [Some(shared_layout()), Some(instance_layout())];+ let solid = |label: &str, fs: &str, cull: Option<wgpu::Face>, ds: Option<wgpu::DepthStencilState>, source: TriSource| {+ let fs = source.fragment(fs);device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {label: Some(label),layout: Some(&solid_layout),vertex: wgpu::VertexState {module: &module,- entry_point: Some("vs_tri"),- buffers: if planned { &evaluated[..] } else { &built[..] },+ entry_point: Some(source.entry()),+ buffers: match source {+ TriSource::Built => &built[..],+ TriSource::Planned => &evaluated[..],+ TriSource::Instanced | TriSource::InstancedFlat => &placed[..],+ },compilation_options: Default::default(),},primitive: wgpu::PrimitiveState { topology: wgpu::PrimitiveTopology::TriangleList, cull_mode: cull, ..Default::default() },@@ -991,7 +1365,7 @@ impl Renderer {multisample: wgpu::MultisampleState { count: t.samples.max(1), mask: !0, alpha_to_coverage_enabled: false },fragment: Some(wgpu::FragmentState {module: &module,- entry_point: Some(fs),+ entry_point: Some(&fs),targets: &[Some(wgpu::ColorTargetState { format: t.format, blend: None, write_mask: wgpu::ColorWrites::ALL })],compilation_options: Default::default(),}),@@ -1000,7 +1374,7 @@ impl Renderer {})};// While a section is shown: the stencil marking and the cap (see `Renderer::tri_cut`).- let cut = |planned: bool| {+ let cut = |source: TriSource| {t.depth.filter(|f| f.has_stencil_aspect()).map(|format| {// The visible surface marks the stencil: 1 where it is a back face (the cap).use wgpu::StencilOperation::{Keep, Replace, Zero};@@ -1022,8 +1396,8 @@ impl Renderer {bias: Default::default(),};(- solid("sc_tris_mark", "fs_solid", None, Some(mark), planned),- solid("sc_tris_cap", "fs_solid_cut", Some(wgpu::Face::Front), Some(cap), planned),+ solid("sc_tris_mark", "fs_solid", None, Some(mark), source),+ solid("sc_tris_cap", "fs_solid_cut", Some(wgpu::Face::Front), Some(cap), source),)})};@@ -1131,10 +1505,20 @@ impl Renderer {sampler,textures: Default::default(),quads: Vec::new(),- tri: solid("sc_tris", "fs_solid", None, pushed(wgpu::CompareFunction::Less, true, FACE_BIAS), false),- tri_cut: cut(false),- tri_planned: solid("sc_tris_planned", "fs_solid", None, pushed(wgpu::CompareFunction::Less, true, FACE_BIAS), true),- tri_cut_planned: cut(true),+ tri: solid("sc_tris", "fs_solid", None, pushed(wgpu::CompareFunction::Less, true, FACE_BIAS), TriSource::Built),+ tri_cut: cut(TriSource::Built),+ tri_planned: solid("sc_tris_planned", "fs_solid", None, pushed(wgpu::CompareFunction::Less, true, FACE_BIAS), TriSource::Planned),+ tri_cut_planned: cut(TriSource::Planned),+ tri_instanced: solid("sc_tris_instanced", "fs_solid", None, pushed(wgpu::CompareFunction::Less, true, FACE_BIAS), TriSource::Instanced),+ tri_cut_instanced: cut(TriSource::Instanced),+ tri_instanced_flat: solid(+ "sc_tris_instanced_flat",+ "fs_solid",+ None,+ pushed(wgpu::CompareFunction::Less, true, FACE_BIAS),+ TriSource::InstancedFlat,+ ),+ tri_cut_instanced_flat: cut(TriSource::InstancedFlat),tess,access_bgl,access_bind,@@ -1309,6 +1693,7 @@ impl Renderer {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);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@@ -1441,21 +1826,36 @@ impl Renderer {pass.draw_indexed(0..d.mesh.index_count, 0, 0..1);}};+ // 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);+ }+ };let sectioned = cb.clip[..3].iter().map(|c| c * c).sum::<f32>() > 0.25;- match (res.tri_cut.as_ref().filter(|_| sectioned), res.tri_cut_planned.as_ref()) {- (Some((mark, cap)), Some((mark_planned, cap_planned))) => {+ match (+ res.tri_cut.as_ref().filter(|_| sectioned),+ res.tri_cut_planned.as_ref(),+ res.tri_cut_instanced.as_ref(),+ res.tri_cut_instanced_flat.as_ref(),+ ) {+ (Some((mark, cap)), Some((mark_planned, cap_planned)), Some((mark_instanced, cap_instanced)), Some((mark_flat, cap_flat))) => {pass.set_stencil_reference(1);tris(pass, mark, &m.tris);tris(pass, mark, &pv.tris);planned(pass, mark_planned);+ instanced(pass, mark_instanced, mark_flat);tris(pass, cap, &m.tris);tris(pass, cap, &pv.tris);planned(pass, cap_planned);+ instanced(pass, cap_instanced, cap_flat);}_ => {tris(pass, &res.tri, &m.tris);tris(pass, &res.tri, &pv.tris);planned(pass, &res.tri_planned);+ instanced(pass, &res.tri_instanced, &res.tri_instanced_flat);}}tris(pass, &res.pbr, &m.pbr);@@ -1609,6 +2009,72 @@ pub fn analysis_colors(c: &solidcraft_render::AnalysisColors) -> [f32; 36] {#[cfg(test)]mod tests {+ /// A placed box is kept while any of it may be in view, and left out only when it lies+ /// wholly past one side of the view: in an orthographic view and a perspective one, behind+ /// the eye too.+ #[test]+ fn placed_boxes_out_of_view_are_left_out() {+ use super::placed_box_in_view;+ 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: x and y from -10 to 10 on screen, depth z from 0 (near) to 1 (far) over+ // -100..100 (columns).+ 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]];+ assert!(placed_box_in_view(&at(0.0, 0.0, 0.0), &unit, &ortho));+ assert!(placed_box_in_view(&at(9.5, 9.5, 0.0), &unit, &ortho), "partly in view");+ for (x, y, z) in [(11.0, 0.0, 0.0), (-12.0, 0.0, 0.0), (0.0, 11.0, 0.0), (0.0, -12.0, 0.0), (0.0, 0.0, -120.0), (0.0, 0.0, 120.0)] {+ assert!(!placed_box_in_view(&at(x, y, z), &unit, &ortho), "{x} {y} {z}");+ }+ // Turned a quarter about z, the box at x 10.5 reaches back into view (x from 9.5).+ let turned = [[0.0, -1.0, 0.0, 10.5], [1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0]];+ assert!(placed_box_in_view(&turned, &unit, &ortho));+ // Perspective, looking down -z from the origin (w = -z, 90° field of view, near 1).+ 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]];+ assert!(placed_box_in_view(&at(-0.5, -0.5, -10.0), &unit, &persp));+ assert!(!placed_box_in_view(&at(-0.5, -0.5, 10.0), &unit, &persp), "behind the eye");+ assert!(!placed_box_in_view(&at(30.0, -0.5, -10.0), &unit, &persp), "beside the view");+ assert!(placed_box_in_view(&at(-0.5, -0.5, -20.0), &[[0.0, 0.0, 0.0], [1.0, 1.0, 21.0]], &persp), "from in front of the eye to behind it");+ // A box that is not finite is drawn (never culled by mistake).+ assert!(placed_box_in_view(&at(30.0, 0.0, -10.0), &[[f32::NAN; 3], [1.0; 3]], &persp));+ }++ /// 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.+ #[test]+ fn shared_tris_share_each_vertex_once() {+ use super::{SHARED_SIZE, SharedTris};+ use solidcraft_geom::{Mesh, Vec3};+ let p = [Vec3::new(0.0, 0.0, 0.0), Vec3::new(1.0, 0.0, 0.0), Vec3::new(1.0, 1.0, 0.0), Vec3::new(0.0, 1.0, 0.0)];+ // Two triangles of a square, each corner its own vertex (as an STL is read).+ let mut flat = Mesh::default();+ for t in [[0, 1, 2], [0, 2, 3]] {+ let base = flat.positions.len() as u32;+ flat.positions.extend(t.map(|i| p[i]));+ flat.normals.extend([Vec3::Z; 3]);+ flat.triangles.push([base, base + 1, base + 2]);+ }+ let shared = SharedTris::new(&flat);+ assert!(shared.flat);+ assert_eq!(shared.vertices.len() / SHARED_SIZE, 4, "the diagonal's ends are shared");+ assert_eq!(shared.indices.len(), 6);+ let corners: Vec<_> = shared.corners().flatten().collect();+ for (k, (q, n)) in corners.iter().enumerate() {+ assert_eq!(*q, flat.positions[k].to_f32());+ assert!((n[2] - 1.0).abs() < 1e-6, "{n:?}");+ }+ // Smooth: the same corners with different normals stay apart.+ let mut smooth = flat.clone();+ smooth.normals = vec![Vec3::Z, Vec3::Z, Vec3::new(0.0, 0.6, 0.8), Vec3::Z, Vec3::X, Vec3::new(0.0, 0.6, 0.8)];+ let shared = SharedTris::new(&smooth);+ assert!(!shared.flat);+ assert_eq!(shared.vertices.len() / SHARED_SIZE, 5, "corner 0 differs in normal only");+ let back: Vec<_> = shared.corners().flatten().map(|(_, n)| n).collect();+ assert_eq!(back, smooth.normals.iter().map(|n| n.to_f32()).collect::<Vec<_>>());+ // Indices past the vertices: the triangle is left out, nothing panics.+ smooth.triangles.push([0, 1, 99]);+ assert_eq!(SharedTris::new(&smooth).indices.len(), 6);+ }/// Only the FirePro under Metal skips GPU evaluation; the same card under another backend/// and other Metal GPUs keep it.diff --git a/crates/gpu/src/view/ao.rs b/crates/gpu/src/view/ao.rsindex 9381a20a24..ff876ad053 100644--- a/crates/gpu/src/view/ao.rs+++ b/crates/gpu/src/view/ao.rs@@ -6,7 +6,7 @@//! bits for portable integer texel reads. GLSL cannot load from a depth texture, and float//! colour attachments are not available on every GL adapter.-use super::{Batches, color_layout, depth_compare, far_depth, planned_layout, tri_layout};+use super::{Batches, TriSource, color_layout, depth_compare, far_depth, instance_layout, planned_layout, shared_layout, tri_layout};pub(super) struct Resources {pub layout: wgpu::BindGroupLayout,@@ -16,6 +16,8 @@ pub(super) struct Resources {size: [u32; 2],pipeline: wgpu::RenderPipeline,planned_pipeline: wgpu::RenderPipeline,+ instanced_pipeline: wgpu::RenderPipeline,+ instanced_flat_pipeline: wgpu::RenderPipeline,}fn texture(device: &wgpu::Device, layout: &wgpu::BindGroupLayout, size: [u32; 2]) -> (wgpu::TextureView, wgpu::TextureView, wgpu::BindGroup) {@@ -64,14 +66,19 @@ impl Resources {});let built = [Some(tri_layout())];let evaluated = [Some(planned_layout()), Some(color_layout())];- let pipeline = |planned: bool| {+ let placed = [Some(shared_layout()), Some(instance_layout())];+ let pipeline = |source: TriSource| {device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {label: Some("sc_ao_prepass"),layout: Some(&pipeline_layout),vertex: wgpu::VertexState {module,- entry_point: Some("vs_tri"),- buffers: if planned { &evaluated } else { &built },+ entry_point: Some(source.entry()),+ buffers: match source {+ TriSource::Built => &built[..],+ TriSource::Planned => &evaluated[..],+ TriSource::Instanced | TriSource::InstancedFlat => &placed[..],+ },compilation_options: Default::default(),},primitive: wgpu::PrimitiveState::default(),@@ -85,7 +92,7 @@ impl Resources {multisample: wgpu::MultisampleState::default(),fragment: Some(wgpu::FragmentState {module,- entry_point: Some("fs_ao_depth"),+ entry_point: Some(&source.fragment("fs_ao_depth")),targets: &[Some(wgpu::ColorTargetState {format: wgpu::TextureFormat::R32Uint,blend: None,@@ -97,10 +104,12 @@ impl Resources {cache: None,})};- let planned_pipeline = pipeline(true);- let pipeline = pipeline(false);+ let planned_pipeline = pipeline(TriSource::Planned);+ let instanced_pipeline = pipeline(TriSource::Instanced);+ let instanced_flat_pipeline = pipeline(TriSource::InstancedFlat);+ let pipeline = pipeline(TriSource::Built);let (depth, values, bind) = texture(device, &layout, [1, 1]);- Self { layout, bind, depth, values, size: [1, 1], pipeline, planned_pipeline }+ Self { layout, bind, depth, values, size: [1, 1], pipeline, planned_pipeline, instanced_pipeline, instanced_flat_pipeline }}pub fn prepare(@@ -159,6 +168,10 @@ 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);+ }}}}diff --git a/crates/ui-egui/src/display_lod.rs b/crates/ui-egui/src/display_lod.rsindex e62bf5c046..2d39bdae20 100644--- a/crates/ui-egui/src/display_lod.rs+++ b/crates/ui-egui/src/display_lod.rs@@ -41,11 +41,16 @@ pub(crate) fn enabled() -> bool {*ON.get_or_init(|| std::env::var("SOLIDCRAFT_DISPLAY_REFINE").map_or(true, |v| v != "0"))}-/// A body's identity here: the address of its reference mesh, which is shared by every copy of-/// the same body across timeline snapshots and held by the cache so the address stays its own.-pub(crate) fn body_id(b: &ModelBody) -> (usize, Arc<Mesh>) {- let m = b.mesh();- (Arc::as_ptr(&m) as usize, m)+/// What keeps a body's identity ([`body_id`]) its own while the cache holds it.+pub(crate) type Holder = Arc<dyn std::any::Any + Send + Sync>;++/// A body's identity here: the address of its [`ModelBody::display_identity`], which is shared by+/// every copy of the same body across timeline snapshots and held by the cache so the address+/// stays its own. Taking it meshes nothing: a part placed many times is drawn without making its+/// moved copies.+pub(crate) fn body_id(b: &ModelBody) -> (usize, Holder) {+ let holder = b.display_identity();+ (Arc::as_ptr(&holder) as *const () as usize, holder)}/// How the camera maps millimetres to pixels.@@ -118,7 +123,7 @@ pub(crate) struct Candidate<'a> {struct Entry {/// Keeps the body's id address its own while the entry lives.- _holder: Arc<Mesh>,+ _holder: Holder,refined: Refined,bytes: usize,used: u64,@@ -127,7 +132,7 @@ struct Entry {#[cfg(not(target_arch = "wasm32"))]struct Job {key: (usize, DisplayQuality, u8),- holder: Arc<Mesh>,+ holder: Holder,rx: std::sync::mpsc::Receiver<Refined>,}@@ -264,7 +269,7 @@ impl Lod {}}- fn insert(&mut self, key: (usize, DisplayQuality, u8), holder: Arc<Mesh>, refined: Refined) {+ fn insert(&mut self, key: (usize, DisplayQuality, u8), holder: Holder, refined: Refined) {let bytes = refined.as_ref().map_or(0, |(plan, mesh)| mesh_bytes(mesh) + plan.vertex_count() * 48 + mesh.triangles.len() * 12);self.cache.insert(key, Entry { _holder: holder, refined, bytes, used: self.clock });}@@ -464,8 +469,8 @@ mod tests {.map(|[a, b, c]| 10.0 - r((a + b + c) * (1.0 / 3.0))).fold(0.0, f64::max);assert!(sag <= q.refined_chord(b.body.size(), 3) * 1.01, "sag {sag}");- // The reference mesh never changes.- assert!(Arc::ptr_eq(&body_id(&b).1, &b.mesh()));+ // Refining never makes (or replaces) the reference mesh.+ assert!(b.cached_mesh().is_none());// Zoomed out a little: kept; far out: the chosen level.assert!(!lod.update(q, cand(3.0), &live));assert_eq!(lod.step(&b), 3);diff --git a/crates/ui-egui/src/gpu.rs b/crates/ui-egui/src/gpu.rsindex 4179ebedfe..f638f70d6d 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, LINE_SIZE, PBR_SIZE, PlannedBody, Renderer, SceneBlock, SceneSlot, TRI_SIZE,- supersampled_size,+ AccessMap, BlockBytes, Frame, GpuImage, GpuScene, GpuTarget, InstancedMesh, LINE_SIZE, PBR_SIZE, PlannedBody, Renderer, SHARED_SIZE, SceneBlock,+ SceneSlot, SharedTris, TRI_SIZE, supersampled_size,};/// A frame of the viewport as an egui paint callback.diff --git a/crates/ui-egui/src/open_meshing.rs b/crates/ui-egui/src/open_meshing.rsindex 088929e9fd..7428e81df9 100644--- a/crates/ui-egui/src/open_meshing.rs+++ b/crates/ui-egui/src/open_meshing.rs@@ -4,7 +4,7 @@//! file) and placed; the display meshes are made afterwards, off the UI thread. Until they all//! are, the viewport draws the bodies already meshed ([`shown_world`]), so the first parts show//! within moments and the window stays responsive while the rest come in. The first placement of-//! every part is meshed first: its other placements only move that mesh. The view is framed from+//! every part is meshed first: its other placements are drawn from that mesh. The view is framed from//! the bodies' outlines meanwhile, and framed again from the meshes when they are all made, unless//! the camera was moved in between. Editing the design meanwhile meshes the new world instead.//!@@ -71,10 +71,12 @@ impl Meshing {return;}if let Some(b) = world.bodies.get(i) {- let _ = b.mesh();+ // What the viewport draws and picks: a placed part's shared mesh, not a+ // moved copy of it (its placements are drawn as instances of it).+ let _ = b.mesh_in_place();if plans {let _ = b.display_plan();- let _ = b.plan_mesh();+ let _ = b.plan_mesh_in_place_at(solidcraft_engine::doc::display_quality::current());}}if let Ok(mut r) = ready.lock() {diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rsindex b754118bd3..cc10249499 100644--- a/crates/ui-egui/src/viewport.rs+++ b/crates/ui-egui/src/viewport.rs@@ -63,13 +63,16 @@ pub struct ViewportState {pick_bounds: std::sync::Mutex<Option<BodyBounds>>,/// The model scene's blocks of bodies by key, from the last scene built.pub(crate) blocks: std::sync::Mutex<std::collections::HashMap<u64, CachedBlock>>,+ /// 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>,/// 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>,/// The view and model the refinement was last chosen for.lod_view: u64,/// Each body mesh's box (the mesh held, so its address stays its own), from the last state.- mesh_bounds: std::sync::Mutex<std::collections::HashMap<usize, (std::sync::Arc<solidcraft_engine::geom::Mesh>, solidcraft_engine::geom::Aabb3)>>,+ mesh_bounds: std::sync::Mutex<MeshBounds>,/// Each shown body mesh's section index for the cut's normal (the mesh held, so its address/// stays its own): a Section Analysis dragged along its normal cuts through it.section_index: std::sync::Mutex<Vec<(std::sync::Arc<solidcraft_engine::geom::Mesh>, std::sync::Arc<solidcraft_engine::view::SectionIndex>)>>,@@ -535,7 +538,7 @@ fn update_refinement(app: &mut SolveApp, ctx: &egui::Context, proj: &Proj) {None => (shown && proj.cam.fov > 0.0 && lens.in_front(bx)).then_some(f64::INFINITY),};let err_px = crate::display_lod::error_px(q, b.body.size(), bx, on_screen, &lens);- candidates.push(crate::display_lod::Candidate { body: b, err_px, triangles: b.mesh().triangles.len() });+ candidates.push(crate::display_lod::Candidate { body: b, err_px, triangles: b.mesh_in_place().0.triangles.len() });}let busy = match app.viewport.lod.lock() {Ok(mut lod) => {@@ -557,14 +560,31 @@ pub(crate) struct CachedBlock {meshes: Vec<std::sync::Arc<solidcraft_engine::geom::Mesh>>,}+/// [`ViewportState::mesh_bounds`]: each box by the shared mesh it was measured on (held, so its+/// address stays its own) and the placement that moved it ([`ModelBody::mesh_in_place`]).+///+/// [`ModelBody::mesh_in_place`]: solidcraft_engine::doc::ModelBody::mesh_in_place+type MeshBounds = std::collections::HashMap<(usize, [u64; 16]), (std::sync::Arc<solidcraft_engine::geom::Mesh>, solidcraft_engine::geom::Aabb3)>;++/// [`ViewportState::instanced_tris`].+type InstancedTris = std::collections::HashMap<usize, (std::sync::Arc<solidcraft_engine::geom::Mesh>, std::sync::Arc<crate::gpu::SharedTris>)>;++/// A body alone is drawn as an instance of its triangles (shared vertices, indexed) from this many+/// triangles: a large imported mesh. Smaller ones are drawn so only when placed more than once.+const INSTANCE_ALONE: usize = 50_000;+/// One body as the model scene draws it.struct BodyDraw {+ /// Its mesh where it stands, or (with `place`) the shared mesh `place` moves there.mesh: std::sync::Arc<solidcraft_engine::geom::Mesh>,+ /// The move from `mesh` to where the body stands, for a body drawn as an instance.+ place: Option<solidcraft_engine::doc::Mat>,col: [u8; 4],faded: bool,opacity: f64,face_looks: std::collections::HashMap<usize, solidcraft_engine::doc::appearance::Look>,- /// Its faces are drawn from its plan on the GPU (only its edges are built here).+ /// Its faces are drawn elsewhere, from its plan on the GPU or as an instance of shared+ /// triangles (only its edges are built here).on_gpu: bool,}@@ -573,6 +593,7 @@ impl BodyDraw {fn key(&self, shaded: bool, edges: bool, hidden_edges: bool, edge_col: [u8; 4], hidden_col: [u8; 4]) -> u64 {let mut h = std::collections::hash_map::DefaultHasher::new();(std::sync::Arc::as_ptr(&self.mesh) as usize).hash(&mut h);+ self.place.iter().flatten().flatten().for_each(|v| v.to_bits().hash(&mut h));(self.col, self.faded, self.opacity.to_bits(), self.on_gpu, shaded, edges, hidden_edges, edge_col, hidden_col).hash(&mut h);let mut looks: Vec<_> = self.face_looks.iter().map(|(f, l)| (*f, l.color, l.opacity.to_bits())).collect();looks.sort_unstable();@@ -608,14 +629,16 @@ impl BodyDraw {}}}+ let at = |p: Vec3| self.place.as_ref().map_or(p, |m| solidcraft_engine::doc::apply_point(m, p)).to_f32();for (ei, e) in m.edges.iter().enumerate().filter(|_| edges) {if !m.edge_pickable(ei) || (shaded && !m.shaded_edge_visible(ei)) {continue;}for w in e.windows(2) {- out.line(w[0].to_f32(), w[1].to_f32(), edge_col, 1.3, false);+ let (a, b) = (at(w[0]), at(w[1]));+ out.line(a, b, edge_col, 1.3, false);if hidden_edges {- out.hidden_line(w[0].to_f32(), w[1].to_f32(), hidden_col, 1.0);+ out.hidden_line(a, b, hidden_col, 1.0);}}}@@ -654,6 +677,86 @@ fn push_block(made.insert(key, block);}+/// The model scene's instanced meshes: the shared triangles drawn more than once among the shown+/// bodies (or large: [`INSTANCE_ALONE`]), and each body placed from them.+struct Instances {+ /// Each candidate body's shared mesh and placement, by body name.+ candidates: std::collections::HashMap<String, (std::sync::Arc<solidcraft_engine::geom::Mesh>, solidcraft_engine::doc::Mat)>,+ /// The meshes drawn as instances, in the order their first placement came, by address.+ meshes: Vec<(std::sync::Arc<solidcraft_engine::geom::Mesh>, crate::gpu::InstancedMesh)>,+ kept: InstancedTris,+}++impl Instances {+ /// The shown bodies' shared meshes, keeping those more than one body is drawn from and large+ /// ones.+ fn new(app: &SolveApp, shown: &[&solidcraft_engine::doc::ModelBody], shaded: bool) -> Instances {+ let kept = app.viewport.instanced_tris.lock().map(|mut k| std::mem::take(&mut *k)).unwrap_or_default();+ let mut candidates = std::collections::HashMap::new();+ if shaded {+ let mut uses: std::collections::HashMap<usize, usize> = std::collections::HashMap::new();+ let placed: Vec<_> = shown.iter().filter_map(|b| Some((b.name.clone(), shared_mesh(app, b)?))).collect();+ for (_, (mesh, _)) in &placed {+ *uses.entry(std::sync::Arc::as_ptr(mesh) as usize).or_default() += 1;+ }+ candidates = placed+ .into_iter()+ .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 }+ }++ /// Draw `b` (in colour `col`) as an instance when it is one: its shared mesh and placement.+ fn place(+ &mut self,+ b: &solidcraft_engine::doc::ModelBody,+ col: [u8; 4],+ ) -> 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)) {+ 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 => std::sync::Arc::new(crate::gpu::SharedTris::new(&mesh)),+ };+ self.meshes.push((mesh.clone(), crate::gpu::InstancedMesh { key: key as u64, tris, instances: Vec::new() }));+ self.meshes.len() - 1+ }+ };+ let (_, inst) = self.meshes.get_mut(at)?;+ inst.place(rows, [col[0], col[1], col[2], 255]);+ Some((mesh, m))+ }++ /// The instanced meshes, keeping their triangles for the next scene.+ 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();+ if let Ok(mut k) = app.viewport.instanced_tris.lock() {+ *k = kept;+ }+ self.meshes.into_iter().map(|(_, inst)| inst).collect()+ }+}++/// The shared mesh `b`'s faces are drawn from and the move that places it ([`drawn_mesh`]+/// without making the moved copy); `None` for a body drawn finer than its display quality.+fn shared_mesh(+ app: &SolveApp,+ b: &solidcraft_engine::doc::ModelBody,+) -> Option<(std::sync::Arc<solidcraft_engine::geom::Mesh>, solidcraft_engine::doc::Mat)> {+ use solidcraft_engine::doc::display_quality::{DisplayQuality, current};+ if refined(app, b).is_some() {+ return None;+ }+ let q = current();+ Some(if q == DisplayQuality::Normal { b.mesh_in_place() } else { b.plan_mesh_in_place_at(q).unwrap_or_else(|| b.mesh_in_place()) })+}+pub(crate) fn build_scene(app: &SolveApp) -> GpuScene {let tk = Tokens::get();let mut sc = GpuScene::default();@@ -675,10 +778,13 @@ pub(crate) fn build_scene(app: &SolveApp) -> GpuScene {let mut made: std::collections::HashMap<u64, CachedBlock> = std::collections::HashMap::new();let mut run: Vec<BodyDraw> = Vec::new();let mut run_key = std::collections::hash_map::DefaultHasher::new();- for b in &st.bodies {- if !app.session.body_visible(&b.name) || app.preview.effective_replaced().contains(&b.name) {- continue;- }+ let shown: Vec<&solidcraft_engine::doc::ModelBody> =+ st.bodies.iter().filter(|b| app.session.body_visible(&b.name) && !app.preview.effective_replaced().contains(&b.name)).collect();+ // Bodies drawn from the same triangles more than once (a part placed by many occurrences)+ // are drawn as instances of them: one copy of the triangles on the GPU, and none moved on+ // the CPU.+ let mut instances = Instances::new(app, &shown, shaded);+ for b in shown {let faded = body_faded(app, b, &active_bodies);let base = body_color(&s.doc, b).unwrap_or(tk.body);let col = if faded { c4(base.gamma_multiply(0.35)) } else { c4(base) };@@ -698,7 +804,11 @@ pub(crate) fn build_scene(app: &SolveApp) -> GpuScene {.collect();sc.planned.push(crate::gpu::PlannedBody { plan, face_colors });}- let body = BodyDraw { mesh: drawn_mesh(app, b), col, faded, opacity, face_looks, on_gpu };+ let instanced = (!on_gpu && !faded && face_looks.is_empty() && opacity >= 0.999).then(|| instances.place(b, col)).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 },+ };let key = body.key(shaded, edges, hidden_edges, edge_col, hidden_col);key.hash(&mut run_key);run.push(body);@@ -716,6 +826,7 @@ pub(crate) fn build_scene(app: &SolveApp) -> GpuScene {if let Ok(mut b) = app.viewport.blocks.lock() {*b = made;}+ sc.instanced = instances.finish(app);if app.ui.ground_shadow && app.ui.visual_style != 2 && app.cam.pitch > 0.0 {ground_shadow(&mut sc, app, &st);}@@ -1061,25 +1172,29 @@ fn body_bounds({return b.clone();}- // Boxes of meshes the last state had too are kept (each body's box walks its mesh).+ // Boxes of meshes the last state had too are kept (each body's box walks its mesh). A+ // placed part's box is its shared mesh's points moved, so no moved copy is made.let mut known = app.viewport.mesh_bounds.lock().map(|mut k| std::mem::take(&mut *k)).unwrap_or_default();- let mut now = std::collections::HashMap::with_capacity(st.bodies.len());+ let mut now: MeshBounds = std::collections::HashMap::with_capacity(st.bodies.len());let b = std::sync::Arc::new(st.bodies.iter().map(|b| {- let mesh = b.mesh();- let ptr = std::sync::Arc::as_ptr(&mesh) as usize;- let bounds = match known.remove(&ptr).or_else(|| now.remove(&ptr)) {+ let (mesh, m) = b.mesh_in_place();+ let key = (std::sync::Arc::as_ptr(&mesh) as usize, std::array::from_fn(|i| m[i / 4][i % 4].to_bits()));+ let bounds = match known.remove(&key).or_else(|| now.get(&key).cloned()) {Some((_, bounds)) => bounds,- None => mesh.bounds(),+ None => b.mesh_bounds(),};- now.insert(ptr, (mesh, bounds));+ now.insert(key, (mesh, bounds));(b.name.clone(), bounds)}).collect::<Vec<_>>(),);- app.viewport.pick_index.retain(|k| now.contains_key(&k));+ // Pick indexes are kept for the meshes this state is picked from (a placed part's+ // shared mesh).+ let live: std::collections::HashSet<usize> = now.keys().map(|(mesh, _)| *mesh).collect();+ app.viewport.pick_index.retain(|k| live.contains(&k));if let Ok(mut k) = app.viewport.mesh_bounds.lock() {*k = now;}@@ -1346,8 +1461,11 @@ fn pick_hits(app: &SolveApp, proj: &Proj, pos: Pos2, other_sketch_points: bool,_ => {}}}- let m = b.mesh();- if let Some((t, ti)) = crate::pick_index::raycast(app.viewport.pick_index.of(&m).as_deref(), &m, o, d) {+ // A placed part is picked in its own frame, from its shared mesh and index: the ray is+ // moved there (a rigid move keeps distances along it), so no moved copy is made.+ let (m, place) = b.mesh_in_place();+ let Some((lo, ld)) = local_ray(&place, o, d) else { continue };+ if let Some((t, ti)) = crate::pick_index::raycast(app.viewport.pick_index.of(&m).as_deref(), &m, lo, ld) {let fi = m.tri_face.get(ti).copied().unwrap_or(0) as usize;let hit = Hit::Face { body: b.name.clone(), index: fi, point: o + d * t };if bestf.as_ref().is_none_or(|(bt, _)| t < *bt) {@@ -1379,13 +1497,17 @@ fn pick_hits(app: &SolveApp, proj: &Proj, pos: Pos2, other_sketch_points: bool,{continue;}- let m = b.mesh();+ // In the part's own frame, as for faces; its points are moved back to where it stands.+ let (m, place) = b.mesh_in_place();+ let Some((lo, ld)) = local_ray(&place, o, d) else { continue };+ let moved = !solidcraft_engine::doc::is_identity(&place);+ let at = |p: Vec3| if moved { solidcraft_engine::doc::apply_point(&place, p) } else { p };// Only the segments that can come near the cursor: of the edges the pick buffer sees// there, else from the index. Either way in the order a scan of every edge would meet// them, so ties go the same way.let near = match &seen {Some(seen) => seen.segments(i, &m),- None => crate::pick_index::segments_near(app.viewport.pick_index.of(&m).as_deref(), &m, o, d, reach),+ None => crate::pick_index::segments_near(app.viewport.pick_index.of(&m).as_deref(), &m, lo, ld, reach),};let mut last_edge = None;for (ei, si) in near {@@ -1395,22 +1517,22 @@ fn pick_hits(app: &SolveApp, proj: &Proj, pos: Pos2, other_sketch_points: bool,}if last_edge != Some(ei) {last_edge = Some(ei);- for v in [e.first(), e.last()].into_iter().flatten() {- if let Some(sp) = proj.to_screen(*v) {+ for v in [e.first(), e.last()].into_iter().flatten().map(|v| at(*v)) {+ if let Some(sp) = proj.to_screen(v) {let dd = sp.distance(pos);- if dd < 7.0 && visible(*v) && bestv.wants(dd) {- bestv.offer(dd, Hit::Vertex { body: b.name.clone(), point: *v });+ if dd < 7.0 && visible(v) && bestv.wants(dd) {+ bestv.offer(dd, Hit::Vertex { body: b.name.clone(), point: v });}}}}- let (Some(p0), Some(p1)) = (e.get(si), e.get(si + 1)) else { continue };- let (Some(a), Some(c)) = (proj.to_screen(*p0), proj.to_screen(*p1)) else { continue };+ let (Some(p0), Some(p1)) = (e.get(si).map(|p| at(*p)), e.get(si + 1).map(|p| at(*p))) else { continue };+ let (Some(a), Some(c)) = (proj.to_screen(p0), proj.to_screen(p1)) else { continue };let dd = seg_dist(pos, a, c);// Visible where the cursor is: the edge's point under the cursor, not an end or// the middle, which can lie deeper than the face the cursor is on.- if dd < 6.0 && beste.wants(dd) && visible(ray_segment_closest(o, d, *p0, *p1)) {- beste.offer(dd, Hit::Edge { body: b.name.clone(), index: ei, mid: polyline_mid(e) });+ if dd < 6.0 && beste.wants(dd) && visible(ray_segment_closest(o, d, p0, p1)) {+ beste.offer(dd, Hit::Edge { body: b.name.clone(), index: ei, mid: at(polyline_mid(e)) });}}}@@ -2294,6 +2416,16 @@ fn body_rgb(app: &SolveApp, name: &str) -> (u8, u8, u8) {(c.r(), c.g(), c.b())}+/// The ray `o` + t `d` in the frame of a mesh that `place` (a rigid move) puts in the world, with+/// the same t along it; `None` for a move with no inverse.+fn local_ray(place: &solidcraft_engine::doc::Mat, o: Vec3, d: Vec3) -> Option<(Vec3, Vec3)> {+ if solidcraft_engine::doc::is_identity(place) {+ return Some((o, d));+ }+ let back = solidcraft_engine::doc::mat_inverse(place)?;+ Some((solidcraft_engine::doc::apply_point(&back, o), solidcraft_engine::doc::apply_vector(&back, d)))+}+pub(crate) fn polyline_mid(pts: &[Vec3]) -> Vec3 {let len: f64 = pts.windows(2).map(|w| w[0].dist(w[1])).sum();let mut acc = 0.0;@@ -4620,6 +4752,339 @@ mod tests {assert!(bounds.min.x >= 29.99 && bounds.max.x <= 32.01 && bounds.max.y >= 41.99, "{bounds:?}");}+ /// The parts the instancing tests place: a box (flat triangles, its vertices shared by+ /// position and each fragment lit with its triangle's normal) and a cylinder (smooth, its+ /// vertices shared by position and normal).+ const PARTS: [(&str, &str); 2] = [("solid.box", r#"{"length":20,"width":10,"height":5}"#), ("solid.cylinder", r#"{"radius":6,"height":12}"#)];++ /// A design with a part (`command` with `params`, see [`PARTS`]) placed three times (one+ /// placement turned), drawn on a device that builds bodies on the CPU.+ fn three_placed_parts((command, params): (&str, &str)) -> SolveApp {+ let mut app = SolveApp::new(solidcraft_engine::Session::default(), 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.run("component.create", json!({"name":"Part"})).unwrap();+ app.run(command, serde_json::from_str(params).unwrap()).unwrap();+ app.run("occurrence.copy", json!({"component":"Part","translate":[40,0,0]})).unwrap();+ let turned = app.run("occurrence.copy", json!({"component":"Part","translate":[0,40,0]})).unwrap()["occurrence"].clone();+ app.run("occurrence.move", json!({"occurrence":turned,"axis":[1,1,0],"angle":"30 deg"})).unwrap();+ // With the part active, its other placements are drawn faded.+ app.run("component.activate", json!({"component":"root"})).unwrap();+ app+ }++ /// A part placed by several occurrences is drawn from one copy of its triangles, once per+ /// placement: one instanced mesh with a placement for each occurrence, whose triangles land+ /// where each occurrence's own moved mesh has them, and no moved copy is made to draw them.+ #[test]+ fn a_part_placed_many_times_is_drawn_from_one_copy_of_its_triangles() {+ for (part, flat) in PARTS.into_iter().zip([true, false]) {+ placed_three_times_is_drawn_from_one_copy(part, flat);+ }+ }++ fn placed_three_times_is_drawn_from_one_copy(part: (&str, &str), flat: bool) {+ let app = three_placed_parts(part);+ let st = app.session.world_state();+ assert_eq!(st.bodies.len(), 3);+ eprintln!("DBG before {}", st.bodies.iter().filter(|b| b.cached_mesh().is_some()).count());+ let scene = build_scene(&app);+ assert_eq!(scene.instanced.len(), 1, "one shared mesh");+ assert_eq!(scene.instanced[0].count(), 3, "a placement per occurrence");+ let shared = &scene.instanced[0].tris;+ assert_eq!(shared.flat, flat, "{part:?}");+ let corners = shared.indices.len();+ let vertices = shared.vertices.len() / crate::gpu::SHARED_SIZE;+ assert!(vertices * 2 < corners, "{part:?}: {vertices} vertices shared by {corners} corners");+ assert!(scene.blocks.iter().all(|b| b.bytes.tris.is_empty()), "no body's triangles built where it stands");+ let moved = st.bodies.iter().filter(|b| b.cached_mesh().is_some()).count();+ assert!(moved <= 1, "{moved} bodies made a moved mesh to be drawn");+ let merged = scene.merged();+ // Each placement's triangles where its own mesh has them, with its normals.+ let vertex = |b: &[u8]| -> [f32; 6] { std::array::from_fn(|i| f32::from_le_bytes([b[4 * i], b[4 * i + 1], b[4 * i + 2], b[4 * i + 3]])) };+ let mut drawn: Vec<[f32; 6]> = merged.tris.as_chunks::<{ crate::gpu::TRI_SIZE }>().0.iter().map(|v| vertex(v)).collect();+ let mut expected: Vec<[f32; 6]> = Vec::new();+ for b in &st.bodies {+ let m = b.mesh();+ for i in m.triangles.iter().flatten().map(|i| *i as usize) {+ let (p, n) = (m.positions[i].to_f32(), m.normals[i].to_f32());+ expected.push([p[0], p[1], p[2], n[0], n[1], n[2]]);+ }+ }+ let order = |a: &[f32; 6], b: &[f32; 6]| a.iter().map(|x| (x * 1e3).round() as i64).cmp(b.iter().map(|x| (x * 1e3).round() as i64));+ drawn.sort_by(order);+ expected.sort_by(order);+ assert_eq!(drawn.len(), expected.len());+ for (d, e) in drawn.iter().zip(&expected) {+ assert!(d.iter().zip(e).all(|(x, y)| (x - y).abs() < 1e-3), "{d:?} vs {e:?}");+ }+ // Each placement's edges are drawn where it stands.+ let one = st.bodies[0].mesh();+ let segments: usize = one+ .edges+ .iter()+ .enumerate()+ .filter(|(i, _)| one.edge_pickable(*i) && one.shaded_edge_visible(*i))+ .map(|(_, e)| e.len().saturating_sub(1))+ .sum();+ assert_eq!(merged.lines.len(), 3 * segments * crate::gpu::LINE_SIZE);+ }++ /// Manual GPU benchmark: 25 placements of the mesh `SOLIDCRAFT_BENCH_MESH` (an STL, OBJ or+ /// 3MF) drawn offscreen at 3600 × 2190 px (divided by `SOLIDCRAFT_BENCH_DIV`) with 4× MSAA+ /// while the camera turns, each frame waited for: the placements' own triangles (`merged`, as+ /// before instancing) and as instances. Prints the median frame time of each.+ #[cfg(not(target_arch = "wasm32"))]+ #[test]+ #[ignore = "manual: SOLIDCRAFT_BENCH_MESH=part.stl cargo test --release -p solidcraft-ui-egui --lib -- --ignored instanced_scene_gpu_benchmark --nocapture"]+ fn instanced_scene_gpu_benchmark() {+ use egui_wgpu::wgpu;+ let Some(path) = std::env::var_os("SOLIDCRAFT_BENCH_MESH") else { return };+ let mut app = SolveApp::new(solidcraft_engine::Session::default(), crate::Services::default());+ app.ui.ground_shadow = false;+ app.ui.show_origin = false;+ let component = app.run("file.insert_mesh", json!({"path": path.to_string_lossy()})).unwrap()["component"].clone();+ app.run("component.activate", json!({"component":"root"})).unwrap();+ let size = app.session.world_state().bodies[0].mesh_bounds().size();+ let step = size.x.max(size.y) * 1.3;+ 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();+ }+ let Some((_, device, queue)) = crate::gpu::offscreen_device() else {+ eprintln!("skipping: no GPU adapter");+ return;+ };+ let scale: u32 = std::env::var("SOLIDCRAFT_BENCH_DIV").ok().and_then(|v| v.parse().ok()).unwrap_or(1).max(1);+ let (w, h, samples) = (3600u32 / scale, 2190u32 / scale, 4u32);+ let depth = solidcraft_gpu::depth_format(&device, true);+ let format = wgpu::TextureFormat::Rgba8Unorm;+ app.viewport.gpu = Some(GpuTarget { format, depth: Some(depth), samples, tess: false });+ app.fit_view();+ let texture = |format, samples| {+ device+ .create_texture(&wgpu::TextureDescriptor {+ label: Some("bench"),+ size: wgpu::Extent3d { width: w, height: h, depth_or_array_layers: 1 },+ mip_level_count: 1,+ sample_count: samples,+ dimension: wgpu::TextureDimension::D2,+ format,+ usage: wgpu::TextureUsages::RENDER_ATTACHMENT,+ view_formats: &[],+ })+ .create_view(&Default::default())+ };+ let (color, resolve, depth_view) = (texture(format, samples), texture(format, 1), texture(depth, samples));+ let rect = Rect::from_min_size(Pos2::ZERO, vec2(w as f32, h as f32));+ let t0 = std::time::Instant::now();+ let scene = build_scene(&app);+ let t1 = std::time::Instant::now();+ drop(build_scene(&app));+ eprintln!("scene built in {:.0} ms, again in {:.0} ms", (t1 - t0).as_secs_f64() * 1e3, t1.elapsed().as_secs_f64() * 1e3);+ let proj = projection(&app, rect);+ let st = app.session.world_state();+ let seen = st.bodies.iter().filter(|b| proj.to_screen(b.mesh_bounds().center()).is_some_and(|p| rect.contains(p))).count();+ eprintln!("{w} x {h} px: {seen} of {} placements in view", st.bodies.len());+ // `SOLIDCRAFT_BENCH_CLOSE=1`: close up on the middle placement, most of the others out of view.+ if std::env::var("SOLIDCRAFT_BENCH_CLOSE").is_ok_and(|v| v == "1") {+ let middle = st.bodies.iter().map(|b| b.mesh_bounds()).nth(12).unwrap_or_default();+ app.cam.target = middle.center();+ app.cam.distance = middle.diagonal() * 1.5;+ let proj = projection(&app, rect);+ let seen = st.bodies.iter().filter(|b| proj.to_screen(b.mesh_bounds().center()).is_some_and(|p| rect.contains(p))).count();+ 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)] {+ 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();+ for k in 0..40 {+ app.cam.yaw = yaw + f64::from(k) * 0.05;+ let proj = projection(&app, rect);+ let e = proj.cam.eye().to_f32();+ let frame = Frame {+ product: false,+ key: 1,+ slot: slot.clone(),+ sketch_key: 0,+ sketch_slot: none(),+ hl_key: 0,+ hl_slot: none(),+ pv_key: 0,+ pv_slot: none(),+ pv_hide: false,+ view_proj: proj.vp.to_f32(),+ back: proj.cam.back().to_f32(),+ size_px: [w as f32, h as f32],+ clip: [0.0; 4],+ cap: [0.0; 4],+ images: Vec::new(),+ analysis: [0.0; 8],+ analysis_colors: crate::gpu::analysis_colors(&Tokens::get().analysis),+ access: None,+ outline: true,+ eye: [e[0], e[1], e[2], if proj.cam.fov > 0.0 { 1.0 } else { 0.0 }],+ ao_radius: 0.0,+ ssaa: 1.0,+ };+ let t0 = std::time::Instant::now();+ let mut encoder = device.create_command_encoder(&Default::default());+ renderer.prepare(&device, &queue, &mut encoder, &frame);+ {+ let mut pass = encoder+ .begin_render_pass(&wgpu::RenderPassDescriptor {+ label: Some("bench"),+ color_attachments: &[Some(wgpu::RenderPassColorAttachment {+ view: &color,+ depth_slice: None,+ resolve_target: Some(&resolve),+ ops: wgpu::Operations { load: wgpu::LoadOp::Clear(wgpu::Color::WHITE), store: wgpu::StoreOp::Discard },+ })],+ depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {+ view: &depth_view,+ depth_ops: Some(wgpu::Operations {+ load: wgpu::LoadOp::Clear(solidcraft_gpu::view::far_depth(solidcraft_gpu::view::reversed_depth(Some(depth)))),+ store: wgpu::StoreOp::Discard,+ }),+ stencil_ops: Some(wgpu::Operations { load: wgpu::LoadOp::Clear(0), store: wgpu::StoreOp::Discard }),+ }),+ timestamp_writes: None,+ occlusion_query_set: None,+ multiview_mask: None,+ })+ .forget_lifetime();+ renderer.paint(&frame, &mut pass, [0.0, 0.0, w as f32, h as f32]);+ }+ queue.submit([encoder.finish()]);+ device.poll(wgpu::PollType::wait_indefinitely()).unwrap();+ if k >= 5 {+ times.push(t0.elapsed().as_secs_f64() * 1e3);+ }+ }+ 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]);+ }+ }++ /// 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.+ #[test]+ fn each_placement_is_picked_where_it_stands_from_the_shared_mesh() {+ let mut app = three_placed_parts(PARTS[0]);+ app.fit_view();+ let rect = Rect::from_min_size(Pos2::ZERO, vec2(800.0, 600.0));+ let proj = projection(&app, rect);+ let st = app.session.world_state();+ // The top face's centre of each placement, from its moved box corners.+ let tops: Vec<(String, Vec3)> = st+ .bodies+ .iter()+ .map(|b| {+ let (mesh, m) = b.mesh_in_place();+ let local = mesh.bounds();+ (+ b.name.clone(),+ solidcraft_engine::doc::apply_point(+ &m,+ Vec3::new((local.min.x + local.max.x) / 2.0, (local.min.y + local.max.y) / 2.0, local.max.z),+ ),+ )+ })+ .collect();+ for (name, top) in &tops {+ let at = proj.to_screen(*top).unwrap();+ let hits = pick(&app, &proj, at);+ let face = hits.iter().find_map(|h| match h {+ Hit::Face { body, point, .. } => Some((body.clone(), *point)),+ _ => None,+ });+ let (body, point) = face.unwrap_or_else(|| panic!("no face of {name} under {at:?}: {hits:?}"));+ assert_eq!(&body, name);+ assert!(point.dist(*top) < 0.05, "{point:?} vs {top:?}");+ }+ assert!(+ st.bodies.iter().all(|b| b.cached_mesh().is_none() || b.mesh_in_place().1 == solidcraft_engine::doc::IDENTITY),+ "a moved copy was made to pick"+ );+ }++ /// A part drawn as instances looks the same as its placements' own triangles drawn one by+ /// one. Skipped without a GPU adapter.+ #[cfg(not(target_arch = "wasm32"))]+ #[test]+ fn instances_draw_like_their_placements_own_triangles() {+ for part in PARTS {+ if !placed_three_times_draws_like_its_own_triangles(part) {+ return;+ }+ }+ }++ /// `false` without a GPU adapter.+ #[cfg(not(target_arch = "wasm32"))]+ fn placed_three_times_draws_like_its_own_triangles(part: (&str, &str)) -> bool {+ let mut app = three_placed_parts(part);+ 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 scene = build_scene(&app);+ assert!(!scene.instanced.is_empty());+ let (Some(instanced), Some(one_by_one)) = (render(scene.clone()), render(scene.clone().merged())) else {+ eprintln!("skipping: no GPU adapter");+ return false;+ };+ let drawn = instanced.chunks(4).filter(|p| p[..3] != [255, 255, 255]).count();+ assert!(drawn > (SIZE * SIZE) as usize / 50, "the parts are drawn: {drawn} pixels");+ let differ = instanced.chunks(4).zip(one_by_one.chunks(4)).filter(|(a, b)| a.iter().zip(b.iter()).any(|(x, y)| x.abs_diff(*y) > 24)).count();+ assert!(differ * 200 < drawn, "{part:?}: {differ} of {drawn} pixels differ");+ // Close up on the turned placement, the others out of view: what is in view is all drawn.+ let turned = app.session.world_state().bodies[2].mesh_bounds();+ app.cam.target = turned.center();+ app.cam.distance = turned.diagonal() * 0.75;+ 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(one_by_one)) = (render(scene.clone()), render(scene.merged())) else { return false };+ let drawn = instanced.chunks(4).filter(|p| p[..3] != [255, 255, 255]).count();+ assert!(drawn > (SIZE * SIZE) as usize / 4, "{part:?}: close up, the part fills the view: {drawn} pixels");+ let differ = instanced.chunks(4).zip(one_by_one.chunks(4)).filter(|(a, b)| a.iter().zip(b.iter()).any(|(x, y)| x.abs_diff(*y) > 24)).count();+ assert!(differ * 200 < drawn, "{part:?} close up: {differ} of {drawn} pixels differ");+ true+ }+#[test]fn ray_segment_closest_takes_the_point_under_the_ray() {let (o, d) = (Vec3::new(0.0, 0.0, 10.0), Vec3::new(0.0, 0.0, -1.0));