SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Wave 297/509: Section cap: only closed bodies take part in the crossing count (and 1 more)
jyviko74cb9ca75383
diff --git a/assets/shaders/viewport.wgsl b/assets/shaders/viewport.wgslindex d4c0c46ad1..8960cf20f2 100644--- a/assets/shaders/viewport.wgsl+++ b/assets/shaders/viewport.wgsl@@ -213,13 +213,43 @@ fn fs_solid(i: TOut, @builtin(front_facing) front: bool) -> @location(0) vec4<f3return c;}+/// A section's crossing count (`Cut::count` in `view.rs`): nothing but the cut itself, so the+/// stencil counts only the faces behind the section plane. The colour is not written.+@fragment+fn fs_clip(i: TOut) -> @location(0) vec4<f32> {+ if (clipped(i.wp)) { discard; }+ return vec4<f32>(0.0);+}++@fragment+fn fs_clip_flat(i: FOut) -> @location(0) vec4<f32> {+ if (clipped(i.rp + u.eye.xyz)) { discard; }+ return vec4<f32>(0.0);+}++/// Faces where the section plane is outside every closed body (`Cut::rest`): a back face seen+/// there is the inside of an open body (a surface body, a solid with faces left out), lit as it+/// is without a section rather than hatched, since there is no cut face to show.+@fragment+fn fs_solid_open(i: TOut, @builtin(front_facing) front: bool) -> @location(0) vec4<f32> {+ let c = solid(i, true);+ return c;+}++@fragment+fn fs_solid_open_flat(i: FOut, @builtin(front_facing) front: bool) -> @location(0) vec4<f32> {+ let t = flat_fragment(i, front);+ let c = solid(t, true);+ return c;+}+struct CutOut {@location(0) c: vec4<f32>,@builtin(frag_depth) depth: f32,};-/// The section cap (the inside seen through the cut, drawn on the far walls' back faces where-/// they are the visible surface) again, at the depth of the section plane rather than of the+/// The section cap (where the section plane lies inside a body, drawn on the far walls' back+/// faces) again, at the depth of the section plane rather than of the/// far wall, so the cut face hides what lies inside the body instead of showing it like a/// pane of glass.@fragmentdiff --git a/crates/doc/src/eval.rs b/crates/doc/src/eval.rsindex b60f22765f..364dd155d6 100644--- a/crates/doc/src/eval.rs+++ b/crates/doc/src/eval.rs@@ -73,8 +73,9 @@ pub struct ModelBody {/// [`kernel::measure`] of `body` (with the body it was measured on), worked out once and/// shared by clones: inspecting a design again measures only the bodies that changed.measured: Arc<OnceLock<(Body, kernel::Result<kernel::BodyMeasure>)>>,- /// [`Body::is_surface`] of `body` (with the body it was measured on), worked out once and- /// shared by clones.+ /// Whether `body` is open (with the body it was measured on): a B-rep one a surface body+ /// ([`Body::is_surface`]), a mesh one with a side only one triangle has+ /// ([`Body::is_closed_mesh`]); worked out once and shared by clones.surface: Arc<OnceLock<(Body, bool)>>,/// [`ModelBody::iso_lines`] worked out so far, shared by clones.iso: Arc<std::sync::Mutex<IsoLines>>,@@ -110,10 +111,22 @@ impl ModelBody {/// A surface body: some shell does not close ([`Body::is_surface`]), worked out once.pub fn is_surface(&self) -> bool {- match self.surface.get_or_init(|| (self.body.clone(), self.body.is_surface())) {+ !self.body.is_mesh() && self.is_open()+ }++ /// The body encloses a volume: a solid whose shells all close ([`ModelBody::is_surface`]),+ /// or a mesh body every side of which two triangles share ([`Body::is_closed_mesh`]).+ /// Worked out once.+ pub fn is_closed(&self) -> bool {+ !self.is_open()+ }++ fn is_open(&self) -> bool {+ let open = |b: &Body| if b.is_mesh() { !b.is_closed_mesh() } else { b.is_surface() };+ match self.surface.get_or_init(|| (self.body.clone(), open(&self.body))) {(measured, s) if measured.same(&self.body) => *s,// The body was replaced in this cell's holder since: look again.- _ => self.body.is_surface(),+ _ => open(&self.body),}}diff --git a/crates/engine/src/cmd/file_thumbnail.rs b/crates/engine/src/cmd/file_thumbnail.rsindex 10eb927103..8e43ceffa2 100644--- a/crates/engine/src/cmd/file_thumbnail.rs+++ b/crates/engine/src/cmd/file_thumbnail.rs@@ -37,7 +37,7 @@ fn scene(s: &Session) -> Option<(Scene, Camera)> {let face_colors =s.doc.face_colors(body).into_iter().map(|(face, look)| (face as u32, Rgb(look.color[0], look.color[1], look.color[2]))).collect();let opacity = s.doc.model_body_opacity(body) as f32;- scene.meshes.push(SceneMesh { mesh, color, face_colors, opacity });+ scene.meshes.push(SceneMesh { mesh, color, face_colors, opacity, closed: body.is_closed() });}if bounds.is_empty() {return None;diff --git a/crates/engine/src/view.rs b/crates/engine/src/view.rsindex d56bac0ed2..eef7ee2511 100644--- a/crates/engine/src/view.rs+++ b/crates/engine/src/view.rs@@ -676,7 +676,7 @@ fn build_scene(// A see-through appearance is drawn see-through, as the viewport draws it; a selected// body is drawn solid, so the selection colour reads.let opacity = if selected { 1.0 } else { s.doc.model_body_opacity(body) as f32 };- sc.meshes.push(SceneMesh { mesh: Arc::clone(&mesh), color, face_colors, opacity });+ sc.meshes.push(SceneMesh { mesh: Arc::clone(&mesh), color, face_colors, opacity, closed: body.is_closed() });if cosmetic_threads&& thread_budget.available()&& s.doc.model_body_opacity(body) >= 0.999diff --git a/crates/gpu/src/capture.rs b/crates/gpu/src/capture.rsindex 225c9923e7..8a41c6bc49 100644--- a/crates/gpu/src/capture.rs+++ b/crates/gpu/src/capture.rs@@ -424,8 +424,10 @@ pub fn scene_geometry(scene: &Scene) -> GpuScene {let n = mesh.normals.get(*k as usize).copied().filter(|n| n.is_finite() && n.len() > 0.5).unwrap_or(flat);if m.glass() {sc.glass_tri(p.to_f32(), n.to_f32(), col);- } else {+ } else if m.closed {sc.tri(p.to_f32(), n.to_f32(), col);+ } else {+ sc.open_tri(p.to_f32(), n.to_f32(), col);}}}@@ -580,7 +582,7 @@ mod tests {/// headless picture of a translucent target shows the tool inside it.#[test]fn a_see_through_body_is_glass_at_its_own_alpha_and_a_solid_one_is_not() {- let mesh = |opacity: f32| SceneMesh { mesh: sheet(), color: Rgb(200, 30, 30), face_colors: Vec::new(), opacity };+ let mesh = |opacity: f32| SceneMesh { mesh: sheet(), color: Rgb(200, 30, 30), face_colors: Vec::new(), opacity, closed: true };let geometry = |opacity: f32| scene_geometry(&Scene { meshes: vec![mesh(opacity)], ..Default::default() });let solid = geometry(1.0);@@ -604,7 +606,7 @@ mod tests {/// painting one face does not make the body solid again.#[test]fn a_painted_face_keeps_its_bodys_opacity() {- let mesh = SceneMesh { mesh: sheet(), color: Rgb(200, 30, 30), face_colors: vec![(0, Rgb(0, 255, 0))], opacity: 0.5 };+ let mesh = SceneMesh { mesh: sheet(), color: Rgb(200, 30, 30), face_colors: vec![(0, Rgb(0, 255, 0))], opacity: 0.5, closed: true };let sc = scene_geometry(&Scene { meshes: vec![mesh], ..Default::default() });assert_eq!(sc.tris.len(), 0);assert_eq!(color(&sc, &sc.glass), Some([0, 255, 0, 128]), "the face's own colour at the body's alpha");diff --git a/crates/gpu/src/view.rs b/crates/gpu/src/view.rsindex 28c6b76969..7cec789f88 100644--- a/crates/gpu/src/view.rs+++ b/crates/gpu/src/view.rs@@ -163,6 +163,10 @@ pub struct PlannedBody {/// How the whole body is drawn: opaque with the model, or faded or see-through blended/// order-independently (only on a renderer that does that: [`GpuTarget::oit`]).pub class: TriClass,+ /// The body encloses a volume (a solid, a closed mesh). Only closed bodies take part in a+ /// section's crossing count ([`Cut`]): an open one has no inside, so it neither gets a cap+ /// nor takes one from the body it lies in.+ pub closed: bool,}/// What the viewport's last frame drew, counted as it was drawn (the performance overlay, #2548).@@ -403,6 +407,8 @@ pub struct InstancedMesh {/// in the part's frame): a placement small on screen is drawn from the coarsest whose error/// stays under [`LOD_PX`] there ([`Batches::cull`]).pub levels: Vec<(Arc<SharedTris>, f32)>,+ /// The triangles enclose a volume (see [`PlannedBody::closed`]).+ pub closed: bool,}impl InstancedMesh {@@ -447,6 +453,9 @@ pub struct GpuScene {pub palette: Arc<Palette>,/// Opaque triangles. A zero normal draws the colour flat (unlit).pub tris: Vec<u8>,+ /// Opaque triangles of open bodies, drawn as `tris` but left out of a section's crossing+ /// count (see [`PlannedBody::closed`]).+ pub open_tris: Vec<u8>,/// Opaque product PBR vertices; linear base color and explicit optical parameters.pub pbr: Vec<u8>,/// Translucent triangles (alpha from the colour), drawn after the opaque ones without@@ -538,6 +547,7 @@ impl GpuScene {}}out.tris.append(&mut self.tris);+ out.tris.append(&mut self.open_tris);out.trans.append(&mut self.trans);out.lines.append(&mut self.lines);out.hidden.append(&mut self.hidden);@@ -603,6 +613,9 @@ pub enum TriClass {pub struct BlockBytes {pub vertices: Arc<Vec<u8>>,pub opaque: Arc<Vec<std::ops::Range<u32>>>,+ /// The opaque runs of closed bodies: what a section's crossing count draws (see+ /// [`PlannedBody::closed`]).+ pub closed: Arc<Vec<std::ops::Range<u32>>>,pub glass: Arc<Vec<std::ops::Range<u32>>>,pub faded: Arc<Vec<std::ops::Range<u32>>>,pub lines: Arc<Vec<u8>>,@@ -634,6 +647,9 @@ pub fn extend_runs(runs: &mut Vec<std::ops::Range<u32>>, at: u32) {pub struct BlockBuilder {vertices: Vec<u8>,opaque: Vec<std::ops::Range<u32>>,+ closed: Vec<std::ops::Range<u32>>,+ /// The triangles being added belong to an open body ([`BlockBuilder::open_body`]).+ open: bool,glass: Vec<std::ops::Range<u32>>,faded: Vec<std::ops::Range<u32>>,lines: Vec<u8>,@@ -664,6 +680,16 @@ impl BlockBuilder {TriClass::Faded => &mut self.faded,};extend_runs(runs, at);+ if class == TriClass::Opaque && !self.open {+ extend_runs(&mut self.closed, at);+ }+ }++ /// Whether the triangles added from now on belong to an open body (a surface body, a mesh+ /// that does not close): those are left out of a section's crossing count. Closed until+ /// said otherwise.+ pub fn open_body(&mut self, open: bool) {+ self.open = open;}/// The runs of `class` that fall within `vertices` (a body's share of the block).@@ -705,6 +731,7 @@ impl BlockBuilder {Arc::new(BlockBytes {vertices: Arc::new(self.vertices),opaque: Arc::new(self.opaque),+ closed: Arc::new(self.closed),glass: Arc::new(self.glass),faded: Arc::new(self.faded),lines: Arc::new(self.lines),@@ -727,6 +754,13 @@ impl GpuScene {}self.tris.extend_from_slice(&c.0.to_le_bytes());}+ /// A vertex of an open body's opaque triangle (see [`GpuScene::open_tris`]).+ pub fn open_tri(&mut self, p: [f32; 3], n: [f32; 3], c: PaletteIndex) {+ for v in p.iter().chain(&n) {+ self.open_tris.extend_from_slice(&v.to_le_bytes());+ }+ self.open_tris.extend_from_slice(&c.0.to_le_bytes());+ }/// A vertex of the ground-plane shadow (see [`GpuScene::shadow`]).pub fn shadow_tri(&mut self, p: [f32; 3], c: PaletteIndex) {for v in p.iter().chain(&[0.0; 3]) {@@ -1003,8 +1037,10 @@ struct Batch {struct PlannedDraw {mesh: Arc<crate::GpuMesh>,colors: wgpu::Buffer,- /// Its bodies' class: a chunk holds bodies of one class.+ /// Its bodies' class and whether they are closed: a chunk holds bodies of one class, all+ /// closed or all open.class: TriClass,+ closed: bool,/// 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>,@@ -1141,6 +1177,8 @@ struct LevelDraw {/// while they come back), and the placements in view, each drawn from its level.struct InstancedDraw {look: InstanceLook,+ /// Its triangles enclose a volume ([`InstancedMesh::closed`]).+ closed: bool,/// The full triangles first, then coarser ones.levels: Vec<LevelDraw>,bounds: [[f32; 3]; 2],@@ -1206,6 +1244,9 @@ struct BlockGpu {bytes: Arc<BlockBytes>,vertices: Option<wgpu::Buffer>,opaque: Option<ClassGpu>,+ /// The opaque runs of closed bodies ([`BlockBytes::closed`]): `opaque`'s own when they are+ /// all of them.+ closed: Option<ClassGpu>,glass: Option<ClassGpu>,faded: Option<ClassGpu>,lines: Option<Batch>,@@ -1272,6 +1313,12 @@ impl BlockGpu {class_gpu(device, fits, &bytes.vertices, bytes.runs(class), old_pair, same_vertices, uploaded)};let (opaque, glass, faded) = (class(TriClass::Opaque), class(TriClass::Glass), class(TriClass::Faded));+ let closed = if bytes.closed == bytes.opaque {+ opaque.clone()+ } else {+ let old_pair = old.as_ref().and_then(|o| o.closed.as_ref().map(|c| (c, &o.bytes.closed)));+ class_gpu(device, fits, &bytes.vertices, &bytes.closed, old_pair, same_vertices, uploaded)+ };let keep = |old: Option<&BlockGpu>, pick: fn(&BlockBytes) -> &Arc<Vec<u8>>, old_lines: fn(&BlockGpu) -> Option<&Batch>| {old.filter(|o| Arc::ptr_eq(pick(&o.bytes), pick(&bytes))).and_then(old_lines).cloned()};@@ -1281,7 +1328,7 @@ impl BlockGpu {};let lines = keep(old.as_ref(), |b| &b.lines, |b| b.lines.as_ref()).or_else(|| fresh(&bytes.lines, "sc_block_lines"));let hidden = keep(old.as_ref(), |b| &b.hidden, |b| b.hidden.as_ref()).or_else(|| fresh(&bytes.hidden, "sc_block_hidden"));- BlockGpu { bytes, vertices, opaque, glass, faded, lines, hidden }+ BlockGpu { bytes, vertices, opaque, closed, glass, faded, lines, hidden }}fn class(&self, class: TriClass) -> Option<&ClassGpu> {@@ -1294,7 +1341,16 @@ impl BlockGpu {/// Draw `class`'s triangles with the pipeline already set (`tally`: what is counted).fn draw(&self, pass: &mut wgpu::RenderPass<'_>, class: TriClass, tally: &Tally) {- match self.class(class) {+ self.draw_runs(pass, self.class(class), tally);+ }++ /// Draw the closed bodies' opaque triangles ([`BlockBytes::closed`]), as [`BlockGpu::draw`].+ fn draw_closed(&self, pass: &mut wgpu::RenderPass<'_>, tally: &Tally) {+ self.draw_runs(pass, self.closed.as_ref(), tally);+ }++ fn draw_runs(&self, pass: &mut wgpu::RenderPass<'_>, runs: Option<&ClassGpu>, tally: &Tally) {+ match runs {Some(ClassGpu::Runs(runs)) => {let Some(vertices) = &self.vertices else { return };pass.set_vertex_buffer(0, vertices.slice(..));@@ -1485,6 +1541,8 @@ struct Batches {block_order: Vec<u64>,key: Option<u64>,tris: Option<Batch>,+ /// [`GpuScene::open_tris`].+ open_tris: Option<Batch>,pbr: Option<Batch>,trans: Option<Batch>,shadow: Option<Batch>,@@ -1576,6 +1634,7 @@ impl Batches {upload(device, label, data, stride)};self.tris = own("sc_tris", &sc.tris, TRI_SIZE);+ self.open_tris = own("sc_open_tris", &sc.open_tris, TRI_SIZE);self.pbr = own("sc_pbr", &sc.pbr, PBR_SIZE);self.trans = own("sc_trans", &sc.trans, TRI_SIZE);self.shadow = own("sc_shadow", &sc.shadow, TRI_SIZE);@@ -1658,7 +1717,7 @@ impl Batches {self.instanced_tris.insert(key, gpu);}if !levels.is_empty() {- out.push(InstancedDraw { look: m.look, levels, bounds: m.tris.bounds, placements, shown: None });+ out.push(InstancedDraw { look: m.look, closed: m.closed, levels, bounds: m.tris.bounds, placements, shown: None });}}out@@ -1741,7 +1800,9 @@ impl Batches {for b in bodies {let n = b.plan.vertex_count();match chunks.last_mut() {- Some(c) if open && filled + n <= crate::MAX_BATCH && c.first().is_some_and(|f| f.class == b.class) => c.push(b),+ Some(c) if open && filled + n <= crate::MAX_BATCH && c.first().is_some_and(|f| (f.class, f.closed) == (b.class, b.closed)) => {+ c.push(b)+ }_ => {chunks.push(vec![b]);filled = 0;@@ -1785,26 +1846,42 @@ impl Batches {}self.uploads.planned += bytes.len() as u64;if let Some((colors, _)) = upload(device, "sc_planned_colors", &bytes, 4).and_then(|c| c.parts.into_iter().next()) {- let class = chunk.first().map_or(TriClass::Opaque, |b| b.class);- out.push(PlannedDraw { mesh, colors, class, plans: key(chunk) });+ let (class, closed) = chunk.first().map_or((TriClass::Opaque, true), |b| (b.class, b.closed));+ out.push(PlannedDraw { mesh, colors, class, closed, plans: key(chunk) });}}out}}-/// The section's pipelines (see `Renderer::tri_cut`).+/// Where a section's crossing count starts (`Cut::count`): half the stencil's range, so a count+/// that goes below it (more faces entered than left: an open sheet's front) stays apart from one+/// above it.+const STENCIL_BASE: u32 = 128;++/// The section's pipelines (see `Renderer::tri_cut`), drawn in this order. The cap shows where+/// the section plane lies inside a body: where the faces behind the plane, on the view ray+/// through the pixel, are left by the ray more often than entered. The stencil counts them, so+/// no depth is compared where bodies touch: a cut body's far wall and the face of the body it+/// rests on lie at one depth, and settling that by depth let the other body show through the+/// cap in specks, stripes and triangles. The display meshes are watertight, so the count is+/// exact for closed bodies; an open one (a surface body, a solid with faces left out) gets no+/// cap.struct Cut {- /// Draws the faces and marks the stencil by their true depth: 1 where a back face (the cap)- /// is the visible surface. Unpushed: `FACE_BIAS`'s slope part would let a front face win a- /// band along its edge with a back face seen through the cut, and the cap would skip it (#6328).- mark: wgpu::RenderPipeline,- /// The faces' depth again, pushed back by `FACE_BIAS` as unsectioned faces are (after- /// `Renderer::section_reset`), so their edges draw over them (#1434). No colour, no stencil.- push: wgpu::RenderPipeline,- /// The cap again, only where marked, at the section plane's depth: depth only, as the mark- /// drew the cap's colour (#6728).+ /// Counts the crossings in the stencil from [`STENCIL_BASE`]: a back face behind the plane+ /// adds one, a front face takes one away. No colour, no depth. Above the base, the plane is+ /// inside a body; at or below it, outside (an open sheet seen from its front counts below).+ count: wgpu::RenderPipeline,+ /// Where the count is above the base, the nearest back face, by its true depth, in its body's cut+ /// colour (the body the plane lies inside: the ray leaves it there).+ fill: wgpu::RenderPipeline,+ /// The cap again, only there, at the section plane's depth (pushed as faces are), so what+ /// lies on the cut face draws over it: depth only, as `fill` drew its colour (#6728).cap: wgpu::RenderPipeline,+ /// Elsewhere, the faces as they are drawn without a section, pushed back by+ /// `FACE_BIAS` so their edges draw over them (#1434); a back face there is an open body's+ /// inside, lit, not hatched.+ rest: wgpu::RenderPipeline,}/// The viewport's pipelines and the scenes uploaded to one device, for one kind of target.@@ -1835,8 +1912,8 @@ pub struct Renderer {/// 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), in place of `tri`: the- /// faces marking where the cap shows, their depth pushed back, then the cap again at the- /// section plane's depth, so it hides the inside ([`Cut`]).+ /// faces behind the plane counted where the cap shows, the cap in its colour and at the+ /// section plane's depth, so it hides the inside, then the other faces ([`Cut`]).tri_cut: Option<Cut>,/// Highlight triangles over the model (depth test ≤, no depth write).tri_hl: wgpu::RenderPipeline,@@ -1924,9 +2001,9 @@ pub struct Renderer {/// Reversed depth drawn into the window's pass: egui clears its depth to 1, which is the near/// plane then, so the viewport first sets its rectangle to the far plane (0).depth_reset: Option<wgpu::RenderPipeline>,- /// The scene target's depth back to the far plane between the section's marking and push- /// passes ([`Cut`]); stencil and colour untouched.- section_reset: Option<wgpu::RenderPipeline>,+ /// The scene target's stencil set to [`STENCIL_BASE`] before a section's crossing count+ /// ([`Cut`]); depth and colour untouched.+ section_stencil: Option<wgpu::RenderPipeline>,}/// A triangle over the whole viewport at the far plane's depth (`FAR`), writing no colour:@@ -2456,36 +2533,40 @@ impl Renderer {let solid = |label: &str, fs: &str, cull: Option<wgpu::Face>, ds: Option<wgpu::DepthStencilState>, source: TriSource| {solid_writes(label, fs, cull, ds, source, true)};- // While a section is shown: the stencil marking and the cap (see `Renderer::tri_cut`).+ // While a section is shown: the crossing count and the cap (see `Cut`), drawn with the+ // stencil reference `STENCIL_BASE`.let cut = |source: TriSource| {t.depth.filter(|f| f.has_stencil_aspect()).map(|format| {- // The visible surface, by its true depth, marks the stencil: 1 where it is a back face (the cap).- use wgpu::StencilOperation::{Keep, Replace, Zero};- let face = |pass_op| wgpu::StencilFaceState { compare: wgpu::CompareFunction::Always, fail_op: Keep, depth_fail_op: Keep, pass_op };- let mark = wgpu::DepthStencilState {+ use wgpu::CompareFunction::{Always, GreaterEqual, Less};+ use wgpu::StencilOperation::{DecrementWrap, IncrementWrap, Keep};+ let face = |compare, pass_op| wgpu::StencilFaceState { compare, fail_op: Keep, depth_fail_op: Keep, pass_op };+ let stencil = |front, back, write_mask| wgpu::StencilState { front, back, read_mask: 0xff, write_mask };+ let count = wgpu::DepthStencilState {format,- depth_write_enabled: Some(true),- depth_compare: Some(depth_compare(reversed, wgpu::CompareFunction::Less)),- stencil: wgpu::StencilState { front: face(Zero), back: face(Replace), read_mask: 0xff, write_mask: 0xff },+ depth_write_enabled: Some(false),+ depth_compare: Some(Always),+ stencil: stencil(face(Always, DecrementWrap), face(Always, IncrementWrap), 0xff),bias: Default::default(),};- // Then the cap's back faces again, only there, at the section plane's depth.- let only = wgpu::StencilFaceState { compare: wgpu::CompareFunction::Equal, ..face(Keep) };- let cap = wgpu::DepthStencilState {- format,+ // The reference (`STENCIL_BASE`) below the count: the plane is inside a body.+ let inside = stencil(face(Less, Keep), face(Less, Keep), 0);+ let fill = wgpu::DepthStencilState {depth_write_enabled: Some(true),- depth_compare: Some(wgpu::CompareFunction::Always),- stencil: wgpu::StencilState { front: only, back: only, read_mask: 0xff, write_mask: 0 },- bias: Default::default(),+ depth_compare: Some(depth_compare(reversed, wgpu::CompareFunction::Less)),+ stencil: inside.clone(),+ ..count.clone()};+ let cap = wgpu::DepthStencilState { depth_write_enabled: Some(true), stencil: inside, ..count.clone() };+ let outside = stencil(face(GreaterEqual, Keep), face(GreaterEqual, Keep), 0);+ let rest = pushed(wgpu::CompareFunction::Less, true, FACE_BIAS).map(|d| wgpu::DepthStencilState { stencil: outside, ..d });Cut {- mark: solid("sc_tris_mark", "fs_solid", None, Some(mark), source),- push: solid_writes("sc_tris_push", "fs_solid", None, pushed(wgpu::CompareFunction::Less, true, FACE_BIAS), source, false),- // Depth only: every back face behind a marked pixel draws here, so writing+ count: solid_writes("sc_tris_count", "fs_clip", None, Some(count), source, false),+ fill: solid("sc_tris_fill", "fs_solid", Some(wgpu::Face::Front), Some(fill), source),+ // Depth only: every back face behind a cap pixel draws here, so writing// colour let the last one drawn paint the cut, other bodies behind it- // included (their colours and outlines showed through it, #6328). The- // marking pass already drew the nearest back face's colour.+ // included (their colours and outlines showed through it, #6328).cap: solid_writes("sc_tris_cap", "fs_solid_cut", Some(wgpu::Face::Front), Some(cap), source, false),+ rest: solid("sc_tris_rest", "fs_solid_open", None, rest, source),}})};@@ -2557,7 +2638,7 @@ impl Renderer {Renderer {ao,depth_reset,- section_reset: t.depth.filter(|f| f.has_stencil_aspect()).and_then(|_| depth_reset_pipeline(device, t)),+ section_stencil: stencil_set_pipeline(device, t),target: GpuTarget { oit: oit.is_some(), ..t },window,max_texture: device.limits().max_texture_dimension_2d,@@ -2676,25 +2757,51 @@ const GHOST_BIAS: wgpu::DepthBiasState = wgpu::DepthBiasState { constant: 2 * FA/// leaving colour and stencil as they are. None without a depth buffer.fn depth_reset_pipeline(device: &wgpu::Device, t: GpuTarget) -> Option<wgpu::RenderPipeline> {let format = t.depth?;+ let reset = wgpu::DepthStencilState {+ format,+ depth_write_enabled: Some(true),+ depth_compare: Some(wgpu::CompareFunction::Always),+ stencil: Default::default(),+ bias: Default::default(),+ };+ Some(viewport_pipeline(device, t, "sc_depth_reset", reset))+}++/// A pipeline that sets the stencil of the viewport in a pass of `t`'s kind to the reference,+/// leaving colour and depth as they are: a section's crossing count starts from it ([`Cut`]).+/// None without a stencil.+fn stencil_set_pipeline(device: &wgpu::Device, t: GpuTarget) -> Option<wgpu::RenderPipeline> {+ let format = t.depth.filter(|f| f.has_stencil_aspect())?;+ let replace = wgpu::StencilFaceState {+ compare: wgpu::CompareFunction::Always,+ fail_op: wgpu::StencilOperation::Keep,+ depth_fail_op: wgpu::StencilOperation::Keep,+ pass_op: wgpu::StencilOperation::Replace,+ };+ let set = wgpu::DepthStencilState {+ format,+ depth_write_enabled: Some(false),+ depth_compare: Some(wgpu::CompareFunction::Always),+ stencil: wgpu::StencilState { front: replace, back: replace, read_mask: 0xff, write_mask: 0xff },+ bias: Default::default(),+ };+ Some(viewport_pipeline(device, t, "sc_stencil_set", set))+}++/// A triangle over the whole viewport in a pass of `t`'s kind, writing no colour, with `ds`.+fn viewport_pipeline(device: &wgpu::Device, t: GpuTarget, label: &str, ds: wgpu::DepthStencilState) -> wgpu::RenderPipeline {let far = if t.reversed_depth() { "0.0" } else { "1.0" };let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {- label: Some("sc_depth_reset"),+ label: Some(label),source: wgpu::ShaderSource::Wgsl(DEPTH_RESET_SHADER.replace("FAR", far).into()),});- let layout =- device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { label: Some("sc_depth_reset"), bind_group_layouts: &[], immediate_size: 0 });- Some(device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {- label: Some("sc_depth_reset"),+ let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { label: Some(label), bind_group_layouts: &[], immediate_size: 0 });+ device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {+ label: Some(label),layout: Some(&layout),vertex: wgpu::VertexState { module: &module, entry_point: Some("vs"), buffers: &[], compilation_options: Default::default() },primitive: wgpu::PrimitiveState { topology: wgpu::PrimitiveTopology::TriangleList, ..Default::default() },- depth_stencil: Some(wgpu::DepthStencilState {- format,- depth_write_enabled: Some(true),- depth_compare: Some(wgpu::CompareFunction::Always),- stencil: Default::default(),- bias: Default::default(),- }),+ depth_stencil: Some(ds),multisample: wgpu::MultisampleState { count: t.samples.max(1), mask: !0, alpha_to_coverage_enabled: false },fragment: Some(wgpu::FragmentState {module: &module,@@ -2704,7 +2811,7 @@ fn depth_reset_pipeline(device: &wgpu::Device, t: GpuTarget) -> Option<wgpu::Ren}),multiview_mask: None,cache: None,- }))+ })}fn upload(device: &wgpu::Device, label: &str, bytes: &[u8], stride: usize) -> Option<Batch> {@@ -3088,8 +3195,9 @@ impl Renderer {pass.set_bind_group(1, &res.access_bind, &[]);pass.set_bind_group(2, &res.ao.bind, &[]);pass.set_bind_group(0, scene_bind(m, &res.bind), &[]);- let planned = |pass: &mut wgpu::RenderPass<'static>, p: &wgpu::RenderPipeline| {- for d in m.planned.iter().filter(|d| d.class == TriClass::Opaque) {+ // `counting`: only closed bodies, for a section's crossing count ([`Cut::count`]).+ let planned = |pass: &mut wgpu::RenderPass<'static>, p: &wgpu::RenderPipeline, counting: bool| {+ for d in m.planned.iter().filter(|d| d.class == TriClass::Opaque && (d.closed || !counting)) {pass.set_pipeline(p);pass.set_vertex_buffer(0, d.mesh.vertices.slice(..));pass.set_vertex_buffer(1, d.colors.slice(..));@@ -3099,8 +3207,8 @@ impl Renderer {}};// Instanced meshes, with the pipeline for smooth and for flat triangles.- let instanced = |pass: &mut wgpu::RenderPass<'static>, smooth: &wgpu::RenderPipeline, flat: &wgpu::RenderPipeline| {- for d in m.instanced.iter().filter(|d| d.look == InstanceLook::Opaque) {+ let instanced = |pass: &mut wgpu::RenderPass<'static>, smooth: &wgpu::RenderPipeline, flat: &wgpu::RenderPipeline, counting: bool| {+ for d in m.instanced.iter().filter(|d| d.look == InstanceLook::Opaque && (d.closed || !counting)) {d.draw(pass, smooth, flat, tally);}};@@ -3147,36 +3255,51 @@ impl Renderer {res.tri_cut_planned.as_ref(),res.tri_cut_instanced.as_ref(),res.tri_cut_instanced_flat.as_ref(),- res.section_reset.as_ref(),+ res.section_stencil.as_ref(),) {- (Some(cut), Some(cut_planned), Some(cut_instanced), Some(cut_flat), Some(reset)) => {+ (Some(cut), Some(cut_planned), Some(cut_instanced), Some(cut_flat), Some(base)) => {// The model's own triangles, blocks, plans and instances with its palette, then the// preview's with its own.- let all = |pass: &mut wgpu::RenderPass<'static>, pick: fn(&Cut) -> &wgpu::RenderPipeline| {+ // `counting`: the crossing count, which leaves open bodies out.+ let all = |pass: &mut wgpu::RenderPass<'static>, pick: fn(&Cut) -> &wgpu::RenderPipeline, counting: bool| {pass.set_bind_group(0, scene_bind(m, &res.bind), &[]);tris(pass, pick(cut), &m.tris);- block_class(pass, pick(cut), TriClass::Opaque);- planned(pass, pick(cut_planned));- instanced(pass, pick(cut_instanced), pick(cut_flat));+ if counting {+ for block in m.block_order.iter().filter_map(|k| m.blocks.get(k)).filter(|b| b.closed.is_some()) {+ pass.set_pipeline(pick(cut));+ block.draw_closed(pass, tally);+ }+ } else {+ tris(pass, pick(cut), &m.open_tris);+ block_class(pass, pick(cut), TriClass::Opaque);+ }+ planned(pass, pick(cut_planned), counting);+ instanced(pass, pick(cut_instanced), pick(cut_flat), counting);pass.set_bind_group(0, scene_bind(pv, &res.bind), &[]);tris(pass, pick(cut), &pv.tris);+ if !counting {+ tris(pass, pick(cut), &pv.open_tris);+ }};- pass.set_stencil_reference(1);- all(pass, |c| &c.mark);- pass.set_pipeline(reset);+ pass.set_stencil_reference(STENCIL_BASE);+ pass.set_pipeline(base);pass.draw(0..3, 0..1);tally.call();- all(pass, |c| &c.push);- all(pass, |c| &c.cap);+ all(pass, |c| &c.count, true);+ all(pass, |c| &c.fill, false);+ all(pass, |c| &c.cap, false);+ all(pass, |c| &c.rest, false);}_ => {pass.set_bind_group(0, scene_bind(m, &res.bind), &[]);tris(pass, &res.tri, &m.tris);+ tris(pass, &res.tri, &m.open_tris);block_class(pass, &res.tri, TriClass::Opaque);- planned(pass, &res.tri_planned);- instanced(pass, &res.tri_instanced, &res.tri_instanced_flat);+ planned(pass, &res.tri_planned, false);+ instanced(pass, &res.tri_instanced, &res.tri_instanced_flat, false);pass.set_bind_group(0, scene_bind(pv, &res.bind), &[]);tris(pass, &res.tri, &pv.tris);+ tris(pass, &res.tri, &pv.open_tris);}}pass.set_bind_group(0, scene_bind(m, &res.bind), &[]);diff --git a/crates/gpu/src/view/ao.rs b/crates/gpu/src/view/ao.rsindex e6e51525c2..2783c0a336 100644--- a/crates/gpu/src/view/ao.rs+++ b/crates/gpu/src/view/ao.rs@@ -155,7 +155,7 @@ impl Resources {for (batch, bind) in batches.into_iter().zip(binds) {pass.set_bind_group(0, bind, &[]);pass.set_pipeline(&self.pipeline);- if let Some(tris) = &batch.tris {+ for tris in [&batch.tris, &batch.open_tris].into_iter().flatten() {for (buffer, count) in &tris.parts {pass.set_vertex_buffer(0, buffer.slice(..));pass.draw(0..*count, 0..1);diff --git a/crates/gpu/tests/depth.rs b/crates/gpu/tests/depth.rsindex dc5461fc28..a5be94a91e 100644--- a/crates/gpu/tests/depth.rs+++ b/crates/gpu/tests/depth.rs@@ -287,6 +287,60 @@ fn an_edge_on_the_cut_face_draws_over_the_cap() {}}+/// A cut body's cap covers the body it touches behind the cut. A block whose far face (y = 30)+/// lies on a larger plate's front face, cut at y = 15: through the cut the block's far wall and+/// the plate's face are at one depth. When the cap went to the nearer of the two by depth, the+/// plate showed through 2721 of its 4350 px here (an engine's sleeves in their bores, pins in+/// their bosses); counted by crossings, the cap is the same with the plate as without it. An+/// open body behind it (a box without its far face, whose near face alone the ray crosses)+/// takes nothing from the cap either: only closed bodies are counted.+#[test]+fn a_cap_covers_the_body_its_cut_body_touches() {+ let block = ("solid.box", json!({"length": 40, "width": 30, "height": 20, "body_name": "block"}));+ let plate = ("solid.box", json!({"length": 70, "width": 10, "height": 50, "corner": [-15, 30, -15], "operation": "new", "body_name": "plate"}));+ let shell = ("solid.box", json!({"length": 70, "width": 10, "height": 50, "corner": [-15, 35, -15], "operation": "new", "body_name": "shell"}));+ let far_face = ("face.delete", json!({"faces": [[20, 45, 10]], "heal": false}));+ let cut = ("inspect.section", json!({"plane": {"origin": [0, 15, 0], "normal": [0, -1, 0]}}));+ let alone = session(&[block.clone(), cut.clone()]);+ let touching = session(&[block.clone(), plate, cut.clone()]);+ let open = session(&[block, shell, far_face, cut]);+ assert!(open.world_state().unwrap().body("shell").unwrap().body.is_surface());+ let (w, h) = (360, 280);+ for (mode, c) in capturers() {+ for (what, other) in [("the touching plate", &touching), ("an open shell behind", &open)] {+ for fov in [0.0, 0.6] {+ let mut cam = view::home_camera(&touching).unwrap();+ (cam.fov, cam.yaw, cam.pitch) = (fov, -0.3, 0.2);+ let radius = view::scene(&touching, &cam).unwrap().radius;+ let shot = |s: &Session| {+ c.rgba(&Scene { grid: Vec::new(), lines: Vec::new(), radius, ..view::scene(s, &cam).unwrap() }, &cam, w, h).unwrap()+ };+ let (a, b) = (shot(&alone), shot(other));+ // The cap on screen: the cut's rectangle (x 0..40, z 0..20 at y = 15), 2 px in.+ let corner = |x: f64, z: f64| cam.to_screen(Vec3::new(x, 15.0, z), f64::from(w), f64::from(h), radius).map(|(x, y, _)| (x, y));+ let cap: Vec<(f64, f64)> = [(0.0, 0.0), (40.0, 0.0), (40.0, 20.0), (0.0, 20.0)].iter().filter_map(|(x, z)| corner(*x, *z)).collect();+ assert_eq!(cap.len(), 4, "fov {fov}: the cut is on screen");+ let turn = (0..4).map(|i| cap[i].0 * cap[(i + 1) % 4].1 - cap[(i + 1) % 4].0 * cap[i].1).sum::<f64>().signum();+ let inside = |x: f64, y: f64| {+ (0..4).all(|i| {+ let ((ax, ay), (bx, by)) = (cap[i], cap[(i + 1) % 4]);+ ((bx - ax) * (y - ay) - (by - ay) * (x - ax)) / (bx - ax).hypot(by - ay) * turn >= 2.0+ })+ };+ let (mut shown, mut all) = (0, 0);+ for (i, (p, q)) in pixels(&a).zip(pixels(&b)).enumerate() {+ if inside((i % w as usize) as f64 + 0.5, (i / w as usize) as f64 + 0.5) {+ all += 1;+ shown += usize::from(p.iter().zip(q).any(|(u, v)| u.abs_diff(v) > 24));+ }+ }+ assert!(all > 3000, "{mode}, fov {fov}: the cap ({all} px)");+ assert_eq!(shown, 0, "{mode} depth, fov {fov}: {what} shows through {shown} of {all} cap px");+ }+ }+ }+}+/// Pixels of the model's edges lying behind the section plane (recoloured red) that draw over/// the cap: the cap's pixels are where the picture without lines shows the hatch (warm, with/// warm pixels 3 px around, so the cut's outline doesn't count).diff --git a/crates/render/src/raster.rs b/crates/render/src/raster.rsindex 86ad798a03..7cd128b711 100644--- a/crates/render/src/raster.rs+++ b/crates/render/src/raster.rs@@ -424,7 +424,7 @@ mod tests {/// A front panel over a back one, with a line between them, seen from the front.fn two_panels(front_opacity: f32) -> (Scene, Camera) {- let glass = SceneMesh { mesh: Arc::new(panel(-5.0)), color: Rgb(255, 0, 0), face_colors: Vec::new(), opacity: front_opacity };+ let glass = SceneMesh { mesh: Arc::new(panel(-5.0)), color: Rgb(255, 0, 0), face_colors: Vec::new(), opacity: front_opacity, closed: true };let scene = Scene {meshes: vec![SceneMesh::solid(Arc::new(panel(5.0)), Rgb(0, 255, 0)), glass],lines: vec![SceneLine {diff --git a/crates/render/src/scene.rs b/crates/render/src/scene.rsindex 79744b516d..ae90fe2b12 100644--- a/crates/render/src/scene.rs+++ b/crates/render/src/scene.rs@@ -27,12 +27,15 @@ pub struct SceneMesh {/// drawn see-through, so what lies inside it shows, as the viewport draws glass. A body/// without an appearance of its own is solid.pub opacity: f32,+ /// The body encloses a volume (a solid, a closed mesh); an open one (a surface body, a solid+ /// with faces left out) has no inside, so a section gives it no cap.+ pub closed: bool,}impl SceneMesh {/// A solid body in `color`, with no face of its own look.pub fn solid(mesh: Arc<Mesh>, color: Rgb) -> SceneMesh {- SceneMesh { mesh, color, face_colors: Vec::new(), opacity: 1.0 }+ SceneMesh { mesh, color, face_colors: Vec::new(), opacity: 1.0, closed: true }}/// Is the body drawn see-through? (Its opacity is below [`SEE_THROUGH`].)diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rsindex b40afaec5c..e1a0b402eb 100644--- a/crates/ui-egui/src/viewport.rs+++ b/crates/ui-egui/src/viewport.rs@@ -920,6 +920,9 @@ struct BodyDraw {/// The render class of each face (opaque, glass or faded).face_classes: Vec<crate::gpu::TriClass>,faded: bool,+ /// The body encloses a volume: only closed bodies take part in a section's crossing count+ /// ([`crate::gpu::BlockBytes::closed`]).+ closed: bool,/// 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,@@ -936,7 +939,7 @@ impl BodyDraw {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.faded, self.on_gpu, shaded, edges, hidden_edges, self.slot_base, self.edge.0, self.hidden_edge.0).hash(&mut h);+ (self.faded, self.closed, self.on_gpu, shaded, edges, hidden_edges, self.slot_base, self.edge.0, self.hidden_edge.0).hash(&mut h);h.finish()}@@ -949,6 +952,7 @@ impl BodyDraw {}m.tri_face.get(ti).and_then(|f| self.face_classes.get(*f as usize)).copied().unwrap_or(crate::gpu::TriClass::Opaque)};+ out.open_body(!self.closed);if shaded && !self.on_gpu {let corner = |k: u32| {let i = k as usize;@@ -1055,6 +1059,7 @@ fn build_block(draws: &[BodyDraw], shaded: bool, build: &impl Fn(&BodyDraw, &mutfn reindex_block(block: CachedBlock, draws: &[BodyDraw]) -> CachedBlock {use crate::gpu::TriClass;let mut runs: [Vec<std::ops::Range<u32>>; 3] = Default::default();+ let mut closed = Vec::new();for (range, d) in block.ranges.iter().zip(draws) {// The triangles this body wrote (none when its faces are drawn from a plan or as an// instance), never more than its mesh has.@@ -1070,6 +1075,9 @@ fn reindex_block(block: CachedBlock, draws: &[BodyDraw]) -> CachedBlock {if let Some(list) = runs.get_mut(slot) {crate::gpu::extend_runs(list, at);}+ if class == TriClass::Opaque && d.closed {+ crate::gpu::extend_runs(&mut closed, at);+ }}}let [opaque, glass, faded] = runs;@@ -1088,6 +1096,7 @@ fn reindex_block(block: CachedBlock, draws: &[BodyDraw]) -> CachedBlock {let bytes = std::sync::Arc::new(crate::gpu::BlockBytes {vertices: old.vertices.clone(),opaque: std::sync::Arc::new(opaque),+ closed: std::sync::Arc::new(closed),glass: std::sync::Arc::new(glass),faded: std::sync::Arc::new(faded),lines: old.lines.clone(),@@ -1156,7 +1165,10 @@ impl Instances {self.lods.levels(&mesh).map(|l| l.as_ref().clone()).unwrap_or_default(),),};- self.meshes.push((mesh.clone(), crate::gpu::InstancedMesh { key: key as u64, tris, instances: Vec::new(), look, levels }));+ self.meshes.push((+ mesh.clone(),+ crate::gpu::InstancedMesh { key: key as u64, tris, instances: Vec::new(), look, levels, closed: b.is_closed() },+ ));self.by_mesh.insert((key, look), self.meshes.len() - 1);self.meshes.len() - 1}@@ -1303,11 +1315,12 @@ pub(crate) fn build_scene(app: &SolveApp) -> GpuScene {face_colors.push(slot);face_classes.push(class);}+ let closed = b.is_closed();let class = plan_class(app, &face_classes);let planned = class.and_then(|class| drawn_plan(app, b, true).map(|plan| (plan, class)));let on_gpu = planned.is_some();if let Some((plan, class)) = planned {- sc.planned.push(crate::gpu::PlannedBody { plan, face_colors: face_colors.clone(), class });+ sc.planned.push(crate::gpu::PlannedBody { plan, face_colors: face_colors.clone(), class, closed });}// Opaque, faded and see-through bodies alike, in one colour (faces of their own colour// are built as before).@@ -1335,6 +1348,7 @@ pub(crate) fn build_scene(app: &SolveApp) -> GpuScene {body_color: slots.body,face_classes,faded,+ closed,on_gpu: true,slot_base: slots.faces,edge: slots.edge,@@ -1348,6 +1362,7 @@ pub(crate) fn build_scene(app: &SolveApp) -> GpuScene {body_color: slots.body,face_classes,faded,+ closed,on_gpu,slot_base: slots.faces,edge: slots.edge,@@ -3127,6 +3142,7 @@ impl HighlightInstances {instances: Vec::new(),look: crate::gpu::InstanceLook::Opaque,levels: Vec::new(),+ closed: true,});self.by_mesh.insert(key, self.meshes.len() - 1);self.meshes.len() - 1