SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Viewport: whole-body highlights reuse the model's own triangles (#4554) (#5109)
Jackson Oursland8301d1c48e66
diff --git a/assets/shaders/viewport.wgsl b/assets/shaders/viewport.wgslindex 5911918800..62c372164b 100644--- a/assets/shaders/viewport.wgsl+++ b/assets/shaders/viewport.wgsl@@ -16,6 +16,8 @@ struct U {ana_c: array<vec4<f32>, 8>,ana_f: vec4<f32>, // x = 1: stripe the negative draft and blocked facesdepth: vec4<f32>, // x = 1: reversed depth (1 near, 0 far); y, z: the faces' push (`FACE_BIAS`)+ tint: vec4<f32>, // xyz added to a whole hovered body's colour before lighting+ sel: vec4<f32>, // xyz a whole selected body's colour before lighting};fn reversed() -> bool {@@ -424,6 +426,20 @@ fn fs_tri(i: TOut) -> @location(0) vec4<f32> {return shade(i);}+/// A whole hovered body, lit over the model from its own plan triangles in a lifted colour.+@fragment+fn fs_hl_hover(i: TOut) -> @location(0) vec4<f32> {+ if (clipped(i.wp)) { discard; }+ return lit_color(i, 1.0, vec4<f32>(i.c.rgb + u.tint.rgb, i.c.a));+}++/// A whole selected body, lit over the model from its own plan triangles in the selection colour.+@fragment+fn fs_hl_selected(i: TOut) -> @location(0) vec4<f32> {+ if (clipped(i.wp)) { discard; }+ return lit_color(i, 1.0, vec4<f32>(u.sel.rgb, i.c.a));+}+/// Reference planes: shaded like `fs_tri`, but never cut by the section plane.@fragmentfn fs_tri_all(i: TOut) -> @location(0) vec4<f32> {@@ -435,9 +451,15 @@ fn shade(i: TOut) -> vec4<f32> {}fn lit(i: TOut, visibility: f32) -> vec4<f32> {+ return lit_color(i, visibility, i.c);+}++/// [`lit`] in a colour of its own: a whole highlighted body is lit in its colour lifted by the+/// hover amount, or in the selection colour, from the model's own plan triangles.+fn lit_color(i: TOut, visibility: f32, base: vec4<f32>) -> vec4<f32> {// A zero normal marks flat colour (selection fills, translucent planes).if (length(i.n) < 0.5) {- return out_color(i.c);+ return out_color(base);}let v = normalize(u.back.xyz);var n = normalize(i.n);@@ -448,7 +470,7 @@ fn lit(i: TOut, visibility: f32) -> vec4<f32> {let h = normalize(key + v);let spec = pow(max(dot(n, h), 0.0), 40.0) * 0.25;let k = 0.42 + 0.38 * diff + 0.25 * fill - (0.42 + 0.25 * fill) * (1.0 - visibility);- return out_color(vec4<f32>(min(i.c.rgb * k + vec3<f32>(spec), vec3<f32>(1.0)), i.c.a));+ return out_color(vec4<f32>(min(base.rgb * k + vec3<f32>(spec), vec3<f32>(1.0)), base.a));}// Lines, decals and ghosts are drawn at their own depth: opaque faces are pushed back by theirdiff --git a/crates/gpu/src/capture.rs b/crates/gpu/src/capture.rsindex 903aebe808..26955aaea6 100644--- a/crates/gpu/src/capture.rs+++ b/crates/gpu/src/capture.rs@@ -383,6 +383,8 @@ fn frame(scene: &Scene, cam: &Camera, [width, height]: [u32; 2], key: u64, acceseye: [eye[0], eye[1], eye[2], if cam.fov > 0.0 { 1.0 } else { 0.0 }],ao_radius: 0.0,ssaa: 1.0,+ hover_tint: [0.0; 3],+ selection_tint: [0.0; 3],}}diff --git a/crates/gpu/src/view.rs b/crates/gpu/src/view.rsindex c243cd8273..4a12cc05c2 100644--- a/crates/gpu/src/view.rs+++ b/crates/gpu/src/view.rs@@ -28,9 +28,9 @@ pub const LINE_SIZE: usize = 32;/// 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`).-const UNIFORM_SIZE: u64 = 384;+/// occlusion radius), the 8 analysis colours, their flags, the depth direction and the two+/// whole-body highlight colours (`uniform_bytes`).+const UNIFORM_SIZE: u64 = 416;/// A body drawn from its display plan, evaluated on the GPU: the plan, and a colour per face/// (the plan's face numbering; faces past the end take the last colour).@@ -290,6 +290,22 @@ pub struct GpuScene {pub planned: Vec<PlannedBody>,/// Opaque bodies drawn as placements of shared triangles, like `tris`.pub instanced: Vec<InstancedMesh>,+ /// Whole hovered bodies the model draws from their plans on the GPU: lit again over the+ /// model in the hover colour from the model's own evaluated triangles, so a whole assembly+ /// under the pointer costs a draw per body, not a copy of every triangle on the CPU.+ pub hover_planned: Vec<Arc<solidcraft_geom::tess::TessPlan>>,+ /// Whole selected bodies, as `hover_planned`, in the selection colour.+ pub selected_planned: Vec<Arc<solidcraft_geom::tess::TessPlan>>,+ /// Whole hovered bodies the model builds on the CPU (no display plan): their triangles in+ /// the model scene's own blocks, drawn again tinted.+ pub hover_blocks: Vec<BlockTris>,+ /// Whole selected bodies, as `hover_blocks`, in the selection colour.+ pub selected_blocks: Vec<BlockTris>,+ /// Whole hovered bodies the model draws as placements of shared triangles: those meshes with+ /// the body's highlight colour on each placement.+ pub hover_instanced: Vec<InstancedMesh>,+ /// Whole selected bodies, as `hover_instanced`, in the selection colour.+ pub selected_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@@ -331,6 +347,16 @@ pub struct SceneBlock {pub bytes: Arc<BlockBytes>,}+/// A whole highlighted body the model builds on the CPU: its triangles in a model scene block,+/// as vertices of the block's triangle buffer.+#[derive(Clone, Debug)]+pub struct BlockTris {+ /// The block's key ([`SceneBlock::key`]).+ pub block: u64,+ /// The body's vertices in it.+ pub tris: std::ops::Range<u32>,+}+/// A block's geometry, laid out as in [`GpuScene`].#[derive(Default)]pub struct BlockBytes {@@ -492,6 +518,10 @@ pub struct Frame {/// direction and filter it down (1: off). Under 1 the frame is drawn smaller and filtered up/// (the product preview past its pixel budget, #1464).pub ssaa: f32,+ /// Whole-body hover highlight: added to the body's own colour before lighting (sRGB 0..1).+ pub hover_tint: [f32; 3],+ /// Whole-body selection highlight: a selected body's colour before lighting (sRGB 0..1).+ pub selection_tint: [f32; 3],}/// Heights of the model seen from a direction (an orthographic depth map): a point is reachable@@ -614,6 +644,16 @@ struct Batch {struct PlannedDraw {mesh: Arc<crate::GpuMesh>,colors: wgpu::Buffer,+ /// The address of each plan in the chunk, in `mesh.parts` order: a whole-body highlight+ /// finds the evaluated triangles of the body it lights.+ plans: Vec<usize>,+}++impl PlannedDraw {+ /// The part drawn from the plan at `address`, if this chunk holds it.+ fn part_of(&self, address: usize) -> Option<&crate::Part> {+ self.plans.iter().position(|p| *p == address).and_then(|i| self.mesh.parts.get(i))+ }}/// An [`InstancedMesh`]'s triangles on the GPU (kept while its key comes back).@@ -830,6 +870,15 @@ struct Batches {guide_lines: Option<Batch>,planned: Vec<PlannedDraw>,instanced: Vec<InstancedDraw>,+ /// Whole highlighted bodies redrawn from `planned` (the scene's own plans are not used).+ hover_planned: Vec<Arc<solidcraft_geom::tess::TessPlan>>,+ selected_planned: Vec<Arc<solidcraft_geom::tess::TessPlan>>,+ /// Whole highlighted bodies redrawn from the scene's blocks, by block key and vertex range.+ hover_blocks: Vec<BlockTris>,+ selected_blocks: Vec<BlockTris>,+ /// Whole highlighted bodies drawn as placements of the scene's shared triangles.+ hover_instanced: Vec<InstancedDraw>,+ selected_instanced: Vec<InstancedDraw>,/// 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>)>,@@ -851,6 +900,12 @@ impl Batches {None => Vec::new(),};self.instanced = self.instanced(device, &sc.instanced);+ self.hover_planned = sc.hover_planned;+ self.selected_planned = sc.selected_planned;+ self.hover_blocks = sc.hover_blocks;+ self.selected_blocks = sc.selected_blocks;+ self.hover_instanced = self.instanced(device, &sc.hover_instanced);+ self.selected_instanced = self.instanced(device, &sc.selected_instanced);let mut kept = std::mem::take(&mut self.blocks);let mut blocks: Vec<&BlockGpu> = Vec::with_capacity(sc.blocks.len());for block in &sc.blocks {@@ -1045,7 +1100,7 @@ impl Batches {bytes.extend(faces.iter().flat_map(|f| b.face_colors.get(*f as usize).copied().unwrap_or(last)));}if let Some((colors, _)) = upload(device, "sc_planned_colors", &bytes, 4).and_then(|c| c.parts.into_iter().next()) {- out.push(PlannedDraw { mesh, colors });+ out.push(PlannedDraw { mesh, colors, plans: key(chunk) });}}out@@ -1079,6 +1134,17 @@ pub struct Renderer {tri_cut: Option<(wgpu::RenderPipeline, wgpu::RenderPipeline)>,/// Highlight triangles over the model (depth test ≤, no depth write).tri_hl: wgpu::RenderPipeline,+ /// Whole highlighted bodies, redrawn from the model's planned chunks in the hover and the+ /// selection colour (depth test ≤, no depth write).+ tri_hl_hover: wgpu::RenderPipeline,+ tri_hl_selected: wgpu::RenderPipeline,+ /// The same for bodies the model builds on the CPU, from its blocks' triangle buffers.+ tri_hl_hover_built: wgpu::RenderPipeline,+ tri_hl_selected_built: wgpu::RenderPipeline,+ /// The same for bodies drawn as placements of shared triangles (the placement's colour is+ /// the highlight's), smooth and flat.+ tri_hl_instanced: wgpu::RenderPipeline,+ tri_hl_instanced_flat: wgpu::RenderPipeline,pbr: wgpu::RenderPipeline,trans: wgpu::RenderPipeline,/// Glass: far sides (front faces culled), then near sides (back faces culled).@@ -1817,6 +1883,12 @@ impl Renderer {access_bind,access_version: 0,tri_hl: pipeline("sc_tris_hl", "vs_tri", "fs_tri", tri_layout(), highlight_depth(t.depth), alpha),+ tri_hl_hover: solid("sc_tris_hl_hover", "fs_hl_hover", None, highlight_depth(t.depth), TriSource::Planned),+ tri_hl_selected: solid("sc_tris_hl_selected", "fs_hl_selected", None, highlight_depth(t.depth), TriSource::Planned),+ tri_hl_hover_built: solid("sc_tris_hl_hover_built", "fs_hl_hover", None, highlight_depth(t.depth), TriSource::Built),+ tri_hl_selected_built: solid("sc_tris_hl_selected_built", "fs_hl_selected", None, highlight_depth(t.depth), TriSource::Built),+ tri_hl_instanced: solid("sc_tris_hl_instanced", "fs_tri", None, highlight_depth(t.depth), TriSource::Instanced),+ tri_hl_instanced_flat: solid("sc_tris_hl_instanced_flat", "fs_tri", None, highlight_depth(t.depth), TriSource::InstancedFlat),pbr: pipeline("sc_pbr", "vs_pbr", "fs_pbr", pbr_layout(), pushed(wgpu::CompareFunction::Less, true, FACE_BIAS), None),trans: pipeline("sc_trans", "vs_tri", "fs_tri", tri_layout(), depth(wgpu::CompareFunction::LessEqual, false), alpha),glass_far: glass("sc_glass_far", wgpu::Face::Front),@@ -2220,6 +2292,48 @@ impl Renderer {d.draw(pass, smooth, flat);}};+ // Whole highlighted bodies: the model's own evaluated plan triangles, drawn again in a+ // highlight colour (the pipeline adds or replaces the vertex colour).+ let tinted = |pass: &mut wgpu::RenderPass<'static>, p: &wgpu::RenderPipeline, plans: &[Arc<solidcraft_geom::tess::TessPlan>]| {+ for plan in plans {+ let address = Arc::as_ptr(plan) as usize;+ for d in &m.planned {+ let Some(part) = d.part_of(address) else { continue };+ pass.set_pipeline(p);+ pass.set_vertex_buffer(0, d.mesh.vertices.slice(..));+ pass.set_vertex_buffer(1, d.colors.slice(..));+ pass.set_index_buffer(d.mesh.indices.slice(..), wgpu::IndexFormat::Uint32);+ pass.draw_indexed(part.indices.clone(), 0, 0..1);+ }+ }+ };+ // Whole highlighted bodies the model builds on the CPU: their part of a block's triangle+ // buffer (the blocks may run over several buffers).+ let tinted_blocks = |pass: &mut wgpu::RenderPass<'static>, p: &wgpu::RenderPipeline, refs: &[BlockTris]| {+ for r in refs {+ let Some(block) = m.blocks.get(&r.block) else { continue };+ let Some(batch) = &block.tris else { continue };+ pass.set_pipeline(p);+ let mut base = 0u32;+ for (buffer, count) in &batch.parts {+ let end = base.saturating_add(*count);+ let (lo, hi) = (r.tris.start.max(base), r.tris.end.min(end));+ if lo < hi {+ pass.set_vertex_buffer(0, buffer.slice(..));+ pass.draw(lo - base..hi - base, 0..1);+ }+ base = end;+ }+ }+ };+ // Whole highlighted bodies the model draws as placements of shared triangles: the same+ // placements, with the highlight colour on each.+ let tinted_instanced =+ |pass: &mut wgpu::RenderPass<'static>, smooth: &wgpu::RenderPipeline, flat: &wgpu::RenderPipeline, list: &[InstancedDraw]| {+ for d in list.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;match (res.tri_cut.as_ref().filter(|_| sectioned),@@ -2246,6 +2360,15 @@ impl Renderer {}}tris(pass, &res.pbr, &m.pbr);+ // Whole-body tints first, so a face or an edge highlighted over the body (in `h.tris`+ // and `h.lines`) keeps its own colour, as it did when the body's triangles were built+ // into the same list before them.+ tinted(pass, &res.tri_hl_hover, &h.hover_planned);+ tinted(pass, &res.tri_hl_selected, &h.selected_planned);+ tinted_blocks(pass, &res.tri_hl_hover_built, &h.hover_blocks);+ tinted_blocks(pass, &res.tri_hl_selected_built, &h.selected_blocks);+ tinted_instanced(pass, &res.tri_hl_instanced, &res.tri_hl_instanced_flat, &h.hover_instanced);+ tinted_instanced(pass, &res.tri_hl_instanced, &res.tri_hl_instanced_flat, &h.selected_instanced);tris(pass, &res.tri_hl, &h.tris);lines(pass, &res.line, &m.lines);lines(pass, &res.line, &sk.lines);@@ -2523,6 +2646,8 @@ pub fn uniform_bytes(cb: &Frame, w: f32, h: f32, linear: bool, reversed: bool) -v.extend([cb.ao_radius, 0.0, 0.0, 0.0]);v.extend(cb.analysis_colors);v.extend([if reversed { 1.0 } else { 0.0 }, FACE_STEPS as f32, FACE_SLOPE, 0.0]);+ v.extend([cb.hover_tint[0], cb.hover_tint[1], cb.hover_tint[2], 0.0]);+ v.extend([cb.selection_tint[0], cb.selection_tint[1], cb.selection_tint[2], 0.0]);v.iter().flat_map(|x| x.to_le_bytes()).collect()}@@ -2926,6 +3051,8 @@ mod glass_tests {eye: [0.0, 0.0, 100.0, 0.0],ao_radius: 0.0,ssaa: 1.0,+ hover_tint: [0.0; 3],+ selection_tint: [0.0; 3],};let texture = |format, usage, sample_count| {device.create_texture(&wgpu::TextureDescriptor {diff --git a/crates/ui-egui/src/gpu.rs b/crates/ui-egui/src/gpu.rsindex bdb3af59fe..16cb977d1a 100644--- a/crates/ui-egui/src/gpu.rs+++ b/crates/ui-egui/src/gpu.rs@@ -8,7 +8,7 @@ use std::sync::{Arc, Mutex};use egui_wgpu::wgpu;pub use solidcraft_gpu::view::{- AccessMap, BlockBytes, Frame, GpuImage, GpuScene, GpuTarget, INSTANCE_SIZE, InstanceLook, InstancedMesh, LINE_SIZE, LOD_PX, PBR_SIZE,+ AccessMap, BlockBytes, BlockTris, 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,};@@ -311,6 +311,8 @@ fn offscreen(eye,ao_radius: 0.0,ssaa,+ hover_tint: [0.0; 3],+ selection_tint: [0.0; 3],});let texture = |format, usage| {device.create_texture(&wgpu::TextureDescriptor {diff --git a/crates/ui-egui/src/render_workspace.rs b/crates/ui-egui/src/render_workspace.rsindex 400089bd73..b0695e2385 100644--- a/crates/ui-egui/src/render_workspace.rs+++ b/crates/ui-egui/src/render_workspace.rs@@ -553,6 +553,8 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {ao_radius: 0.0,eye: [eye.x as f32, eye.y as f32, eye.z as f32, if camera.fov > 0.0 { 1.0 } else { 0.0 }],ssaa: if width < full.0 { width as f32 / full.0 as f32 } else { 1.0 },+ hover_tint: [0.0; 3],+ selection_tint: [0.0; 3],});ui.painter().add(egui_wgpu::Callback::new_paint_callback(rect, callback));Ok(())diff --git a/crates/ui-egui/src/scale_tests.rs b/crates/ui-egui/src/scale_tests.rsindex fcd56ba467..5011719604 100644--- a/crates/ui-egui/src/scale_tests.rs+++ b/crates/ui-egui/src/scale_tests.rs@@ -105,3 +105,30 @@ fn frame_cost_of_a_design_file() {h.frame();}}++/// A whole assembly's hover highlight: the model's own triangles (its display plans on the GPU)+/// against the copy of every triangle it used to build here. Run with `--ignored --nocapture`.+#[test]+#[ignore = "manual scaling measurement"]+fn whole_body_highlight_cost_from_the_models_own_triangles() {+ let mut h = Harness::new();+ let mut names = Vec::new();+ // Each torus holds some 8k triangles at Normal quality: twenty make a large assembly.+ for k in 0..20 {+ let name = format!("Torus{k}");+ h.app.run("solid.torus", json!({"major": 100, "minor": 10, "center": [k as f64 * 220.0, 0.0, 0.0], "body_name": name.clone()})).unwrap();+ names.push(name);+ }+ let st = h.app.session.world_state();+ let triangles: usize = st.bodies.iter().map(|b| b.mesh().triangles.len()).sum();+ st.warm_meshes(|| true);+ for b in &st.bodies {+ let _ = b.display_plan();+ }+ let bodies = names.len();+ h.app.viewport.hover_bodies = names;+ let copied = ms(|| drop(crate::viewport::build_highlight(&h.app)));+ h.app.viewport.gpu = Some(crate::gpu::GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: true });+ let planned = ms(|| drop(crate::viewport::build_highlight(&h.app)));+ println!("HIGHLIGHT bodies={bodies} triangles={triangles} cpu_copy_ms={copied:.2} model_triangles_ms={planned:.2}");+}diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rsindex 3fe6eddbbb..1868470f97 100644--- a/crates/ui-egui/src/viewport.rs+++ b/crates/ui-egui/src/viewport.rs@@ -100,6 +100,9 @@ pub struct ViewportState {hl_key: u64,/// Browser/timeline body feedback, independent of the camera and reference widget scale.hover_block: std::sync::Mutex<Option<HoverBlock>>,+ /// Each shown body the model builds on the CPU: the block of the model scene that holds its+ /// triangles, and the body's vertex range in it (for whole-body highlights).+ body_tris: std::sync::Mutex<std::collections::HashMap<String, (u64, std::ops::Range<u32>)>>,pub nav: Option<NavMode>,/// The preset's navigation for the left-button drag under way (Alias: Shift+Alt), taken/// when the button went down, so the drag neither selects nor moves sketch geometry.@@ -559,6 +562,9 @@ fn update_refinement(app: &mut SolveApp, ctx: &egui::Context, proj: &Proj) {pub(crate) struct CachedBlock {bytes: std::sync::Arc<crate::gpu::BlockBytes>,meshes: Vec<std::sync::Arc<solidcraft_engine::geom::Mesh>>,+ /// Each body's triangles in `bytes.tris`, by body name: whole-body highlights draw those+ /// vertices again instead of building a copy of them on the CPU.+ ranges: Vec<(String, std::ops::Range<u32>)>,}/// [`ViewportState::mesh_bounds`]: each box by the shared mesh it was measured on (held, so its@@ -607,6 +613,8 @@ fn taken_shared_tris(mesh: &std::sync::Arc<solidcraft_engine::geom::Mesh>) -> Op/// One body as the model scene draws it.struct BodyDraw {+ /// The body's name in the world state, for the highlight's lookup of its triangles.+ name: String,/// 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.@@ -693,16 +701,29 @@ fn push_block(build: impl Fn(&BodyDraw, &mut crate::gpu::BlockBytes),) {let same = |c: &CachedBlock| c.meshes.len() == draws.len() && c.meshes.iter().zip(&draws).all(|(m, d)| std::sync::Arc::ptr_eq(m, &d.mesh));- let block = match kept.remove(&key).or_else(|| made.remove(&key)).filter(same) {+ let mut block = match kept.remove(&key).or_else(|| made.remove(&key)).filter(same) {Some(c) => c,None => {let mut bytes = crate::gpu::BlockBytes::default();+ let mut ranges = Vec::with_capacity(draws.len());for d in &draws {+ let start = u32::try_from(bytes.tris.len() / crate::gpu::TRI_SIZE).unwrap_or(u32::MAX);build(d, &mut bytes);+ let end = u32::try_from(bytes.tris.len() / crate::gpu::TRI_SIZE).unwrap_or(u32::MAX);+ ranges.push((d.name.clone(), start..end));}- CachedBlock { bytes: std::sync::Arc::new(bytes), meshes: draws.iter().map(|d| d.mesh.clone()).collect() }+ CachedBlock { bytes: std::sync::Arc::new(bytes), meshes: draws.iter().map(|d| d.mesh.clone()).collect(), ranges }}};+ // The body names are not part of a block's key (its bytes are the same whatever a body is+ // called): keep the ranges' names those of the bodies drawn from them this time.+ if block.ranges.len() == draws.len() {+ for (range, d) in block.ranges.iter_mut().zip(&draws) {+ if range.0 != d.name {+ range.0.clone_from(&d.name);+ }+ }+ }// See-through triangles are sorted with the rest of the glass, every view.sc.glass.extend_from_slice(&block.bytes.glass);sc.blocks.push(crate::gpu::SceneBlock { key, bytes: block.bytes.clone() });@@ -864,9 +885,10 @@ pub(crate) fn build_scene(app: &SolveApp) -> GpuScene {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 name = b.name.clone();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 },+ Some((mesh, place)) => BodyDraw { name, mesh, place: Some(place), col, faded, opacity, face_looks, on_gpu: true },+ None => BodyDraw { name, mesh: drawn_mesh(app, b), place: None, col, faded, opacity, face_looks, on_gpu },};let key = body.key(shaded, edges, hidden_edges, edge_col, hidden_col);key.hash(&mut run_key);@@ -882,6 +904,19 @@ pub(crate) fn build_scene(app: &SolveApp) -> GpuScene {if !run.is_empty() {push_block(&mut sc, &mut kept, &mut made, run_key.finish(), run, |d, out| d.build(out, shaded, edges, hidden_edges, edge_col, hidden_col));}+ // Where each CPU-built body's triangles are in the model's blocks, for whole-body+ // highlights (see `highlight_block_tris`).+ let mut body_tris = std::collections::HashMap::new();+ for (key, c) in &made {+ for (name, tris) in &c.ranges {+ if !tris.is_empty() {+ body_tris.insert(name.clone(), (*key, tris.clone()));+ }+ }+ }+ if let Ok(mut m) = app.viewport.body_tris.lock() {+ *m = body_tris;+ }if let Ok(mut b) = app.viewport.blocks.lock() {*b = made;}@@ -2146,8 +2181,15 @@ fn highlight_geometry_key(app: &SolveApp) -> u64 {hover_drawn(&app.viewport.hover).hash(&mut h);app.viewport.hover_feature.hash(&mut h);app.viewport.hover_bodies.hash(&mut h);- // Which mesh lights a face follows how the model draws its body (see `shown_mesh`).+ // Which mesh lights a face follows how the model draws its body (see `shown_mesh`), and at+ // which display quality its plan and edges are made.+ solidcraft_engine::doc::display_quality::current().hash(&mut h);lod_generation(app).hash(&mut h);+ // Whole-body highlights redraw the model scene's own blocks: they must be the scene's+ // current ones (their keys and the bodies' ranges in them).+ scene_key(app).hash(&mut h);+ // And the mode the model draws bodies in: from their plans on the GPU, or built here.+ app.viewport.gpu.is_some_and(|g| g.tess).hash(&mut h);app.session.active_component.hash(&mut h);app.session.active_occurrence_path.hash(&mut h);app.ui.visual_style.hash(&mut h);@@ -2182,15 +2224,125 @@ fn highlight_key(app: &SolveApp) -> u64 {h.finish()}+#[derive(Clone)]struct HoverBlock {key: u64,state: std::sync::Arc<solidcraft_engine::doc::ModelState>,doc: std::sync::Arc<solidcraft_engine::doc::Document>,block: crate::gpu::SceneBlock,+ /// Whole bodies the model draws from their plans: reused like the block when the camera+ /// moves (they are the model's own evaluated triangles, not a copy of them).+ hover_planned: Vec<std::sync::Arc<solidcraft_engine::geom::tess::TessPlan>>,+ selected_planned: Vec<std::sync::Arc<solidcraft_engine::geom::tess::TessPlan>>,+ /// CPU-built bodies: their triangles in the model scene's blocks, reused the same way.+ hover_blocks: Vec<crate::gpu::BlockTris>,+ selected_blocks: Vec<crate::gpu::BlockTris>,+ /// Bodies the model draws as placements of shared triangles: the same placements with the+ /// highlight colour.+ hover_instanced: Vec<crate::gpu::InstancedMesh>,+ selected_instanced: Vec<crate::gpu::InstancedMesh>,+}++/// The plan the model draws a whole highlighted body from, when it draws one on the GPU. The+/// highlight then redraws those evaluated triangles in the highlight colour instead of building+/// a copy of every triangle on the CPU: lighting a whole assembly's faces that way took seconds+/// (every triangle of every body, again), while the model already had them all on the GPU.+fn highlight_plan(+ app: &SolveApp,+ b: &solidcraft_engine::doc::ModelBody,+ active_bodies: &Option<Vec<String>>,+) -> Option<std::sync::Arc<solidcraft_engine::geom::tess::TessPlan>> {+ drawn_plan(app, b, highlight_opaque(app, b, active_bodies))+}++/// Whether the model draws a whole body opaque on the GPU, rather than building it on the CPU:+/// a live preview stands in for none, faded and see-through bodies stay on the CPU, and face+/// opacities matter only where faces are shaded.+fn highlight_opaque(app: &SolveApp, b: &solidcraft_engine::doc::ModelBody, active_bodies: &Option<Vec<String>>) -> bool {+ if app.preview.effective_replaced().contains(&b.name) {+ return false;+ }+ let doc = &app.session.doc;+ let faces_opaque = app.ui.visual_style == 2 || doc.face_colors(b).iter().all(|(_, l)| l.opacity >= 0.999);+ !body_faded(app, b, active_bodies) && doc.model_body_opacity(b) >= 0.999 && faces_opaque+}++/// Whole highlighted bodies the model draws as placements of shared triangles, collected as one+/// [`InstancedMesh`] per mesh (a placement and its colour each): the model scene already holds+/// the shared vertices, so a whole assembly under the pointer draws them again, not a copy.+#[derive(Default)]+struct HighlightInstances {+ meshes: Vec<crate::gpu::InstancedMesh>,+ /// The index in `meshes` of each mesh, by its address.+ by_mesh: std::collections::HashMap<usize, usize>,+}++impl HighlightInstances {+ /// Add the body at `color`, when the model draws it as an instanced placement of an opaque+ /// shared mesh; `false` when it does not (the caller builds its feedback on the CPU).+ fn add(&mut self, app: &SolveApp, b: &solidcraft_engine::doc::ModelBody, active_bodies: &Option<Vec<String>>, color: [u8; 4]) -> bool {+ // A body with face appearances of its own is built on the CPU, never as an instance.+ if !highlight_opaque(app, b, active_bodies) || !app.session.doc.face_colors(b).is_empty() {+ return false;+ }+ let Some((mesh, m)) = shared_mesh(app, b) else { return false };+ let key = std::sync::Arc::as_ptr(&mesh) as usize;+ let at = match self.by_mesh.get(&key) {+ Some(i) => *i,+ None => {+ // The model scene's shared triangles (made ahead, or with its own instances).+ let tris = app+ .viewport+ .instanced_tris+ .lock()+ .ok()+ .and_then(|c| c.get(&key).filter(|(held, _)| std::sync::Arc::ptr_eq(held, &mesh)).map(|(_, t)| t.clone()))+ .or_else(|| taken_shared_tris(&mesh));+ let Some(tris) = tris else { return false };+ self.meshes.push(crate::gpu::InstancedMesh {+ key: key as u64,+ tris,+ instances: Vec::new(),+ look: crate::gpu::InstanceLook::Opaque,+ levels: Vec::new(),+ });+ self.by_mesh.insert(key, self.meshes.len() - 1);+ self.meshes.len() - 1+ }+ };+ 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]);+ match self.meshes.get_mut(at) {+ Some(inst) => {+ inst.place(rows, color);+ true+ }+ None => false,+ }+ }++ /// The meshes with their placements (none when nothing was added).+ fn finish(self) -> Vec<crate::gpu::InstancedMesh> {+ self.meshes+ }+}++/// The model scene's triangles for a whole highlighted body it builds on the CPU (no display+/// plan): the block holding them and the body's vertex range in it. Drawing those again tinted+/// costs no CPU work, where copying every triangle did (a whole assembly hovered at once stalled+/// the window). See-through and faded bodies have no range here: they are not in the block's+/// opaque triangles, and the CPU feedback colours them.+fn highlight_block_tris(app: &SolveApp, b: &solidcraft_engine::doc::ModelBody) -> Option<crate::gpu::BlockTris> {+ if app.preview.effective_replaced().contains(&b.name) {+ return None;+ }+ let map = app.viewport.body_tris.lock().ok()?;+ let (block, tris) = map.get(&b.name)?;+ Some(crate::gpu::BlockTris { block: *block, tris: tris.clone() })}/// The highlight scene: origin widget, construction planes, selection and hover.pub(crate) fn build_highlight(app: &SolveApp) -> GpuScene {+ let began = crate::now_ms();let t = Tokens::get();let mut sc = GpuScene::default();let st = crate::open_meshing::shown_world(app);@@ -2271,17 +2423,22 @@ pub(crate) fn build_highlight(app: &SolveApp) -> GpuScene {|| matches!(hover, Some(Hit::Profile { .. }));let key = highlight_geometry_key(app);if !projected- && let Some(block) = app.viewport.hover_block.lock().ok().and_then(|cache| {- cache- .as_ref()- .filter(|c| c.key == key && std::sync::Arc::ptr_eq(&c.state, &st) && std::sync::Arc::ptr_eq(&c.doc, &s.doc))- .map(|c| c.block.clone())+ && let Some(cached) = app.viewport.hover_block.lock().ok().and_then(|cache| {+ cache.as_ref().filter(|c| c.key == key && std::sync::Arc::ptr_eq(&c.state, &st) && std::sync::Arc::ptr_eq(&c.doc, &s.doc)).cloned()}){- sc.blocks.push(block);+ sc.blocks.push(cached.block);+ sc.hover_planned = cached.hover_planned;+ sc.selected_planned = cached.selected_planned;+ sc.hover_blocks = cached.hover_blocks;+ sc.selected_blocks = cached.selected_blocks;+ sc.hover_instanced = cached.hover_instanced;+ sc.selected_instanced = cached.selected_instanced;return sc;}let mut feedback = GpuScene::default();+ let mut hover_instances = HighlightInstances::default();+ let mut selected_instances = HighlightInstances::default();// Selected things.for x in &sel {match x {@@ -2296,9 +2453,15 @@ pub(crate) fn build_highlight(app: &SolveApp) -> GpuScene {if let Some(b) = st.body(name)&& app.session.body_visible(name){- let m = shown(b);- let count = b.body.face_count();- mesh_tris(&mut feedback, &m, c4(t.body_selected), true, |f| (f as usize) < count);+ if let Some(plan) = highlight_plan(app, b, &active_bodies) {+ feedback.selected_planned.push(plan);+ } else if let Some(tris) = highlight_block_tris(app, b) {+ feedback.selected_blocks.push(tris);+ } else if !selected_instances.add(app, b, &active_bodies, c4(t.body_selected)) {+ let m = shown(b);+ let count = b.body.face_count();+ mesh_tris(&mut feedback, &m, c4(t.body_selected), true, |f| (f as usize) < count);+ }}}Sel::Edge { body, index, point } => {@@ -2350,44 +2513,55 @@ pub(crate) fn build_highlight(app: &SolveApp) -> GpuScene {// Timeline modifiers light only their resulting faces; browser rows light whole bodies.let mut hovered = app.viewport.hover_feature.map(|id| feature_geometry(app, id)).unwrap_or_default();hovered.extend(app.viewport.hover_bodies.iter().map(|name| Sel::Body { name: name.clone() }));+ // By name, once: a whole assembly holds thousands of bodies, and scanning the list for+ // each of them is quadratic (as is a body lookup by name in the world).+ let hovered_whole: std::collections::HashSet<&str> =+ hovered.iter().filter_map(|x| if let Sel::Body { name } = x { Some(name.as_str()) } else { None }).collect();+ let selected_whole: std::collections::HashSet<&str> =+ sel.iter().filter_map(|x| if let Sel::Body { name } = x { Some(name.as_str()) } else { None }).collect();+ let mut hovered_faces: std::collections::HashMap<&str, Vec<usize>> = std::collections::HashMap::new();+ let mut selected_faces: std::collections::HashMap<&str, std::collections::HashSet<usize>> = std::collections::HashMap::new();+ for x in &hovered {+ if let Sel::Face { body, index, .. } = x {+ hovered_faces.entry(body.as_str()).or_default().push(*index);+ }+ }+ for x in &sel {+ if let Sel::Face { body, index, .. } = x {+ selected_faces.entry(body.as_str()).or_default().insert(*index);+ }+ }for b in st.bodies.iter().filter(|b| app.session.body_visible(&b.name) && !app.preview.effective_replaced().contains(&b.name)) {- let whole = hovered.iter().any(|x| matches!(x, Sel::Body { name } if name == &b.name));- let faces: Vec<_> = if whole {- (0..b.body.face_count()).collect()- } else {- hovered- .iter()- .filter_map(|x| match x {- Sel::Face { body, index, .. } if body == &b.name => Some(*index),- _ => None,- })- .collect()- };+ let whole = hovered_whole.contains(b.name.as_str());+ let faces: Vec<usize> =+ if whole { (0..b.body.face_count()).collect() } else { hovered_faces.get(b.name.as_str()).cloned().unwrap_or_default() };if faces.is_empty() {continue;}- let k = t.hover_face_lift;- let c = body_rgb(app, &b.name);let m = drawn_mesh(app, b);- let lit = shown(b);- let selected_body = sel.iter().any(|x| matches!(x, Sel::Body { name } if name == &b.name));+ let base = body_color(&s.doc, b).unwrap_or(t.body);+ let k = t.hover_face_lift;+ let hover_col = [base.r().saturating_add(k), base.g().saturating_add(k), base.b().saturating_add(k), 255];+ let selected_body = selected_whole.contains(b.name.as_str());if !selected_body {- let selected_faces: std::collections::HashSet<usize> = sel- .iter()- .filter_map(|x| {- if let Sel::Face { body, index, .. } = x- && body == &b.name- {- Some(*index)- } else {- None- }- })- .collect();- let hovered_faces: std::collections::HashSet<usize> = faces.iter().copied().collect();- mesh_tris(&mut feedback, &lit, [c.0.saturating_add(k), c.1.saturating_add(k), c.2.saturating_add(k), 255], true, |f| {- hovered_faces.contains(&(f as usize)) && !selected_faces.contains(&(f as usize))- });+ // A whole body the model draws from a plan is lit by redrawing the plan's own+ // evaluated triangles, not by building every triangle again (see `highlight_plan`).+ if whole && let Some(plan) = highlight_plan(app, b, &active_bodies) {+ feedback.hover_planned.push(plan);+ } else if whole && let Some(tris) = highlight_block_tris(app, b) {+ feedback.hover_blocks.push(tris);+ } else if whole && hover_instances.add(app, b, &active_bodies, hover_col) {+ // Its placements carry the highlight colour.+ } else {+ let lit = shown(b);+ let selected_faces = selected_faces.get(b.name.as_str());+ let hovered_faces: std::collections::HashSet<usize> = faces.iter().copied().collect();+ let keeps = |f: u32| {+ let f = f as usize;+ hovered_faces.contains(&f) && selected_faces.is_none_or(|s| !s.contains(&f))+ };+ mesh_tris(&mut feedback, &lit, hover_col, true, keeps);+ }}for (ei, e) in m.edges.iter().enumerate() {if m.edge_pickable(ei) && (whole || m.edge_faces.get(ei).is_some_and(|fs| fs.iter().any(|f| faces.contains(&(*f as usize))))) {@@ -2401,12 +2575,17 @@ pub(crate) fn build_highlight(app: &SolveApp) -> GpuScene {Some(Hit::Face { body, .. }) if app.ui.pick_bodies && app.dialog.is_none() && app.tool.is_none() => {if let Some(b) = st.body(body) {let k = t.hover_face_lift;- let c = body_rgb(app, body);- let m = shown(b);- let count = b.body.face_count();- mesh_tris(&mut feedback, &m, [c.0.saturating_add(k), c.1.saturating_add(k), c.2.saturating_add(k), 255], true, |f| {- (f as usize) < count- });+ let c = body_color(&s.doc, b).unwrap_or(t.body);+ let hover_col = [c.r().saturating_add(k), c.g().saturating_add(k), c.b().saturating_add(k), 255];+ if let Some(plan) = highlight_plan(app, b, &active_bodies) {+ feedback.hover_planned.push(plan);+ } else if let Some(tris) = highlight_block_tris(app, b) {+ feedback.hover_blocks.push(tris);+ } else if !hover_instances.add(app, b, &active_bodies, hover_col) {+ let m = shown(b);+ let count = b.body.face_count();+ mesh_tris(&mut feedback, &m, hover_col, true, |f| (f as usize) < count);+ }}}Some(Hit::Face { body, index, .. })@@ -2450,12 +2629,20 @@ pub(crate) fn build_highlight(app: &SolveApp) -> GpuScene {}_ => {}}+ feedback.hover_instanced = hover_instances.finish();+ feedback.selected_instanced = selected_instances.finish();if projected {sc.tris.append(&mut feedback.tris);sc.trans.append(&mut feedback.trans);sc.lines.append(&mut feedback.lines);sc.hidden.append(&mut feedback.hidden);sc.overlay.append(&mut feedback.overlay);+ sc.hover_planned.append(&mut feedback.hover_planned);+ sc.selected_planned.append(&mut feedback.selected_planned);+ sc.hover_blocks.append(&mut feedback.hover_blocks);+ sc.selected_blocks.append(&mut feedback.selected_blocks);+ sc.hover_instanced.append(&mut feedback.hover_instanced);+ sc.selected_instanced.append(&mut feedback.selected_instanced);} else {let block = crate::gpu::SceneBlock {key,@@ -2466,12 +2653,49 @@ pub(crate) fn build_highlight(app: &SolveApp) -> GpuScene {..Default::default()}),};+ let (hover_planned, selected_planned) = (feedback.hover_planned, feedback.selected_planned);+ let (hover_blocks, selected_blocks) = (feedback.hover_blocks, feedback.selected_blocks);+ let (hover_instanced, selected_instanced) = (feedback.hover_instanced, feedback.selected_instanced);if let Ok(mut cache) = app.viewport.hover_block.lock() {- *cache = Some(HoverBlock { key, state: st.clone(), doc: s.doc.clone(), block: block.clone() });+ *cache = Some(HoverBlock {+ key,+ state: st.clone(),+ doc: s.doc.clone(),+ block: block.clone(),+ hover_planned: hover_planned.clone(),+ selected_planned: selected_planned.clone(),+ hover_blocks: hover_blocks.clone(),+ selected_blocks: selected_blocks.clone(),+ hover_instanced: hover_instanced.clone(),+ selected_instanced: selected_instanced.clone(),+ });}sc.blocks.push(block);+ sc.hover_planned = hover_planned;+ sc.selected_planned = selected_planned;+ sc.hover_blocks = hover_blocks;+ sc.selected_blocks = selected_blocks;+ sc.hover_instanced = hover_instanced;+ sc.selected_instanced = selected_instanced;+ }++ if solidcraft_engine::geom::env::var_os("PROFILE_FRAMES").is_some() {+ let in_blocks = |f: fn(&crate::gpu::SceneBlock) -> usize| sc.blocks.iter().map(f).sum::<usize>();+ let tris = sc.tris.len() + in_blocks(|b| b.bytes.tris.len());+ let lines = sc.lines.len() + in_blocks(|b| b.bytes.lines.len());+ let hidden = sc.hidden.len() + in_blocks(|b| b.bytes.hidden.len());+ eprintln!(+ "SolidCraft highlight: {:.0} ms, hovered {} bodies, planned {} hover + {} selected, blocks {} hover + {} selected, instanced {} hover + {} selected, CPU triangles {tris} B, lines {lines} B, hidden {hidden} B",+ crate::now_ms() - began,+ hovered.len(),+ sc.hover_planned.len(),+ sc.selected_planned.len(),+ sc.hover_blocks.len(),+ sc.selected_blocks.len(),+ sc.hover_instanced.len(),+ sc.selected_instanced.len(),+ );}-sc}@@ -2698,6 +2922,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {}app.viewport.hl_key = hk;}+ crate::frame_watch::step(app, "highlight scene");let ppp = ui.ctx().pixels_per_point();let size_px = [rect.width() * ppp, rect.height() * ppp];let ssaa = supersampling(app, ui.ctx(), proj.vp.to_f32(), size_px);@@ -2735,6 +2960,13 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {let e = proj.cam.eye().to_f32();[e[0], e[1], e[2], if proj.cam.fov > 0.0 { 1.0 } else { 0.0 }]},+ // Whole-body highlights redraw the model's own plan triangles: the hover lifts each+ // body's colour the same amount `mesh_tris` used to, and a selection replaces it.+ hover_tint: [f32::from(t.hover_face_lift) / 255.0; 3],+ selection_tint: {+ let c = t.body_selected;+ [f32::from(c.r()) / 255.0, f32::from(c.g()) / 255.0, f32::from(c.b()) / 255.0]+ },});painter.add(egui_wgpu::Callback::new_paint_callback(rect, cb));}@@ -5075,6 +5307,8 @@ mod tests {eye: [e[0], e[1], e[2], if proj.cam.fov > 0.0 { 1.0 } else { 0.0 }],ao_radius: 0.0,ssaa: 1.0,+ hover_tint: [0.0; 3],+ selection_tint: [0.0; 3],};let t0 = std::time::Instant::now();let mut encoder = device.create_command_encoder(&Default::default());@@ -6247,6 +6481,68 @@ mod tests {}}+ /// A whole highlighted body is lit from the model's own triangles, not by copying every one+ /// of them onto the CPU (a whole assembly lit that way took most of a second a frame): from+ /// its display plan where the model draws one, else from its vertices in the model scene's+ /// blocks. See-through bodies keep the CPU feedback, which colours them.+ #[test]+ fn whole_body_highlights_reuse_the_models_own_triangles() {+ let mut app = cylinder_app();+ app.viewport.gpu = Some(GpuTarget { format: egui_wgpu::wgpu::TextureFormat::Rgba8Unorm, depth: None, samples: 1, tess: true });+ let body = app.session.world_state().bodies[0].clone();+ let plan = body.display_plan().expect("the test body is drawn from a plan");+ app.viewport.hover_bodies = vec![body.name.clone()];+ let hovered = build_highlight(&app);+ assert_eq!(hovered.hover_planned.len(), 1, "the whole hovered body is lit from its plan");+ assert!(std::sync::Arc::ptr_eq(&hovered.hover_planned[0], &plan));+ assert_eq!(hovered.tris.len(), 0);+ assert!(hovered.blocks.iter().all(|b| b.bytes.tris.is_empty()), "no copy of the body's triangles");+ app.viewport.hover_bodies.clear();+ app.session.selection = vec![Sel::Body { name: body.name.clone() }];+ let selected = build_highlight(&app);+ assert_eq!(selected.selected_planned.len(), 1, "a selected whole body is lit from its plan too");+ assert_eq!(selected.tris.len(), 0);+ assert!(selected.blocks.iter().all(|b| b.bytes.tris.is_empty()));+ // A body the model builds on the CPU (here: no GPU plans) is lit from its own vertices+ // in the model scene's blocks.+ app.session.selection.clear();+ app.viewport.hover_bodies.clear();+ app.viewport.gpu = None;+ build_scene(&app);+ app.viewport.hover_bodies = vec![body.name.clone()];+ let built = build_highlight(&app);+ assert!(built.hover_planned.is_empty());+ assert_eq!(built.hover_blocks.len(), 1, "a CPU-built body is lit from the model's block");+ assert_eq!(built.tris.len(), 0);+ assert!(built.blocks.iter().all(|b| b.bytes.tris.is_empty()), "no copy of the body's triangles");+ // Two occurrences of one component are drawn as placements of its shared triangles: the+ // highlight draws those placements again, in its colour.+ let mut s = solidcraft_engine::Session::default();+ s.execute("solid.cylinder", &json!({"radius": 10, "height": 20, "body_name": "Sleeve"})).unwrap();+ let made = s.execute("component.from_bodies", &json!({"bodies": ["Sleeve"]})).unwrap();+ let part = made["components"][0]["component"].as_u64().unwrap();+ s.execute("occurrence.copy", &json!({"component": part, "translate": [40, 0, 0]})).unwrap();+ let mut assembly = SolveApp::new(s, crate::Services::default());+ assembly.ui.show_origin = false;+ let names: Vec<String> = assembly.session.world_state().bodies.iter().map(|b| b.name.clone()).collect();+ assert_eq!(names.len(), 2, "two placements of the part");+ build_scene(&assembly);+ assembly.viewport.hover_bodies = names;+ let instanced = build_highlight(&assembly);+ assert_eq!(instanced.hover_instanced.len(), 1, "the part's one shared mesh");+ assert_eq!(instanced.hover_instanced[0].count(), 2, "both of its placements");+ assert_eq!(instanced.tris.len(), 0);+ assert!(instanced.blocks.iter().all(|b| b.bytes.tris.is_empty()), "no copy of the placements");+ // A see-through body is not in the block's opaque triangles: its feedback is built here.+ app.viewport.hover_bodies.clear();+ app.run("appearance.assign", json!({"bodies": [body.name.clone()], "color": [200, 200, 200], "opacity": 0.5})).unwrap();+ build_scene(&app);+ app.viewport.hover_bodies = vec![body.name.clone()];+ let see_through = build_highlight(&app);+ assert!(see_through.hover_planned.is_empty(), "a see-through body is not drawn from a plan");+ assert!(!see_through.merged().tris.is_empty(), "its highlight is still lit");+ }+#[test]fn smooth_wall_display_preserves_wireframe_and_edge_selection() {let mut s = solidcraft_engine::Session::default();