SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Section caps: a body touching another along a curved face keeps its own cap (#9407) (#9665)
PaddleStroke2cf8df2ef6a2
diff --git a/assets/shaders/viewport.wgsl b/assets/shaders/viewport.wgslindex 09c91816a6..4715d9edfd 100644--- a/assets/shaders/viewport.wgsl+++ b/assets/shaders/viewport.wgsl@@ -243,6 +243,44 @@ fn pushed(z: f32) -> f32 {return clamp(z - select(-push, push, reversed()), 0.0, 1.0);}+/// A far wall seen through the cut where another body's face lying on it was drawn in front of+/// it (a shaft in its bore, #9407): its cap colour again, at its depth pulled toward the eye by+/// `touch_depth`, so it wins over that face, which is faceted another way.+@fragment+fn fs_solid_touch(i: TOut, @builtin(front_facing) front: bool) -> CutOut {+ var o: CutOut;+ // Derivatives (in `touch_depth`) first, before `solid` may discard.+ o.depth = touch_depth(i.wp, i.pos.z);+ o.c = solid(i, front);+ return o;+}++@fragment+fn fs_solid_touch_flat(i: FOut, @builtin(front_facing) front: bool) -> CutOut {+ let t = flat_fragment(i, front);+ var o: CutOut;+ o.depth = touch_depth(t.wp, t.pos.z);+ o.c = solid(t, front);+ return o;+}++/// The depth of `wp` (depth `z`) pulled toward the eye by what may part two faceted copies of+/// one surface: 3 pixels' width along the view ray (display refinement keeps a facet's sag about+/// a pixel) and 2 pixels of the face's own depth slope (more where it turns from the eye).+fn touch_depth(wp: vec3<f32>, z: f32) -> f32 {+ let px = min(length(dpdx(wp)), length(dpdy(wp)));+ let slope = max(abs(dpdx(z)), abs(dpdy(z)));+ var dir = -u.back.xyz;+ if (u.eye.w > 0.5) { dir = wp - u.eye.xyz; }+ let len = length(dir);+ if (len < 1e-12) { return z; }+ let c = u.vp * vec4<f32>(wp - dir * (3.0 * px / len), 1.0);+ if (c.w <= 0.0) { return z; }+ let pulled = c.z / c.w;+ if (reversed()) { return clamp(max(pulled, z) + 2.0 * slope, 0.0, 1.0); }+ return clamp(min(pulled, z) - 2.0 * slope, 0.0, 1.0);+}+/// Depth of the section plane on the view ray through `wp` (a far wall seen through the cut),/// never behind the wall itself (`z`).fn cap_depth(wp: vec3<f32>, z: f32) -> f32 {diff --git a/crates/gpu/src/view.rs b/crates/gpu/src/view.rsindex fa1024c05b..e005349788 100644--- a/crates/gpu/src/view.rs+++ b/crates/gpu/src/view.rs@@ -169,7 +169,7 @@ pub struct PlannedBody {/// What the viewport's last frame drew, counted as it was drawn (the performance overlay, #2548)./// Triangles and line segments count every pass that draws them, so a section's stencil passes-/// count twice; that is the work the GPU did.+/// count once each; that is the work the GPU did.#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]pub struct DrawStats {pub draw_calls: u32,@@ -1939,12 +1939,21 @@ impl Batches {}}-/// The section's pipelines (see `Renderer::tri_cut`).+/// The section's pipelines (see `Renderer::tri_cut`). The stencil's low bits ([`WINDING`]) count+/// the faces behind the cut on each pixel, its high bit ([`NOT_CAP`]) marks where no cap shows.struct Cut {- /// Draws the faces and marks the stencil by their true depth: 1 where a back face (the cap)+ /// No colour or depth: counts the faces behind the cut, +1 per back face and -1 per front+ /// face, so the count is not 0 where the cut runs through a body, whatever the faces' order.+ wind: wgpu::RenderPipeline,+ /// Draws the faces and marks the stencil by their true depth: [`NOT_CAP`] where a front face/// 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,+ /// Where the cut runs through a body but a front face won the marking: the back faces again,+ /// pulled toward the eye (`fs_solid_touch`), and marked as the cap where one wins. That front+ /// face is another body's lying on the far wall (a shaft in its bore), faceted another way,+ /// which won in streaks (#9407).+ touch: 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,@@ -1953,6 +1962,11 @@ struct Cut {cap: wgpu::RenderPipeline,}+/// The stencil bits of [`Cut::wind`]'s count (kept modulo 128).+const WINDING: u32 = 0x7f;+/// The stencil bit [`Cut::mark`] sets where a front face is the visible surface (no cap there).+const NOT_CAP: u32 = 0x80;+/// The viewport's pipelines and the scenes uploaded to one device, for one kind of target.pub struct Renderer {/// What the last frame drew ([`Renderer::stats`]).@@ -2086,6 +2100,9 @@ pub struct Renderer {/// 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 to 0 before the section's passes count faces in it ([`Cut::wind`]);+ /// depth and colour untouched.+ section_clear: Option<wgpu::RenderPipeline>,/// The new resolve textures [`clear_resolve_targets`] has cleared (tests count them).#[cfg(test)]resolve_clears: u32,@@ -2664,31 +2681,54 @@ impl Renderer {// While a section is shown, the depth states of the stencil marking and of the cap (see// `Renderer::tri_cut`), where the depth buffer has a stencil.let cut_states = 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};+ use wgpu::StencilOperation::{DecrementWrap, IncrementWrap, Keep, Replace, Zero};let face = |pass_op| wgpu::StencilFaceState { compare: wgpu::CompareFunction::Always, fail_op: Keep, depth_fail_op: Keep, pass_op };+ // First the faces behind the cut are counted, back +1 and front -1, whatever their depth.+ let wind = wgpu::DepthStencilState {+ format,+ depth_write_enabled: Some(false),+ depth_compare: Some(wgpu::CompareFunction::Always),+ stencil: wgpu::StencilState { front: face(DecrementWrap), back: face(IncrementWrap), read_mask: 0xff, write_mask: WINDING },+ bias: Default::default(),+ };+ // The visible surface, by its true depth, marks the stencil: `NOT_CAP` where it is a+ // front face (the reference), cleared where it is a back face (the cap).let mark = 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 },+ stencil: wgpu::StencilState { front: face(Replace), back: face(Zero), read_mask: 0xff, write_mask: NOT_CAP },bias: Default::default(),};- // Then the cap's back faces again, only there, at the section plane's depth.+ // Where a front face won but the count says the cut runs through a body (`NOT_CAP` set+ // and a count: above the reference `NOT_CAP`), a back face pulled in front of it is the+ // cap after all.+ let through = wgpu::StencilFaceState { compare: wgpu::CompareFunction::Less, ..face(Zero) };+ let touch = wgpu::DepthStencilState {+ format,+ depth_write_enabled: Some(true),+ depth_compare: Some(depth_compare(reversed, wgpu::CompareFunction::LessEqual)),+ stencil: wgpu::StencilState { front: through, back: through, read_mask: 0xff, write_mask: NOT_CAP },+ bias: Default::default(),+ };+ // Then the cap's back faces again, only there (`NOT_CAP` clear, the reference 0), at the+ // section plane's depth.let only = wgpu::StencilFaceState { compare: wgpu::CompareFunction::Equal, ..face(Keep) };let cap = wgpu::DepthStencilState {format,depth_write_enabled: Some(true),depth_compare: Some(wgpu::CompareFunction::Always),- stencil: wgpu::StencilState { front: only, back: only, read_mask: 0xff, write_mask: 0 },+ stencil: wgpu::StencilState { front: only, back: only, read_mask: NOT_CAP, write_mask: 0 },bias: Default::default(),};- (mark, cap)+ (wind, mark, touch, cap)});- // `Cut::mark` and `Cut::push` use `tri`'s fragment shader; `Cut::cap` has its own.+ // `Cut::wind`, `Cut::mark` and `Cut::push` use `tri`'s fragment shader; `Cut::touch` and+ // `Cut::cap` have their own.let marks = |source: TriSource| {- cut_states.as_ref().map(|(mark, _)| {+ cut_states.as_ref().map(|(wind, mark, _, _)| {(+ solid_writes("sc_tris_wind", "fs_solid", None, Some(wind.clone()), source, false),solid("sc_tris_mark", "fs_solid", None, Some(mark.clone()), source),solid_writes("sc_tris_push", "fs_solid", None, pushed(wgpu::CompareFunction::Less, true, FACE_BIAS), source, false),)@@ -2699,10 +2739,16 @@ impl Renderer {// outlines showed through it, #6328). The marking pass already drew the nearest back// face's colour.let cap = |source: TriSource| {- cut_states.as_ref().map(|(_, cap)| solid_writes("sc_tris_cap", "fs_solid_cut", Some(wgpu::Face::Front), Some(cap.clone()), source, false))+ cut_states.as_ref().map(|(_, _, touch, cap)| {+ (+ solid("sc_tris_touch", "fs_solid_touch", Some(wgpu::Face::Front), Some(touch.clone()), source),+ solid_writes("sc_tris_cap", "fs_solid_cut", Some(wgpu::Face::Front), Some(cap.clone()), source, false),+ )+ })};- let cut = |marks: Option<(wgpu::RenderPipeline, wgpu::RenderPipeline)>, cap: Option<wgpu::RenderPipeline>| {- marks.zip(cap).map(|((mark, push), cap)| Cut { mark, push, cap })+ type Marks = (wgpu::RenderPipeline, wgpu::RenderPipeline, wgpu::RenderPipeline);+ let cut = |marks: Option<Marks>, cap: Option<(wgpu::RenderPipeline, wgpu::RenderPipeline)>| {+ marks.zip(cap).map(|((wind, mark, push), (touch, cap))| Cut { wind, mark, touch, push, cap })};let access_bind = access_texture(device, None, &access_bgl, 1, &[]);let sampler = device.create_sampler(&wgpu::SamplerDescriptor {@@ -2777,6 +2823,7 @@ impl Renderer {(window.reversed_depth().then(|| depth_reset_pipeline(device, window)).flatten(),t.depth.filter(|f| f.has_stencil_aspect()).and_then(|_| depth_reset_pipeline(device, t)),+ t.depth.filter(|f| f.has_stencil_aspect()).and_then(|_| stencil_clear_pipeline(device, t)),)};let opaque = || pushed(wgpu::CompareFunction::Less, true, FACE_BIAS);@@ -2881,12 +2928,13 @@ impl Renderer {let (line, line_hidden) = lines.join();let (overlay, guide_line) = lines_all.join();let (ss_blit, copy_blit, ss_filter) = blits.join();- let (depth_reset, section_reset) = resets.join();+ let (depth_reset, section_reset, section_clear) = resets.join();let oit = oit.join();Renderer {ao: ao.join(),depth_reset,section_reset,+ section_clear,#[cfg(test)]resolve_clears: 0,target: GpuTarget { oit: oit.is_some(), ..t },@@ -3008,24 +3056,47 @@ const GHOST_BIAS: wgpu::DepthBiasState = wgpu::DepthBiasState { constant: 2 * FA/// A pipeline that sets the depth of the viewport in a pass of `t`'s kind back to the far plane,/// leaving colour and stencil as they are. None without a depth buffer.fn depth_reset_pipeline(device: &wgpu::Device, t: GpuTarget) -> Option<wgpu::RenderPipeline> {+ viewport_fill_pipeline(device, t, "sc_depth_reset", true, Default::default())+}++/// A pipeline that sets the stencil of the viewport in a pass of `t`'s kind to 0, leaving colour+/// and depth as they are. None without a depth buffer.+fn stencil_clear_pipeline(device: &wgpu::Device, t: GpuTarget) -> Option<wgpu::RenderPipeline> {+ let zero = wgpu::StencilFaceState {+ compare: wgpu::CompareFunction::Always,+ fail_op: wgpu::StencilOperation::Keep,+ depth_fail_op: wgpu::StencilOperation::Keep,+ pass_op: wgpu::StencilOperation::Zero,+ };+ viewport_fill_pipeline(device, t, "sc_stencil_clear", false, wgpu::StencilState { front: zero, back: zero, read_mask: 0xff, write_mask: 0xff })+}++/// A triangle over the whole viewport in a pass of `t`'s kind, writing no colour: the far plane's+/// depth where `depth`, and `stencil`'s operations.+fn viewport_fill_pipeline(+ device: &wgpu::Device,+ t: GpuTarget,+ label: &str,+ depth: bool,+ stencil: wgpu::StencilState,+) -> Option<wgpu::RenderPipeline> {let format = t.depth?;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 });+ let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { label: Some(label), bind_group_layouts: &[], immediate_size: 0 });Some(device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {- label: Some("sc_depth_reset"),+ 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_write_enabled: Some(depth),depth_compare: Some(wgpu::CompareFunction::Always),- stencil: Default::default(),+ stencil,bias: Default::default(),}),multisample: wgpu::MultisampleState { count: t.samples.max(1), mask: !0, alpha_to_coverage_enabled: false },@@ -3594,9 +3665,9 @@ 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_reset.as_ref().zip(res.section_clear.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((reset, clear))) => {// 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| {@@ -3608,12 +3679,20 @@ impl Renderer {pass.set_bind_group(0, scene_bind(pv, &res.bind), &[]);tris(pass, pick(cut), &pv.tris);};- pass.set_stencil_reference(1);+ // The stencil starts at 0 (the window's pass keeps it from frame to frame), counts+ // the faces behind the cut, then marks where no cap shows (`Cut`).+ pass.set_pipeline(clear);+ pass.draw(0..3, 0..1);+ tally.call();+ all(pass, |c| &c.wind);+ pass.set_stencil_reference(NOT_CAP);all(pass, |c| &c.mark);+ all(pass, |c| &c.touch);pass.set_pipeline(reset);pass.draw(0..3, 0..1);tally.call();all(pass, |c| &c.push);+ pass.set_stencil_reference(0);all(pass, |c| &c.cap);}_ => {diff --git a/crates/gpu/tests/depth.rs b/crates/gpu/tests/depth.rsindex 255536fb4a..9c1948e863 100644--- a/crates/gpu/tests/depth.rs+++ b/crates/gpu/tests/depth.rs@@ -471,3 +471,68 @@ fn a_cut_hides_the_edges_behind_it() {}}}++/// #9407: a shaft in a bore it fits exactly, cut along its axis. Seen through the hub's cut, the+/// bore's wall (a back face: the hub's cap) and the shaft's side (a front face) are the same+/// cylinder, each faceted its own way, so neither is always in front: the shaft's side showed+/// through the hub's cap in streaks along the axis, changing as the view turned. The hub's cap is+/// the same as without the shaft, from several directions, in orthographic and perspective.+#[test]+fn a_shaft_in_its_bore_leaves_the_hubs_cap_whole() {+ let hub = [+ ("solid.cylinder", json!({"radius": 20, "height": 40, "body_name": "Hub"})),+ ("solid.cylinder", json!({"radius": 8, "height": 40, "operation": "cut"})),+ ];+ let shaft = ("solid.cylinder", json!({"radius": 8, "height": 60, "base": [0, 0, -10], "body_name": "Shaft", "operation": "new"}));+ let cut = ("inspect.section", json!({"plane": {"origin": [0, 0, 0], "normal": [0, -1, 0]}}));+ let alone = session(&[&hub[..], std::slice::from_ref(&cut)].concat());+ let fitted = session(&[&hub[..], &[shaft, cut]].concat());+ let (w, h) = (480, 400);+ for (mode, c) in capturers() {+ for fov in [0.0, 0.6] {+ let mut shown = Vec::new();+ for i in 0..6 {+ let mut cam = view::home_camera(&fitted);+ (cam.fov, cam.yaw, cam.pitch) = (fov, -1.1 + 0.3 * f64::from(i), 0.3);+ let with = view::scene(&fitted, &cam);+ let radius = with.radius;+ // The hub alone, framed as the design with the shaft.+ let without = Scene { radius, ..view::scene(&alone, &cam) };+ let shot = |sc: Scene| c.rgba(&Scene { grid: Vec::new(), ..sc }, &cam, w, h).unwrap();+ let (a, b) = (shot(without), shot(with));+ // The hub's cut on screen: a rectangle each side of the bore, its outline left out.+ let rects: Vec<Vec<(f64, f64)>> = [(8.0, 20.0), (-20.0, -8.0)]+ .iter()+ .map(|(x0, x1)| {+ [(*x0, 0.0), (*x1, 0.0), (*x1, 40.0), (*x0, 40.0)]+ .iter()+ .filter_map(|(x, z)| cam.to_screen(Vec3::new(*x, 0.0, *z), f64::from(w), f64::from(h), radius).map(|(x, y, _)| (x, y)))+ .collect()+ })+ .collect();+ let inside = |x: f64, y: f64| {+ rects.iter().any(|q| {+ q.len() == 4 && {+ let turn = (0..4).map(|i| q[i].0 * q[(i + 1) % 4].1 - q[(i + 1) % 4].0 * q[i].1).sum::<f64>().signum();+ (0..4).all(|i| {+ let ((ax, ay), (bx, by)) = (q[i], q[(i + 1) % 4]);+ ((bx - ax) * (y - ay) - (by - ay) * (x - ax)) / (bx - ax).hypot(by - ay) * turn >= 2.0+ })+ }+ })+ };+ let (mut differ, 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;+ differ += usize::from(p.iter().zip(q).any(|(u, v)| u.abs_diff(v) > 24));+ }+ }+ assert!(all > 3000, "{mode}, fov {fov}, view {i}: the hub's cap ({all} px)");+ shown.push(differ);+ }+ let total: usize = shown.iter().sum();+ assert!(total <= 12, "{mode} depth, fov {fov}: the shaft shows through the hub's cap, px per view {shown:?}");+ }+ }+}