SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Wave 303/509: Section hatch by part: touching cut parts never look alike (and 1 more)
jyviko40426d19bde4
diff --git a/assets/locales/pending/section-hatch-by-part.json b/assets/locales/pending/section-hatch-by-part.jsonnew file mode 100644index 0000000000..85c32ee634--- /dev/null+++ b/assets/locales/pending/section-hatch-by-part.json@@ -0,0 +1,17 @@+{+ "en": {+ "prefs.section_hatch": "Section hatch",+ "prefs.section_hatch_by_part": "By part",+ "prefs.section_hatch_one": "One style"+ },+ "ja": {+ "prefs.section_hatch": "断面ハッチング",+ "prefs.section_hatch_by_part": "部品ごと",+ "prefs.section_hatch_one": "単一スタイル"+ },+ "zh": {+ "prefs.section_hatch": "剖面线",+ "prefs.section_hatch_by_part": "按零件",+ "prefs.section_hatch_one": "单一样式"+ }+}diff --git a/assets/shaders/viewport.wgsl b/assets/shaders/viewport.wgslindex 8960cf20f2..6eb301683d 100644--- a/assets/shaders/viewport.wgsl+++ b/assets/shaders/viewport.wgsl@@ -18,6 +18,8 @@ struct U {depth: 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 lightingsel: vec4<f32>, // xyz a whole selected body's colour before lighting+ // the section hatch colours by part (`solidcraft_render::hatch`), the first the cap's own+ hatch: array<vec4<f32>, 3>,};fn reversed() -> bool {@@ -37,16 +39,25 @@ fn clipped(p: vec3<f32>) -> bool {return length(u.clip.xyz) > 0.5 && dot(u.clip.xyz, p) > u.clip.w;}@group(0) @binding(0) var<uniform> u: U;-// The scene's colours, 2048 entries to a row: an R32Uint texture rather than a storage buffer,-// so the viewport draws on WebGL2 (which has no storage buffers) as well.+// The scene's colours, 2048 entries to a row: an Rg32Uint texture rather than a storage buffer,+// so the viewport draws on WebGL2 (which has no storage buffers) as well. Each entry is the+// colour's bytes, then 1 + the section hatch of the body it colours (0: the cap's own).@group(0) @binding(1) var pal: texture_2d<u32>;-/// The colour at palette entry `i`, as byte/255 (the old Unorm8x4 conversion, bit for bit).-fn palette(i: u32) -> vec4<f32> {- let v = textureLoad(pal, vec2<i32>(i32(i & 2047u), i32(i >> 11u)), 0).x;+fn palette_entry(i: u32) -> vec2<u32> {+ return textureLoad(pal, vec2<i32>(i32(i & 2047u), i32(i >> 11u)), 0).xy;+}++/// A palette entry's colour bytes as byte/255 (the old Unorm8x4 conversion, bit for bit).+fn unpack_color(v: u32) -> vec4<f32> {return vec4<f32>(f32(v & 255u), f32((v >> 8u) & 255u), f32((v >> 16u) & 255u), f32((v >> 24u) & 255u)) / 255.0;}+/// The colour at palette entry `i`.+fn palette(i: u32) -> vec4<f32> {+ return unpack_color(palette_entry(i).x);+}+fn to_linear(c: vec3<f32>) -> vec3<f32> {return select(c, pow((c + vec3<f32>(0.055)) / vec3<f32>(1.055), vec3<f32>(2.4)), c > vec3<f32>(0.04045));}@@ -63,6 +74,8 @@ struct TOut {@location(0) n: vec3<f32>,@location(1) c: vec4<f32>,@location(2) wp: vec3<f32>,+ // 1 + the section hatch of the body (0: the cap's own), from the palette.+ @location(3) @interpolate(flat) h: u32,};@vertex@@ -70,7 +83,9 @@ fn vs_tri(@location(0) p: vec3<f32>, @location(1) n: vec3<f32>, @location(2) c:var o: TOut;o.pos = u.vp * vec4<f32>(p, 1.0);o.n = n;- o.c = palette(c);+ let e = palette_entry(c);+ o.c = unpack_color(e.x);+ o.h = e.y;o.wp = p;return o;}@@ -92,7 +107,9 @@ fn vs_tri_inst(var o: TOut;o.pos = u.vp * vec4<f32>(wp, 1.0);o.n = vec3<f32>(dot(r0.xyz, n), dot(r1.xyz, n), dot(r2.xyz, n));- o.c = palette(c);+ let e = palette_entry(c);+ o.c = unpack_color(e.x);+ o.h = e.y;o.wp = wp;return o;}@@ -107,6 +124,7 @@ struct FOut {@builtin(position) pos: vec4<f32>,@location(0) rp: vec3<f32>,@location(1) c: vec4<f32>,+ @location(2) @interpolate(flat) h: u32,};@vertex@@ -122,7 +140,9 @@ fn vs_tri_inst_flat(var o: FOut;o.pos = u.vp * vec4<f32>(wp, 1.0);o.rp = wp - u.eye.xyz;- o.c = palette(c);+ let e = palette_entry(c);+ o.c = unpack_color(e.x);+ o.h = e.y;return o;}@@ -138,6 +158,7 @@ fn flat_fragment(i: FOut, front: bool) -> TOut {o.pos = i.pos;o.n = n;o.c = i.c;+ o.h = i.h;o.wp = i.rp + u.eye.xyz;return o;}@@ -294,11 +315,19 @@ fn solid(i: TOut, front: bool) -> vec4<f32> {if (clipped(i.wp)) { discard; }if (!front && length(u.clip.xyz) > 0.5) {// The cut face in its body's colour ("from component" colouring), tinted toward the- // cap colour so it reads as a cut, hatched at 45 degrees on screen; with the hatch off+ // cap colour so it reads as a cut, hatched at 45 degrees on screen; by part, toward the+ // body's own hatch colour and at its angle (45 or 135 degrees). With the hatch off// (`u.cap.a` 0), plain in the body's own colour.if (u.cap.a < 0.5) { return out_color(vec4<f32>(i.c.rgb, 1.0)); }- let base = mix(i.c.rgb, u.cap.rgb, 0.35);- let h = fract((i.pos.x + i.pos.y) / 9.0);+ var tint = u.cap.rgb;+ var turn = 1.0;+ if (i.h > 0u) {+ let k = i.h - 1u;+ tint = u.hatch[min(k >> 1u, 2u)].rgb;+ turn = select(1.0, -1.0, (k & 1u) == 1u);+ }+ let base = mix(i.c.rgb, tint, 0.35);+ let h = fract((i.pos.x + turn * i.pos.y) / 9.0);return out_color(vec4<f32>(select(base, base * 0.6, h < 0.22), 1.0));}if (u.ana.x > 0.5 && length(i.n) > 0.5) {diff --git a/assets/styles/ui/palettes.rs b/assets/styles/ui/palettes.rsindex cf1fda870a..b28a3576ec 100644--- a/assets/styles/ui/palettes.rs+++ b/assets/styles/ui/palettes.rs@@ -187,6 +187,11 @@ impl Tokens {dimension_driven: Color32::from_rgb(120, 126, 138),sketch_point_free: Color32::from_rgb(30, 90, 200),section_cap: Color32::from_rgb(214, 128, 72),+ // A steel and a sage that tint a body about as strongly as the cap does and to within+ // a few points of its lightness, so the cut stays calm, while staying apart from the+ // cap, each other and the body in every colour vision mode (dark keeps them, as the+ // cap).+ section_hatch: [Color32::from_rgb(84, 138, 168), Color32::from_rgb(108, 180, 126)],dialog_bg: Color32::from_rgb(250, 251, 252),dialog_border: Color32::from_rgb(213, 219, 227),chip: Color32::from_rgb(38, 120, 218),diff --git a/crates/engine/src/cmd/file_thumbnail.rs b/crates/engine/src/cmd/file_thumbnail.rsindex 8e43ceffa2..c377b1c733 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, closed: body.is_closed() });+ scene.meshes.push(SceneMesh { mesh, color, face_colors, opacity, closed: body.is_closed(), hatch: Default::default() });}if bounds.is_empty() {return None;diff --git a/crates/engine/src/view.rs b/crates/engine/src/view.rsindex eef7ee2511..df07a28ee1 100644--- a/crates/engine/src/view.rs+++ b/crates/engine/src/view.rs@@ -72,6 +72,8 @@ pub struct Palette {pub axes: [Rgb; 3],/// What the section cap is tinted toward.pub cap: Rgb,+ /// The section hatch's other colours, after the cap's (`Scene::part_hatch`).+ pub hatch: [Rgb; 2],/// Isocurve Analysis: the faces' isoparametric curves.pub isocurve: Rgb,/// The surface analysis colours.@@ -97,6 +99,7 @@ impl Palette {sketch_centerline: colors::SKETCH_CENTERLINE,axes: [colors::AXIS_X, colors::AXIS_Y, colors::AXIS_Z],cap: colors::SECTION_CAP,+ hatch: solidcraft_render::SECTION_HATCH,isocurve: colors::ISOCURVE,analysis: AnalysisColors::DEFAULT,};@@ -589,6 +592,7 @@ fn build_scene(clip: section.map(|(o, n)| (n, n.dot(o))),cap: Some(p.cap),plain_cap: !s.section_hatch,+ part_hatch: Some([p.cap, p.hatch[0], p.hatch[1]]),analysis: s.analysis.map(|a| SceneAnalysis { mode: a.mode(), colors: p.analysis }),..Default::default()};@@ -655,6 +659,8 @@ fn build_scene(.flatten().collect();let mut thread_budget = crate::cosmetic_threads::Budget::default();+ // Where the section cuts each closed solid body, by its mesh in `sc.meshes`: their hatches.+ let mut cuts: Vec<(usize, u64, Vec<(Vec3, Vec3)>)> = Vec::new();for body in st.bodies.iter().filter(|b| s.body_visible(&b.name)) {let selected = selected_occurrences.contains(&body.name) || s.selection.iter().any(|x| matches!(x, Sel::Body { name } if *name == body.name));let mesh = body.mesh();@@ -676,7 +682,9 @@ 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, closed: body.is_closed() });+ let cut_solid = section.is_some() && body.is_closed() && opacity >= solidcraft_render::SEE_THROUGH;+ sc.meshes.push(SceneMesh { mesh: Arc::clone(&mesh), color, face_colors, opacity, closed: body.is_closed(), hatch: Default::default() });+ let at = sc.meshes.len() - 1;if cosmetic_threads&& thread_budget.available()&& s.doc.model_body_opacity(body) >= 0.999@@ -694,8 +702,21 @@ fn build_scene(}// The outline of the body where the section cuts it.if let Some((o, n)) = section {- for (a, b) in section_segments(&mesh, o, n) {- sc.lines.push(SceneLine { points: vec![a, b], color: p.edge, alpha: 1.0, width: 1.6, on_top: false });+ let segments = section_segments(&mesh, o, n);+ for (a, b) in &segments {+ sc.lines.push(SceneLine { points: vec![*a, *b], color: p.edge, alpha: 1.0, width: 1.6, on_top: false });+ }+ if cut_solid && !segments.is_empty() {+ cuts.push((at, solidcraft_render::hatch::seed(&body.name), segments));+ }+ }+ }+ if let Some((_, n)) = section {+ let parts: Vec<solidcraft_render::hatch::CutPart> =+ cuts.iter().map(|(_, seed, segments)| solidcraft_render::hatch::CutPart { seed: *seed, segments }).collect();+ for ((at, _, _), hatch) in cuts.iter().zip(solidcraft_render::hatch::hatches(&parts, n)) {+ if let Some(m) = sc.meshes.get_mut(*at) {+ m.hatch = hatch;}}}diff --git a/crates/engine/src/view_palette_tests.rs b/crates/engine/src/view_palette_tests.rsindex 1548e1c095..6f81265b61 100644--- a/crates/engine/src/view_palette_tests.rs+++ b/crates/engine/src/view_palette_tests.rs@@ -93,6 +93,7 @@ const MARK: Palette = Palette {sketch_centerline: Rgb(43, 44, 45),axes: [Rgb(46, 47, 48), Rgb(49, 50, 51), Rgb(52, 53, 54)],cap: Rgb(55, 56, 57),+ hatch: [Rgb(61, 62, 63), Rgb(64, 65, 66)],isocurve: Rgb(58, 59, 60),analysis: solidcraft_render::AnalysisColors {draft: [[0.1, 0.2, 0.3], [0.4, 0.5, 0.6], [0.7, 0.8, 0.9]],diff --git a/crates/gpu/src/capture.rs b/crates/gpu/src/capture.rsindex 8a41c6bc49..90e120ed70 100644--- a/crates/gpu/src/capture.rs+++ b/crates/gpu/src/capture.rs@@ -12,10 +12,11 @@ use std::sync::atomic::{AtomicBool, Ordering};use std::sync::{Arc, Mutex};use solidcraft_geom::Vec3;-use solidcraft_render::{AnalysisMode, Camera, Rgb, SECTION_CAP, Scene};+use solidcraft_render::hatch::Hatch;+use solidcraft_render::{AnalysisMode, Camera, Rgb, SECTION_CAP, Scene, SceneMesh};use wgpu::util::DeviceExt;-use crate::view::{AccessMap, Frame, GpuScene, GpuTarget, Renderer, analysis_colors, analysis_uniform};+use crate::view::{AccessMap, Frame, GpuScene, GpuTarget, Palette, PaletteIndex, Renderer, analysis_colors, analysis_uniform};use crate::{GpuError, Result, popped};/// The colour format pictures are drawn in: sRGB bytes as they are, like the viewport's usual@@ -401,6 +402,7 @@ fn frame(scene: &Scene, cam: &Camera, [width, height]: [u32; 2], key: u64, accesssaa: 1.0,hover_tint: [0.0; 3],selection_tint: [0.0; 3],+ hatch: scene.part_hatch.map_or_else(Default::default, |c| c.map(|Rgb(r, g, b)| [r, g, b].map(|x| f32::from(x) / 255.0))),}}@@ -408,16 +410,44 @@ fn frame(scene: &Scene, cam: &Camera, [width, height]: [u32; 2], key: u64, acces/// normals; a face normal where a vertex has none), lines as wide lines (over everything when/// `on_top`), the grid under everything. A body whose appearance is see-through/// ([`solidcraft_render::SceneMesh::glass`]) goes into the scene's glass, drawn as the viewport-/// draws glass: far sides first, then near sides, so what lies inside it shows through.+/// draws glass: far sides first, then near sides, so what lies inside it shows through. When the+/// scene hatches its cut by part ([`Scene::part_hatch`]), each body's colours are palette entries+/// of its own, carrying its hatch.pub fn scene_geometry(scene: &Scene) -> GpuScene {- let mut sc = GpuScene::default();- for m in &scene.meshes {- let alpha = (m.alpha() * 255.0).round().clamp(0.0, 255.0) as u8;- let c4 = |c: Rgb| [c.0, c.1, c.2, alpha];+ let by_part = scene.part_hatch.is_some() && scene.clip.is_some();+ // Per body, its colours' stable entries (by part), and the stable palette they make.+ let mut own: Vec<HashMap<[u8; 4], PaletteIndex>> = Vec::new();+ let mut stable: Vec<[u8; 4]> = Vec::new();+ let mut hatches: Vec<(PaletteIndex, Hatch)> = Vec::new();+ let c4 = |m: &SceneMesh, c: Rgb| [c.0, c.1, c.2, (m.alpha() * 255.0).round().clamp(0.0, 255.0) as u8];+ if by_part {+ for m in &scene.meshes {+ let mut map = HashMap::new();+ for c in std::iter::once(m.color).chain(m.face_colors.iter().map(|(_, c)| *c)) {+ map.entry(c4(m, c)).or_insert_with(|| {+ let i = PaletteIndex(u32::try_from(stable.len()).unwrap_or(0));+ stable.push(c4(m, c));+ hatches.push((i, m.hatch));+ i+ });+ }+ own.push(map);+ }+ }+ let mut palette = Palette::with_stable(stable);+ for (i, h) in hatches {+ palette.set_hatch(i, h);+ }+ let mut sc = GpuScene::with_palette(palette);+ for (mi, m) in scene.meshes.iter().enumerate() {let faces: HashMap<u32, Rgb> = m.face_colors.iter().copied().collect();let mesh = &m.mesh;for (ti, t) in mesh.triangles.iter().enumerate() {- let col = sc.color(c4(mesh.tri_face.get(ti).and_then(|f| faces.get(f)).copied().unwrap_or(m.color)));+ let rgba = c4(m, mesh.tri_face.get(ti).and_then(|f| faces.get(f)).copied().unwrap_or(m.color));+ let col = match own.get(mi).and_then(|o| o.get(&rgba)) {+ Some(i) => *i,+ None => sc.color(rgba),+ };let [Some(a), Some(b), Some(c)] = t.map(|k| mesh.positions.get(k as usize).copied()) else { continue };let flat = (b - a).cross(c - a).normalized().unwrap_or(Vec3::Z);for (k, p) in t.iter().zip([a, b, c]) {@@ -557,7 +587,6 @@ mod tests {use super::*;use crate::view::TRI_SIZE;use solidcraft_geom::Mesh;- use solidcraft_render::SceneMesh;use std::sync::Arc;/// One triangle facing the camera.@@ -582,7 +611,14 @@ 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, closed: true };+ let mesh = |opacity: f32| SceneMesh {+ mesh: sheet(),+ color: Rgb(200, 30, 30),+ face_colors: Vec::new(),+ opacity,+ closed: true,+ hatch: Default::default(),+ };let geometry = |opacity: f32| scene_geometry(&Scene { meshes: vec![mesh(opacity)], ..Default::default() });let solid = geometry(1.0);@@ -606,7 +642,14 @@ 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, closed: true };+ let mesh = SceneMesh {+ mesh: sheet(),+ color: Rgb(200, 30, 30),+ face_colors: vec![(0, Rgb(0, 255, 0))],+ opacity: 0.5,+ closed: true,+ hatch: Default::default(),+ };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 7cec789f88..c518cc6dd5 100644--- a/crates/gpu/src/view.rs+++ b/crates/gpu/src/view.rs@@ -41,7 +41,7 @@ pub struct PaletteIndex(pub u32);/// How many palette entries fit on one texel row: the shader reads `x = i & 2047`,/// `y = i >> 11`. A power of two keeps the lookup a shift and a mask.pub const PALETTE_WIDTH: u32 = 2048;-/// Most palette entries a scene may carry (2048 × 512): the palette is an `R32Uint` texture+/// Most palette entries a scene may carry (2048 × 512): the palette is an `Rg32Uint` texture/// (`downlevel_defaults`/WebGL2 have no storage buffers in the vertex stage).pub const MAX_PALETTE: usize = 1 << 20;@@ -50,17 +50,22 @@ pub const MAX_PALETTE: usize = 1 << 20;/// The first [`Palette::stable_len`] entries are stable for a scene: cached block bytes keep/// referring to them, so appearance edits only change their values. Entries after that are/// interned per build for ephemeral geometry (grids, highlights, sketch, previews).+///+/// A stable entry also carries the section hatch of the body it colours+/// (`solidcraft_render::hatch`): none, the cap's own hatch, unless the scene hatches by part.#[derive(Clone, Debug, Default)]pub struct Palette {entries: Vec<[u8; 4]>,lookup: std::collections::HashMap<[u8; 4], u32>,stable_len: usize,+ /// Per entry, 1 + its body's hatch, or 0 for the cap's own (empty: 0 for every entry).+ hatches: Vec<u8>,}impl Palette {/// A palette whose entries are all stable (the model scene's body/face slots).pub fn with_stable(entries: Vec<[u8; 4]>) -> Palette {- Palette { stable_len: entries.len(), entries, lookup: std::collections::HashMap::new() }+ Palette { stable_len: entries.len(), entries, lookup: std::collections::HashMap::new(), hatches: Vec::new() }}/// Where the stable entries end and the per-build interned ones begin.@@ -116,9 +121,35 @@ impl Palette {PaletteIndex(i)}- /// The palette as the shader's `R32Uint` texels (rgba bytes packed little-endian).- pub fn texels(&self) -> Vec<u32> {- self.entries.iter().map(|[r, g, b, a]| u32::from_le_bytes([*r, *g, *b, *a])).collect()+ /// Give stable entry `i` (a body's colour) that body's section hatch; `false` when `i` is not+ /// a stable entry.+ pub fn set_hatch(&mut self, i: PaletteIndex, hatch: solidcraft_render::hatch::Hatch) -> bool {+ let at = i.0 as usize;+ if at >= self.stable_len {+ return false;+ }+ if self.hatches.len() < self.stable_len {+ self.hatches.resize(self.stable_len, 0);+ }+ match self.hatches.get_mut(at) {+ Some(slot) => {+ *slot = hatch.0.saturating_add(1);+ true+ }+ None => false,+ }+ }++ /// The section hatch entry `i` was given ([`Palette::set_hatch`]), if any.+ pub fn hatch(&self, i: PaletteIndex) -> Option<solidcraft_render::hatch::Hatch> {+ self.hatches.get(i.0 as usize).and_then(|h| h.checked_sub(1)).map(solidcraft_render::hatch::Hatch)+ }++ /// Entry `i` as the shader's `Rg32Uint` texel: the rgba bytes packed little-endian, then+ /// 1 + its hatch (0: the cap's own).+ fn texel(&self, i: usize) -> [u32; 2] {+ let colour = self.entries.get(i).map_or(0, |[r, g, b, a]| u32::from_le_bytes([*r, *g, *b, *a]));+ [colour, u32::from(self.hatches.get(i).copied().unwrap_or(0))]}}@@ -151,8 +182,8 @@ fn octahedral6(n: [f32; 3]) -> u32 {}/// The shader's `U`: the view-projection matrix, 10 `vec4`s (the tenth carries the ambient/// 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;+/// whole-body highlight colours, then the section hatch colours (`uniform_bytes`).+const UNIFORM_SIZE: u64 = 416 + 16 * solidcraft_render::hatch::HATCH_COLOURS as u64;/// A body drawn from its display plan, evaluated on the GPU: the plan, and a palette index per/// face (the plan's face numbering; faces past the end take the last index).@@ -914,6 +945,9 @@ pub struct Frame {pub hover_tint: [f32; 3],/// Whole-body selection highlight: a selected body's colour before lighting (sRGB 0..1).pub selection_tint: [f32; 3],+ /// The section hatch colours by part (straight sRGB, 0..1; the first the cap's own): what a+ /// cut body whose palette entries carry a hatch ([`Palette::set_hatch`]) is tinted toward.+ pub hatch: [[f32; 3]; solidcraft_render::hatch::HATCH_COLOURS],}/// Heights of the model seen from a direction (an orthographic depth map): a point is reachable@@ -1393,16 +1427,19 @@ fn joined<'a>(blocks: impl Iterator<Item = &'a Option<Batch>>, own: Option<Batch(!parts.is_empty()).then_some(Batch { parts, chunk })}-/// A scene's palette on the GPU: an `R32Uint` texture, [`PALETTE_WIDTH`] entries to a row.+/// A scene's palette on the GPU: an `Rg32Uint` texture (colour, hatch), [`PALETTE_WIDTH`]+/// entries to a row.struct PaletteGpu {palette: Arc<Palette>,/// Held for the bind group, which views it._texture: wgpu::Texture,bind: wgpu::BindGroup,rows: u32,- entries: Vec<[u8; 4]>,}+/// Bytes of one palette texel.+const PALETTE_TEXEL: u32 = 8;+fn palette_texture(device: &wgpu::Device, rows: u32) -> wgpu::Texture {device.create_texture(&wgpu::TextureDescriptor {label: Some("sc_palette"),@@ -1410,28 +1447,28 @@ fn palette_texture(device: &wgpu::Device, rows: u32) -> wgpu::Texture {mip_level_count: 1,sample_count: 1,dimension: wgpu::TextureDimension::D2,- format: wgpu::TextureFormat::R32Uint,+ format: wgpu::TextureFormat::Rg32Uint,usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,view_formats: &[],})}-/// Rows `first..last` of `entries` as the texture's texels (zero past the end).-fn palette_bytes(entries: &[[u8; 4]], first: u32, last: u32) -> Vec<u8> {+/// Rows `first..last` of `palette` as the texture's texels (zero past the end).+fn palette_bytes(palette: &Palette, first: u32, last: u32) -> Vec<u8> {let width = PALETTE_WIDTH as usize;- let mut out = Vec::with_capacity((last - first) as usize * width * 4);+ let mut out = Vec::with_capacity((last - first) as usize * width * PALETTE_TEXEL as usize);for row in first..last {for col in 0..PALETTE_WIDTH {- let i = row as usize * width + col as usize;- let texel = entries.get(i).map_or(0, |[r, g, b, a]| u32::from_le_bytes([*r, *g, *b, *a]));- out.extend_from_slice(&texel.to_le_bytes());+ for word in palette.texel(row as usize * width + col as usize) {+ out.extend_from_slice(&word.to_le_bytes());+ }}}out}-fn palette_rows(entries: &[[u8; 4]]) -> u32 {- u32::try_from(entries.len().div_ceil(PALETTE_WIDTH as usize)).unwrap_or(1).max(1)+fn palette_rows(palette: &Palette) -> u32 {+ u32::try_from(palette.len().div_ceil(PALETTE_WIDTH as usize)).unwrap_or(1).max(1)}impl PaletteGpu {@@ -1443,15 +1480,14 @@ impl PaletteGpu {palette: Arc<Palette>,written: &mut u64,) -> PaletteGpu {- let entries = palette.entries().to_vec();- let rows = palette_rows(&entries);+ let rows = palette_rows(&palette);let texture = palette_texture(device, rows);- let bytes = palette_bytes(&entries, 0, rows);+ let bytes = palette_bytes(&palette, 0, rows);*written += bytes.len() as u64;queue.write_texture(wgpu::TexelCopyTextureInfo { texture: &texture, mip_level: 0, origin: wgpu::Origin3d::ZERO, aspect: wgpu::TextureAspect::All },&bytes,- wgpu::TexelCopyBufferLayout { offset: 0, bytes_per_row: Some(PALETTE_WIDTH * 4), rows_per_image: Some(rows) },+ wgpu::TexelCopyBufferLayout { offset: 0, bytes_per_row: Some(PALETTE_WIDTH * PALETTE_TEXEL), rows_per_image: Some(rows) },wgpu::Extent3d { width: PALETTE_WIDTH, height: rows, depth_or_array_layers: 1 },);let view = texture.create_view(&Default::default());@@ -1463,7 +1499,7 @@ impl PaletteGpu {wgpu::BindGroupEntry { binding: 1, resource: wgpu::BindingResource::TextureView(&view) },],});- PaletteGpu { palette, _texture: texture, bind, rows, entries }+ PaletteGpu { palette, _texture: texture, bind, rows }}/// Bring the texture up to `palette`, writing only the rows whose entries changed (or the@@ -1480,8 +1516,7 @@ impl PaletteGpu {if Arc::ptr_eq(&self.palette, &palette) {return;}- let entries = palette.entries().to_vec();- let rows = palette_rows(&entries);+ let rows = palette_rows(&palette);if rows != self.rows {*self = PaletteGpu::new(device, queue, uniform, bgl, palette, written);return;@@ -1489,7 +1524,7 @@ impl PaletteGpu {let width = PALETTE_WIDTH as usize;let same = |row: u32| {let base = row as usize * width;- (0..width).all(|c| self.entries.get(base + c).copied().unwrap_or_default() == entries.get(base + c).copied().unwrap_or_default())+ (0..width).all(|c| self.palette.texel(base + c) == palette.texel(base + c))};let mut row = 0u32;while row < rows {@@ -1501,7 +1536,7 @@ impl PaletteGpu {while row < rows && !same(row) {row += 1;}- let bytes = palette_bytes(&entries, first, row);+ let bytes = palette_bytes(&palette, first, row);*written += bytes.len() as u64;queue.write_texture(wgpu::TexelCopyTextureInfo {@@ -1511,11 +1546,10 @@ impl PaletteGpu {aspect: wgpu::TextureAspect::All,},&bytes,- wgpu::TexelCopyBufferLayout { offset: 0, bytes_per_row: Some(PALETTE_WIDTH * 4), rows_per_image: Some(row - first) },+ wgpu::TexelCopyBufferLayout { offset: 0, bytes_per_row: Some(PALETTE_WIDTH * PALETTE_TEXEL), rows_per_image: Some(row - first) },wgpu::Extent3d { width: PALETTE_WIDTH, height: row - first, depth_or_array_layers: 1 },);}- self.entries = entries;self.palette = palette;}}@@ -2942,6 +2976,7 @@ fn frame_key(cb: &Frame) -> u64 {// picture cached under the previous theme's colours is not shown (#5802).cb.hover_tint.map(f32::to_bits).hash(&mut h);cb.selection_tint.map(f32::to_bits).hash(&mut h);+ cb.hatch.iter().flatten().for_each(|v| v.to_bits().hash(&mut h));cb.outline.hash(&mut h);cb.ao_radius.to_bits().hash(&mut h);cb.ssaa.to_bits().hash(&mut h);@@ -3656,6 +3691,9 @@ pub fn uniform_bytes(cb: &Frame, w: f32, h: f32, linear: bool, reversed: bool) -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]);+ for [r, g, b] in cb.hatch {+ v.extend([r, g, b, 1.0]);+ }v.iter().flat_map(|x| x.to_le_bytes()).collect()}@@ -3820,6 +3858,7 @@ mod tests {access: None,hover_tint: [0.0; 3],selection_tint: [0.0; 3],+ hatch: Default::default(),outline: false,eye: [0.0; 4],ao_radius: 0.0,@@ -4106,6 +4145,7 @@ mod glass_tests {ssaa: 1.0,hover_tint: [0.0; 3],selection_tint: [0.0; 3],+ hatch: Default::default(),};let texture = |format, usage, sample_count| {device.create_texture(&wgpu::TextureDescriptor {@@ -4273,6 +4313,7 @@ mod glass_tests {access: None,hover_tint: [0.0; 3],selection_tint: [0.0; 3],+ hatch: Default::default(),outline: false,eye: [0.0, 0.0, 100.0, 0.0],ao_radius: 0.0,diff --git a/crates/gpu/src/view/msaa_check.rs b/crates/gpu/src/view/msaa_check.rsindex 591c3581d8..29869b29a4 100644--- a/crates/gpu/src/view/msaa_check.rs+++ b/crates/gpu/src/view/msaa_check.rs@@ -116,6 +116,7 @@ impl Renderer {ssaa: 1.0,hover_tint: [0.0; 3],selection_tint: [0.0; 3],+ hatch: Default::default(),};let size = wgpu::Extent3d { width: SIZE, height: SIZE, depth_or_array_layers: 1 };let color = device.create_texture(&wgpu::TextureDescriptor {diff --git a/crates/gpu/tests/depth.rs b/crates/gpu/tests/depth.rsindex a5be94a91e..1d83c4d3f5 100644--- a/crates/gpu/tests/depth.rs+++ b/crates/gpu/tests/depth.rs@@ -502,3 +502,76 @@ fn a_cut_hides_the_edges_behind_it() {}}}++/// The hatch a picture shows over the pixels `at`: the colour most of them have (the fill,+/// rounded to 8 levels a channel), and whether the darker lines through it run at 135 degrees+/// (down to the right on screen) rather than 45.+fn hatch_seen(img: &[u8], w: u32, at: &[(i64, i64)]) -> ([u8; 3], bool) {+ let px = |x: i64, y: i64| {+ let i = (y * i64::from(w) + x) as usize * 4;+ img.get(i..i + 3).map(|p| [p[0], p[1], p[2]])+ };+ let mut counts = std::collections::HashMap::new();+ for (x, y) in at {+ if let Some(p) = px(*x, *y) {+ *counts.entry(p.map(|c| c / 8)).or_insert(0usize) += 1;+ }+ }+ let fill = counts.into_iter().max_by_key(|(_, n)| *n).map_or([0; 3], |(c, _)| c);+ let line = |x: i64, y: i64| {+ px(x, y).is_some_and(|p| p.iter().map(|c| u32::from(*c)).sum::<u32>() * 8 < fill.iter().map(|c| u32::from(*c) * 8 + 4).sum::<u32>() * 7)+ };+ // Along a 45 degree line (x + y the same) the pixels agree; across it they alternate.+ let agree = |dy: i64| at.iter().filter(|(x, y)| line(*x, *y) && line(x + 1, y + dy)).count();+ (fill, agree(1) > agree(-1))+}++/// Section hatch by part: two blocks side by side, cut through both, touch along the cut, so they+/// get different hatches (in angle or colour) and the picture shows them apart; the next frame+/// and a plane moved a little keep each block's hatch. With one hatch for every body (the+/// preference's old behaviour) both caps are the cap colour at 45 degrees.+#[test]+fn touching_caps_are_hatched_apart_and_keep_their_hatch() {+ let left = ("solid.box", json!({"length": 20, "width": 30, "height": 20, "body_name": "left"}));+ let right = ("solid.box", json!({"length": 20, "width": 30, "height": 20, "corner": [20, 0, 0], "operation": "new", "body_name": "right"}));+ let cut = |y: f64| ("inspect.section", json!({"plane": {"origin": [0, y, 0], "normal": [0, -1, 0]}}));+ let s = session(&[left.clone(), right.clone(), cut(15.0)]);+ let moved = session(&[left, right, cut(15.5)]);+ let mut cam = view::home_camera(&s).unwrap();+ (cam.fov, cam.yaw, cam.pitch) = (0.0, -0.3, 0.2);+ let hatches = |s: &Session| view::scene(s, &cam).unwrap().meshes.iter().map(|m| m.hatch).collect::<Vec<_>>();+ let first = hatches(&s);+ assert_eq!(first.len(), 2);+ assert_ne!(first[0], first[1], "touching caps share a hatch");+ assert_eq!(hatches(&s), first, "the next frame keeps them");+ assert_eq!(hatches(&moved), first, "a plane moved a little keeps them");+ let (w, h) = (360, 280);+ // Each block's cap on screen, 4 px in: x 0..20 and 20..40, z 0..20 at y = 15.+ let radius = view::scene(&s, &cam).unwrap().radius;+ let cap_pixels = |x0: f64| -> Vec<(i64, i64)> {+ 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 q: Vec<(f64, f64)> = [(x0, 0.0), (x0 + 20.0, 0.0), (x0 + 20.0, 20.0), (x0, 20.0)].iter().filter_map(|(x, z)| corner(*x, *z)).collect();+ assert_eq!(q.len(), 4, "the cut is on screen");+ 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();+ let inside = |x: f64, y: f64| {+ (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 >= 4.0+ })+ };+ (0..i64::from(h)).flat_map(|y| (0..i64::from(w)).map(move |x| (x, y))).filter(|(x, y)| inside(*x as f64 + 0.5, *y as f64 + 0.5)).collect()+ };+ let (a, b) = (cap_pixels(0.0), cap_pixels(20.0));+ assert!(a.len() > 1500 && b.len() > 1500, "the caps ({} and {} px)", a.len(), b.len());+ for (mode, c) in capturers() {+ let by_part = c.rgba(&Scene { grid: Vec::new(), ..view::scene(&s, &cam).unwrap() }, &cam, w, h).unwrap();+ let (la, lb) = (hatch_seen(&by_part, w, &a), hatch_seen(&by_part, w, &b));+ assert_ne!(la, lb, "{mode} depth: the touching caps look alike");+ let expect = |hatch: solidcraft_engine::render::hatch::Hatch| hatch.turned();+ assert_eq!((la.1, lb.1), (expect(first[0]), expect(first[1])), "{mode} depth: the caps' angles");+ let one = c.rgba(&Scene { grid: Vec::new(), part_hatch: None, ..view::scene(&s, &cam).unwrap() }, &cam, w, h).unwrap();+ let (oa, ob) = (hatch_seen(&one, w, &a), hatch_seen(&one, w, &b));+ assert_eq!(oa, ob, "{mode} depth: one hatch for every body");+ assert!(!oa.1, "{mode} depth: one hatch runs at 45 degrees");+ }+}diff --git a/crates/render/src/hatch.rs b/crates/render/src/hatch.rsnew file mode 100644index 0000000000..60af8d4714--- /dev/null+++ b/crates/render/src/hatch.rs@@ -0,0 +1,245 @@+//! The section hatch by part, as engineering section drawings tell parts apart: each body a+//! section cuts is hatched at 45 or 135 degrees in one of a few colours of one family, and bodies+//! whose cut faces touch or overlap never share a hatch (a map colouring of the cut, the angle+//! changed first, then the colour). Otherwise a body keeps the hatch its name seeds, so it stays+//! the same from frame to frame and as the plane moves. Spacing and line width are the same for+//! every hatch; only the angle and the colour change.++use std::collections::{HashMap, HashSet};++use solidcraft_geom::{Vec2, Vec3};++/// The colours a cut is hatched in: the section cap's own, then the others of its family.+pub const HATCH_COLOURS: usize = 3;++/// The hatches a body may get: every colour at 45 and at 135 degrees.+pub const HATCHES: usize = 2 * HATCH_COLOURS;++/// One of the [`HATCHES`]: colour `n / 2`, at 135 degrees when `n` is odd. Hatch 0 is the one a+/// section draws every body with when it does not hatch by part: the cap's colour at 45 degrees.+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]+pub struct Hatch(pub u8);++impl Hatch {+ /// Which of the [`HATCH_COLOURS`] it is drawn in.+ pub fn colour(self) -> usize {+ usize::from(self.0 / 2) % HATCH_COLOURS+ }++ /// Its lines run at 135 degrees on screen (else 45).+ pub fn turned(self) -> bool {+ self.0 % 2 == 1+ }++ fn of(colour: usize, turned: bool) -> Hatch {+ Hatch(((colour % HATCH_COLOURS) * 2 + usize::from(turned)) as u8)+ }+}++/// A body's seed: its persistent name hashed (FNV-1a, the same on every platform and release).+pub fn seed(name: &str) -> u64 {+ name.bytes().fold(0xcbf2_9ce4_8422_2325u64, |h, b| (h ^ u64::from(b)).wrapping_mul(0x0100_0000_01b3))+}++/// A closed body the section cuts: its [`seed`] and where the plane cuts it, as segments in the+/// plane (one per crossed triangle, in world space).+pub struct CutPart<'a> {+ pub seed: u64,+ pub segments: &'a [(Vec3, Vec3)],+}++/// Cut faces closer than this, as a share of the whole cut's size, touch: a pin in its bore,+/// tessellated each its own way, still reads as one contact.+const TOUCH: f64 = 1e-3;++/// The hatch of each part (in order) cut by a plane with normal `normal`: the one its seed picks,+/// unless a part it touches or overlaps on the cut, taken first, has that one already; then the+/// same colour at the other angle, then the next colours. Parts are taken in the order of their+/// seeds, so the hatches depend only on which parts are cut and which of them touch.+pub fn hatches(parts: &[CutPart], normal: Vec3) -> Vec<Hatch> {+ let neighbours = touching(parts, normal);+ let mut order: Vec<usize> = (0..parts.len()).collect();+ order.sort_by_key(|&i| (parts.get(i).map_or(0, |p| p.seed), i));+ let mut out: Vec<Option<Hatch>> = vec![None; parts.len()];+ for i in order {+ let Some(part) = parts.get(i) else { continue };+ let taken: Vec<Hatch> = neighbours.get(&i).into_iter().flatten().filter_map(|j| out.get(*j).copied().flatten()).collect();+ let own = Hatch((mix(part.seed) % HATCHES as u64) as u8);+ let candidates = (0..HATCH_COLOURS).flat_map(|k| {+ let colour = own.colour() + k;+ [Hatch::of(colour, own.turned()), Hatch::of(colour, !own.turned())]+ });+ // The first free one; with every one taken, the one the fewest neighbours have.+ let pick = candidates.clone().find(|h| !taken.contains(h)).or_else(|| candidates.min_by_key(|h| taken.iter().filter(|t| *t == h).count()));+ if let Some(slot) = out.get_mut(i) {+ *slot = pick;+ }+ }+ out.into_iter().map(Option::unwrap_or_default).collect()+}++/// The seed spread over all its bits (SplitMix64's finaliser), so names that differ in one+/// letter pick unrelated hatches.+fn mix(mut z: u64) -> u64 {+ z = (z ^ (z >> 30)).wrapping_mul(0xbf58_476d_1ce4_e5b9);+ z = (z ^ (z >> 27)).wrapping_mul(0x94d0_49bb_1331_11eb);+ z ^ (z >> 31)+}++/// Which parts touch or overlap on the cut: per part, the others.+fn touching(parts: &[CutPart], normal: Vec3) -> HashMap<usize, Vec<usize>> {+ let u = normal.any_perp();+ let v = normal.cross(u).normalized().unwrap_or(Vec3::Y);+ let flat = |p: Vec3| Vec2::new(p.dot(u), p.dot(v));+ let cuts: Vec<Vec<(Vec2, Vec2)>> = parts+ .iter()+ .map(|p| p.segments.iter().map(|(a, b)| (flat(*a), flat(*b))).filter(|(a, b)| a.is_finite() && b.is_finite()).collect())+ .collect();+ let boxes: Vec<Option<(Vec2, Vec2)>> = cuts.iter().map(|c| bounds(c)).collect();+ let Some((lo, hi)) = boxes.iter().flatten().copied().reduce(|(a, b), (c, d)| (min2(a, c), max2(b, d))) else {+ return HashMap::new();+ };+ let extent = (hi - lo).len();+ if !(extent.is_finite() && extent > 0.0) {+ return HashMap::new();+ }+ let eps = extent * TOUCH;+ let mut pairs: HashSet<(usize, usize)> = HashSet::new();+ // Outlines closer than `eps`: through a grid of cells at least `eps` wide, each holding the+ // pieces of segments (no longer than a cell) whose box, grown by half of `eps`, reaches it.+ let cell = eps.max(extent / 1024.0);+ let mut grid: HashMap<(i64, i64), Vec<(usize, usize)>> = HashMap::new();+ let at = |x: f64, o: f64| ((x - o) / cell).floor() as i64;+ for (pi, cut) in cuts.iter().enumerate() {+ for (si, (a, b)) in cut.iter().enumerate() {+ let pieces = ((*b - *a).len() / cell).ceil().clamp(1.0, 4096.0) as usize;+ let mut last = None;+ for k in 0..pieces {+ let (p, q) = (a.lerp(*b, k as f64 / pieces as f64), a.lerp(*b, (k + 1) as f64 / pieces as f64));+ let (x0, x1) = (at(p.x.min(q.x) - eps / 2.0, lo.x), at(p.x.max(q.x) + eps / 2.0, lo.x));+ let (y0, y1) = (at(p.y.min(q.y) - eps / 2.0, lo.y), at(p.y.max(q.y) + eps / 2.0, lo.y));+ for x in x0..=x1 {+ for y in y0..=y1 {+ // Consecutive pieces share cells: the segment goes in each cell once.+ if last.is_some_and(|(lx0, lx1, ly0, ly1)| (lx0..=lx1).contains(&x) && (ly0..=ly1).contains(&y)) {+ continue;+ }+ grid.entry((x, y)).or_default().push((pi, si));+ }+ }+ last = Some((x0, x1, y0, y1));+ }+ }+ }+ for list in grid.values() {+ for (k, &(pa, sa)) in list.iter().enumerate() {+ for &(pb, sb) in list.iter().skip(k + 1) {+ let pair = (pa.min(pb), pa.max(pb));+ if pa == pb || pairs.contains(&pair) {+ continue;+ }+ let seg = |p: usize, s: usize| cuts.get(p).and_then(|c| c.get(s)).copied();+ if let (Some(x), Some(y)) = (seg(pa, sa), seg(pb, sb))+ && segment_distance(x, y) <= eps+ {+ pairs.insert(pair);+ }+ }+ }+ }+ // Overlap without outlines that meet: one part's cut lies inside the other's material.+ let mut rows: HashMap<usize, Rows> = HashMap::new();+ for a in 0..cuts.len() {+ for b in a + 1..cuts.len() {+ if pairs.contains(&(a, b)) {+ continue;+ }+ let (Some(Some(ba)), Some(Some(bb))) = (boxes.get(a), boxes.get(b)) else { continue };+ if ba.1.x < bb.0.x || bb.1.x < ba.0.x || ba.1.y < bb.0.y || bb.1.y < ba.0.y {+ continue;+ }+ let inside = |outer: usize, inner: usize, rows: &mut HashMap<usize, Rows>| {+ let (Some(o), Some(Some(first))) = (cuts.get(outer), cuts.get(inner).map(|c| c.first())) else { return false };+ let r = rows.entry(outer).or_insert_with(|| Rows::new(o));+ r.contains(o, first.0.lerp(first.1, 0.5))+ };+ if inside(a, b, &mut rows) || inside(b, a, &mut rows) {+ pairs.insert((a, b));+ }+ }+ }+ let mut out: HashMap<usize, Vec<usize>> = HashMap::new();+ for (a, b) in pairs {+ out.entry(a).or_default().push(b);+ out.entry(b).or_default().push(a);+ }+ out+}++/// A part's cut segments sorted into rows across the plane's second axis, so a point-in-material+/// test looks at the segments of one row.+struct Rows {+ lo: f64,+ step: f64,+ rows: Vec<Vec<usize>>,+}++/// Rows a [`Rows`] makes, at most.+const ROWS: usize = 256;++impl Rows {+ fn new(cut: &[(Vec2, Vec2)]) -> Rows {+ let (lo, hi) = cut.iter().fold((f64::INFINITY, f64::NEG_INFINITY), |(l, h), (a, b)| (l.min(a.y).min(b.y), h.max(a.y).max(b.y)));+ let count = (cut.len() / 16).clamp(1, ROWS);+ let step = if hi > lo { (hi - lo) / count as f64 } else { 1.0 };+ let mut rows = vec![Vec::new(); count];+ let row = |y: f64| (((y - lo) / step).floor().max(0.0) as usize).min(count - 1);+ for (i, (a, b)) in cut.iter().enumerate() {+ for r in rows.iter_mut().take(row(a.y.max(b.y)) + 1).skip(row(a.y.min(b.y))) {+ r.push(i);+ }+ }+ Rows { lo, step, rows }+ }++ /// Whether `p` lies inside the material `cut` bounds: a ray along the first axis crosses its+ /// outline an odd number of times.+ fn contains(&self, cut: &[(Vec2, Vec2)], p: Vec2) -> bool {+ let r = ((p.y - self.lo) / self.step).floor();+ let Some(row) = (r >= 0.0).then_some(r as usize).and_then(|r| self.rows.get(r)) else { return false };+ let crossings = row+ .iter()+ .filter_map(|i| cut.get(*i))+ .filter(|(a, b)| (a.y > p.y) != (b.y > p.y) && a.x + (p.y - a.y) / (b.y - a.y) * (b.x - a.x) > p.x)+ .count();+ crossings % 2 == 1+ }+}++fn min2(a: Vec2, b: Vec2) -> Vec2 {+ Vec2::new(a.x.min(b.x), a.y.min(b.y))+}++fn max2(a: Vec2, b: Vec2) -> Vec2 {+ Vec2::new(a.x.max(b.x), a.y.max(b.y))+}++fn bounds(cut: &[(Vec2, Vec2)]) -> Option<(Vec2, Vec2)> {+ cut.iter().map(|(a, b)| (min2(*a, *b), max2(*a, *b))).reduce(|(a, b), (c, d)| (min2(a, c), max2(b, d)))+}++/// The distance between two segments: zero where they cross, else the nearest end to the other.+fn segment_distance((a, b): (Vec2, Vec2), (c, d): (Vec2, Vec2)) -> f64 {+ let side = |p: Vec2, q: Vec2, r: Vec2| (q - p).cross(r - p);+ let (d1, d2, d3, d4) = (side(c, d, a), side(c, d, b), side(a, b, c), side(a, b, d));+ if ((d1 > 0.0 && d2 < 0.0) || (d1 < 0.0 && d2 > 0.0)) && ((d3 > 0.0 && d4 < 0.0) || (d3 < 0.0 && d4 > 0.0)) {+ return 0.0;+ }+ let to = |p: Vec2, s: Vec2, e: Vec2| {+ let se = e - s;+ let l2 = se.dot(se);+ let t = if l2 > 0.0 { ((p - s).dot(se) / l2).clamp(0.0, 1.0) } else { 0.0 };+ (p - (s + se * t)).len()+ };+ to(a, c, d).min(to(b, c, d)).min(to(c, a, b)).min(to(d, a, b))+}diff --git a/crates/render/src/lib.rs b/crates/render/src/lib.rsindex 420268e810..4d7e850481 100644--- a/crates/render/src/lib.rs+++ b/crates/render/src/lib.rs@@ -12,6 +12,7 @@ pub mod clear_coat;mod curve_display;pub mod film;mod gif;+pub mod hatch;pub mod job;pub mod lighting;pub mod mapping;@@ -41,4 +42,4 @@ pub use curve_display::{PixelCurveView, SampledPath, SamplingBudget, SamplingQuapub use gif::gif;pub use product::{FaceAppearance, ProductMesh, ProductScene};pub use raster::{Canvas, render, render_png, render_transparent};-pub use scene::{MIN_ALPHA, Rgb, SECTION_CAP, SEE_THROUGH, Scene, SceneLine, SceneMesh, png};+pub use scene::{MIN_ALPHA, Rgb, SECTION_CAP, SECTION_HATCH, SEE_THROUGH, Scene, SceneLine, SceneMesh, png};diff --git a/crates/render/src/raster.rs b/crates/render/src/raster.rsindex 7cd128b711..ab65ffc943 100644--- a/crates/render/src/raster.rs+++ b/crates/render/src/raster.rs@@ -118,6 +118,11 @@ pub fn render(scene: &Scene, cam: &Camera, w: usize, h: usize) -> Canvas {let alpha = sm.alpha();let m = &sm.mesh;let body = sm.color.f();+ // The hatch of its cut face: its own by part, else the cap's at 45 degrees.+ let (tint, turned) = match scene.part_hatch {+ Some(colours) => (colours.get(sm.hatch.colour()).map_or(cap_tint, |c| c.f()), sm.hatch.turned()),+ None => (cap_tint, false),+ };let pts: Vec<Option<[f64; 3]>> = m.positions.iter().map(|p| project(*p)).collect();// 1 / clip w per vertex, for perspective-correct interpolation of world positions (so// the section cuts along the plane, not a curve, in perspective views).@@ -194,15 +199,16 @@ pub fn render(scene: &Scene, cam: &Camera, w: usize, h: usize) -> Canvas {};}if cut {- // The cut: the body's colour tinted toward the cap colour, hatched- // at 45 degrees (as the viewport draws it); a plain cap is the- // body's own colour.+ // The cut: the body's colour tinted toward its hatch colour, hatched+ // at 45 or 135 degrees (as the viewport draws it); a plain cap is+ // the body's own colour.if scene.plain_cap {c.put(x, y, base, 1.0);continue;}- let tinted: [f64; 3] = std::array::from_fn(|k| base[k] + (cap_tint[k] - base[k]) * 0.35);- let k = if ((x + y) / SS) % 9 < 2 { 0.6 } else { 1.0 };+ let tinted: [f64; 3] = std::array::from_fn(|k| base[k] + (tint[k] - base[k]) * 0.35);+ let along = if turned { x as i64 - y as i64 } else { (x + y) as i64 };+ let k = if along.div_euclid(SS as i64).rem_euclid(9) < 2 { 0.6 } else { 1.0 };c.put(x, y, tinted.map(|v| v * k), 1.0);continue;}@@ -424,7 +430,14 @@ 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, closed: true };+ let glass = SceneMesh {+ mesh: Arc::new(panel(-5.0)),+ color: Rgb(255, 0, 0),+ face_colors: Vec::new(),+ opacity: front_opacity,+ closed: true,+ hatch: Default::default(),+ };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 ae90fe2b12..a87d233019 100644--- a/crates/render/src/scene.rs+++ b/crates/render/src/scene.rs@@ -7,6 +7,7 @@ use std::sync::Arc;use solidcraft_geom::{Mesh, Vec3};use crate::SceneAnalysis;+use crate::hatch::{HATCH_COLOURS, Hatch};#[derive(Clone, Copy, Debug, PartialEq)]pub struct Rgb(pub u8, pub u8, pub u8);@@ -30,12 +31,14 @@ pub struct SceneMesh {/// 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,+ /// The hatch of its cut face when the scene hatches by part ([`Scene::part_hatch`]).+ pub hatch: Hatch,}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, closed: true }+ SceneMesh { mesh, color, face_colors: Vec::new(), opacity: 1.0, closed: true, hatch: Hatch(0) }}/// Is the body drawn see-through? (Its opacity is below [`SEE_THROUGH`].)@@ -87,6 +90,9 @@ pub struct Scene {pub cap: Option<Rgb>,/// The section cap without its hatch: plain, in the body's own colour.pub plain_cap: bool,+ /// Each cut body hatched its own way ([`SceneMesh::hatch`]), in these colours (the first+ /// the cap's own); `None`: every cut face in [`Scene::cap`] at 45 degrees.+ pub part_hatch: Option<[Rgb; HATCH_COLOURS]>,/// A surface analysis shading the meshes (zebra, draft, curvature map, ...).pub analysis: Option<SceneAnalysis>,}@@ -94,6 +100,10 @@ pub struct Scene {/// The section cap's default tint, as in the viewport.pub const SECTION_CAP: Rgb = Rgb(214, 128, 72);+/// The section hatch's other colours by default, as in the viewport: a steel and a sage that tint+/// a cut face about as strongly as the cap does, so the cut stays calm.+pub const SECTION_HATCH: [Rgb; HATCH_COLOURS - 1] = [Rgb(84, 138, 168), Rgb(108, 180, 126)];+/// RGBA pixels (`w × h`) to PNG bytes.pub fn png(w: usize, h: usize, rgba: Vec<u8>) -> Option<Vec<u8>> {let img = image::RgbaImage::from_raw(u32::try_from(w).ok()?, u32::try_from(h).ok()?, rgba)?;diff --git a/crates/ui-egui/src/colour_vision_tests.rs b/crates/ui-egui/src/colour_vision_tests.rsindex b1559249a8..a0f934f168 100644--- a/crates/ui-egui/src/colour_vision_tests.rs+++ b/crates/ui-egui/src/colour_vision_tests.rs@@ -306,7 +306,11 @@ fn groups(t: &Tokens) -> Vec<Group> {],&[],),- group("section", &[("section_cap", t.section_cap)], &[("body", t.body)]),+ group(+ "section",+ &[("section_cap", t.section_cap), ("section_hatch[0]", t.section_hatch[0]), ("section_hatch[1]", t.section_hatch[1])],+ &[("body", t.body)],+ ),group("interference", &[("interference", t.interference)], &[("body", t.body)]),group("continuity seams",diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rsindex f78be64753..b6377455b9 100644--- a/crates/ui-egui/src/control.rs+++ b/crates/ui-egui/src/control.rs@@ -389,6 +389,9 @@ pub(crate) fn view_scene(app: &SolveApp, guides: solidcraft_engine::view::Guides).map_err(|e| e.to_string())?;scene.plain_cap = !crate::viewport::section_hatch(app);+ if app.preferences.section_hatch == crate::prefs::SectionHatch::One {+ scene.part_hatch = None;+ }Ok(scene)}diff --git a/crates/ui-egui/src/gpu.rs b/crates/ui-egui/src/gpu.rsindex 2535f3ddaa..6b4eb52497 100644--- a/crates/ui-egui/src/gpu.rs+++ b/crates/ui-egui/src/gpu.rs@@ -365,6 +365,7 @@ fn offscreen(ssaa,hover_tint: [0.0; 3],selection_tint: [0.0; 3],+ hatch: Default::default(),});let texture = |format, usage| {device.create_texture(&wgpu::TextureDescriptor {diff --git a/crates/ui-egui/src/prefs.rs b/crates/ui-egui/src/prefs.rsindex 44a1ddec2f..2ab6b458eb 100644--- a/crates/ui-egui/src/prefs.rs+++ b/crates/ui-egui/src/prefs.rs@@ -332,6 +332,19 @@ pub enum HistorySketches {UnderFeature,}+/// How a section hatches the faces it cuts (Preferences: "Section hatch").+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]+#[serde(rename_all = "snake_case")]+pub enum SectionHatch {+ /// Each body in its own hatch (`solidcraft_render::hatch`): 45 or 135 degrees in one of the+ /// theme's hatch colours, touching bodies never alike. Also what a value this version doesn't+ /// know reads as (`lenient`).+ #[default]+ ByPart,+ /// Every cut face in the cap colour at 45 degrees (how it was before by part).+ One,+}+/// What an orbit turns around (Preferences: "Orbit around").#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]#[serde(rename_all = "snake_case")]@@ -586,6 +599,9 @@ preference_settings! {ambient_occlusion: bool = false, PAGE_GRAPHICS;/// Optional schematic markings on threaded cylindrical walls; off for new and older preferences.cosmetic_threads: bool = false, PAGE_GRAPHICS;+ /// A section hatches each cut body its own way (the default), or every one alike, in the cap+ /// colour at 45 degrees, as before.+ section_hatch: SectionHatch = SectionHatch::ByPart, PAGE_GRAPHICS;/// The grid turns to the upright origin plane facing a side view (#1470). Off by default: the/// grid stays on the ground plane (XY) whatever the view.grid_follows_view: bool = false => check("Grid follows the view", "Side views show the grid on the upright plane facing them instead of the ground");diff --git a/crates/ui-egui/src/prefs/graphics.rs b/crates/ui-egui/src/prefs/graphics.rsindex ecdefff899..58e3f3db1a 100644--- a/crates/ui-egui/src/prefs/graphics.rs+++ b/crates/ui-egui/src/prefs/graphics.rs@@ -154,6 +154,15 @@ pub(super) fn show(app: &mut SolveApp, ui: &mut egui::Ui) {let response = ui_kit::checkbox(ui, app.tr("ui.cosmetic_thread_markings"), &mut app.preferences.cosmetic_threads).on_hover_text(app.tr("ui.cosmetic_thread_markings_help"));crate::scenario::publish_handle("prefs:cosmetic_threads", response.rect.center());+ ui_kit::row(ui, app.tr("prefs.section_hatch"), |ui| {+ let styles = [crate::prefs::SectionHatch::One, crate::prefs::SectionHatch::ByPart];+ let mut selected = styles.iter().position(|s| *s == app.preferences.section_hatch).unwrap_or(1);+ if ui_kit::segmented(ui, &mut selected, &[app.tr("prefs.section_hatch_one"), app.tr("prefs.section_hatch_by_part")], Default::default())+ && let Some(style) = styles.get(selected)+ {+ app.preferences.section_hatch = *style;+ }+ });ui.columns(2, |columns| {if let Some(left) = columns.get_mut(0) {ui_kit::checkbox(left, crate::i18n::tr_label("Grid"), &mut app.ui.show_grid);diff --git a/crates/ui-egui/src/render_workspace.rs b/crates/ui-egui/src/render_workspace.rsindex 04bf2ee603..1f2d21a77b 100644--- a/crates/ui-egui/src/render_workspace.rs+++ b/crates/ui-egui/src/render_workspace.rs@@ -1637,6 +1637,7 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {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],+ hatch: Default::default(),});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 96c5a45cf3..5f89659102 100644--- a/crates/ui-egui/src/scale_tests.rs+++ b/crates/ui-egui/src/scale_tests.rs@@ -290,6 +290,7 @@ pub(crate) fn view_frame(ssaa: 1.0,hover_tint: [f32::from(t.hover_face_lift) / 255.0; 3],selection_tint: [0.4, 0.6, 0.9],+ hatch: Default::default(),}}diff --git a/crates/ui-egui/src/theme.rs b/crates/ui-egui/src/theme.rsindex c1c8591976..6977d5d3f1 100644--- a/crates/ui-egui/src/theme.rs+++ b/crates/ui-egui/src/theme.rs@@ -758,6 +758,9 @@ pub struct Tokens {pub chip: Color32,/// Inside of bodies cut by a section.pub section_cap: Color32,+ /// The section hatch's other colours by part, after `section_cap` (Preferences > Graphics >+ /// Section hatch): of its family and lightness, so a cut stays calm.+ pub section_hatch: [Color32; 2],/// Closed sketch profiles (translucent fill).pub profile_fill: Color32,/// Constraint glyph boxes.@@ -902,6 +905,7 @@ impl Tokens {sketch_point: view.sketch_point,sketch_point_free: view.sketch_point_free,section_cap: view.section_cap,+ section_hatch: view.section_hatch,profile_fill: view.profile_fill,glyph_bg: view.glyph_bg,glyph_edge: view.glyph_edge,diff --git a/crates/ui-egui/src/theme_files.rs b/crates/ui-egui/src/theme_files.rsindex 4d4b7487da..01dc51eba1 100644--- a/crates/ui-egui/src/theme_files.rs+++ b/crates/ui-egui/src/theme_files.rs@@ -315,7 +315,7 @@ theme_keys! {app_bar_hover_button, app_bar_hover_strong, app_bar_tab_active,form_ink, form_dim, form_primary, form_error, form_error_fill, form_success, form_success_fill, dialog_body, dialog_footer, dialog_rule, control_fill, control_border, dialog_label, selected_ink, selected_bg,],- many: [continuity, logo],+ many: [continuity, logo, section_hatch],icons: [highlight, agent, marker_halo],}diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rsindex 752a2c691e..b796e70118 100644--- a/crates/ui-egui/src/viewport.rs+++ b/crates/ui-egui/src/viewport.rs@@ -451,6 +451,7 @@ fn scene_key(app: &SolveApp) -> u64 {app.preview.effective_replaced().hash(&mut h);app.preview.rolled_back.hash(&mut h);app.preferences.cosmetic_threads.hash(&mut h);+ app.preferences.section_hatch.hash(&mut h);crate::theme::is_dark().hash(&mut h);crate::theme::vision().hash(&mut h);// Two themes may share a light/dark base while drawing different geometry colours.@@ -1422,6 +1423,9 @@ pub(crate) fn build_scene(app: &SolveApp) -> GpuScene {let mut kept = app.viewport.section_index.lock().map(|mut k| std::mem::take(&mut *k)).unwrap_or_default();let mut made = std::collections::HashMap::with_capacity(kept.len());let normal = [n.x.to_bits(), n.y.to_bits(), n.z.to_bits()];+ // The closed solid bodies the plane cuts and where it cuts them: their hatches by part.+ let by_part = app.preferences.section_hatch == crate::prefs::SectionHatch::ByPart;+ let mut cuts: Vec<(&str, Vec<(Vec3, Vec3)>)> = Vec::new();for b in st.bodies.iter().filter(|b| app.session.body_visible(&b.name)) {let mesh = b.mesh();let key = (std::sync::Arc::as_ptr(&mesh) as usize, normal);@@ -1429,10 +1433,28 @@ pub(crate) fn build_scene(app: &SolveApp) -> GpuScene {Some((_, index)) => index,None => std::sync::Arc::new(solidcraft_engine::view::SectionIndex::new(&mesh, n)),};- for (a, c) in index.segments(&mesh, o) {+ let segments = index.segments(&mesh, o);+ for (a, c) in &segments {sc.line(a.to_f32(), c.to_f32(), col, 1.8, false);}made.insert(key, (mesh, index));+ let solid = b.is_closed() && !body_faded(app, b, &active_bodies) && s.doc.model_body_opacity(b) >= 0.999;+ if by_part && solid && !segments.is_empty() {+ cuts.push((b.name.as_str(), segments));+ }+ }+ // Each cut body's hatch on all its palette entries (its colour, faces and placements).+ let parts: Vec<solidcraft_engine::render::hatch::CutPart> = cuts+ .iter()+ .map(|(name, segments)| solidcraft_engine::render::hatch::CutPart { seed: solidcraft_engine::render::hatch::seed(name), segments })+ .collect();+ let hatches = solidcraft_engine::render::hatch::hatches(&parts, n);+ let palette = std::sync::Arc::make_mut(&mut sc.palette);+ for ((name, _), hatch) in cuts.iter().zip(hatches) {+ let Some(slots) = arena.slots(name) else { continue };+ for slot in (0..slots.face_capacity as usize).map(|f| slots.face(f)).chain([slots.body, slots.instance]) {+ palette.set_hatch(slot, hatch);+ }}if let Ok(mut k) = app.viewport.section_index.lock() {*k = made;@@ -3935,6 +3957,12 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {let c = t.body_selected;[f32::from(c.r()) / 255.0, f32::from(c.g()) / 255.0, f32::from(c.b()) / 255.0]},+ // The section hatch colours by part: the cap's, then the theme's others.+ hatch: std::array::from_fn(|k| {+ let c = if k == 0 { t.section_cap } else { t.section_hatch.get(k - 1).copied().unwrap_or(t.section_cap) };+ let [r, g, b, _] = c.to_normalized_gamma_f32();+ [r, g, b]+ }),});painter.add(egui_wgpu::Callback::new_paint_callback(rect, cb));}@@ -5350,6 +5378,7 @@ pub(crate) fn scene_palette(dark: bool, mode: crate::theme::ColorVision) -> solisketch_centerline: rgb(t.sketch_centerline),axes: t.axes().map(rgb),cap: rgb(t.section_cap),+ hatch: t.section_hatch.map(rgb),isocurve: rgb(t.accent),analysis: t.analysis,}@@ -7161,6 +7190,7 @@ mod tests {ssaa: 1.0,hover_tint: [0.0; 3],selection_tint: [0.0; 3],+ hatch: Default::default(),};let t0 = std::time::Instant::now();let mut encoder = device.create_command_encoder(&Default::default());diff --git a/tests/kernel-cases/crashes/5022-snap-fit-near-zero-thickness/expected.json b/tests/kernel-cases/crashes/5022-snap-fit-near-zero-thickness/expected.jsonindex ee3244f8f1..2d2d95e213 100644--- a/tests/kernel-cases/crashes/5022-snap-fit-near-zero-thickness/expected.json+++ b/tests/kernel-cases/crashes/5022-snap-fit-near-zero-thickness/expected.json@@ -5,5 +5,6 @@"what": "a snap fit 1e-9 mm thick on a box: it got past validation and panicked in the kernel ('tolerance must be no less than 1e-6')","source": "invariants","method": "a 1e-9 mm wall is no solid: the right answer is a clean refusal, never a panic",- "outcome": "refused"+ "outcome": "refused",+ "refusal": "the snap fit's thickness must be at least 0.01 mm"}diff --git a/tests/kernel-cases/ladder/07-fillets/016-corner-three-sequential-r5-r3-r7/expected.json b/tests/kernel-cases/ladder/07-fillets/016-corner-three-sequential-r5-r3-r7/expected.jsonindex 576216d880..ba913b441f 100644--- a/tests/kernel-cases/ladder/07-fillets/016-corner-three-sequential-r5-r3-r7/expected.json+++ b/tests/kernel-cases/ladder/07-fillets/016-corner-three-sequential-r5-r3-r7/expected.json@@ -3,5 +3,6 @@"what": "rounds r5 and r3 on the two top edges at a corner, then r7 on the vertical edge under them: refused, the r7 cannot exist","source": "invariants","method": "the r7 runs on (tangent chain) up the side x=60 along its arc on the r5 round, a circle of radius 5 about the r5 axis: the r7's contact line on that face would be the arc offset 7 towards its centre, radius 5 - 7 < 0, so the blend passes through itself; and along the seam of the r5 and r3 rounds no ball over r3 fits the r3 round. No such round exists, so the right answer is a clean refusal (SMLib: no room for the rolling ball). 018 is the same corner with a radius that fits.",- "outcome": "refused"+ "outcome": "refused",+ "refusal": "the fillet is larger than the faces beside its edges allow"}diff --git a/tests/kernel-cases/sheet-metal/262-fold-at-a-tab-root-refused/expected.json b/tests/kernel-cases/sheet-metal/262-fold-at-a-tab-root-refused/expected.jsonindex 34d0c187ea..6fe7f89c5c 100644--- a/tests/kernel-cases/sheet-metal/262-fold-at-a-tab-root-refused/expected.json+++ b/tests/kernel-cases/sheet-metal/262-fold-at-a-tab-root-refused/expected.json@@ -6,5 +6,6 @@"what": "a fold exactly at a tab's root, where the bend zone (+-BA/2) would reach the blank's outline beside the tab, needs a bend relief","source": "invariants","method": "the fold line y = 50 is the tab's root: its bend zone reaches the corners (40,50) and (60,50) of the outline, so a clean bend is impossible without a relief that fold does not cut; the right behaviour is a refusal that names the cause, not a panic, a hang or a malformed body (BA/2 = (pi/2)(0.8+0.352)/2 = 0.905 mm)",- "outcome": "refused"+ "outcome": "refused",+ "refusal": "the bend zone (1.810 mm wide) reaches a corner of the sheet's outline"}\ No newline at end of filediff --git a/tests/kernel-cases/sheet-metal/3234-edge-flange-on-the-bend-line-refused/expected.json b/tests/kernel-cases/sheet-metal/3234-edge-flange-on-the-bend-line-refused/expected.jsonindex 1082837964..29f493555d 100644--- a/tests/kernel-cases/sheet-metal/3234-edge-flange-on-the-bend-line-refused/expected.json+++ b/tests/kernel-cases/sheet-metal/3234-edge-flange-on-the-bend-line-refused/expected.json@@ -6,5 +6,6 @@"what": "a second edge flange picked on the bend line of an existing flange made a doubled flange with a gap and two shells in one body","source": "invariants","method": "the base's edge at y = 5 (the setback R + T = 5 from the first flange) is the bend line of the existing flange, not a free edge; a flange there would stand on material the first bend already occupies. The right behaviour is a clean refusal that leaves the sheet unchanged",- "outcome": "refused"+ "outcome": "refused",+ "refusal": "that edge is the bend line of a flange; pick a free edge of the sheet"}\ No newline at end of filediff --git a/tests/kernel-cases/sheet-metal/3324-flat-pattern-refused-after-a-fillet-on-the-sheet/expected.json b/tests/kernel-cases/sheet-metal/3324-flat-pattern-refused-after-a-fillet-on-the-sheet/expected.jsonindex 543c0b763f..280c39df22 100644--- a/tests/kernel-cases/sheet-metal/3324-flat-pattern-refused-after-a-fillet-on-the-sheet/expected.json+++ b/tests/kernel-cases/sheet-metal/3324-flat-pattern-refused-after-a-fillet-on-the-sheet/expected.json@@ -7,5 +7,6 @@"what": "a fillet on a sheet metal corner changes the body but not its sheet model, so the flat pattern would be a sharp rectangle: it must refuse","source": "invariants","method": "after Fillet R10 on a corner of a 100 x 60 sheet the body has a round, and a flat pattern written from the sheet model would be the sharp 100 x 60 rectangle, a different part from the design; the right behaviour is a clean refusal naming the feature",- "outcome": "refused"+ "outcome": "refused",+ "refusal": "the flat pattern of `Body1` can't include Fillet1, which changed the body after its sheet metal features"}\ No newline at end of filediff --git a/tests/kernel-cases/sheet-metal/570-flange-refuses-thickness-it-would-ignore/expected.json b/tests/kernel-cases/sheet-metal/570-flange-refuses-thickness-it-would-ignore/expected.jsonindex 420cb13a9b..160b85530b 100644--- a/tests/kernel-cases/sheet-metal/570-flange-refuses-thickness-it-would-ignore/expected.json+++ b/tests/kernel-cases/sheet-metal/570-flange-refuses-thickness-it-would-ignore/expected.json@@ -7,5 +7,6 @@"what": "sheet.flange given thickness, k_factor and bend_radius, which the rule alone defines, used to ignore them silently and build the 2.5 mm default","source": "invariants","method": "a base flange asked for a 0.8 mm sheet must either build 0.8 mm (V = 100*60*0.8 = 4800) or refuse; it must never succeed with another thickness. The engine's documented behaviour is the refusal (the rule is the only source of thickness, k-factor and radius), so the right answer here is a clean refusal",- "outcome": "refused"+ "outcome": "refused",+ "refusal": "`thickness` is not a sheet.flange parameter: the sheet metal rule sets it"}\ No newline at end of filediff --git a/tests/kernel-cases/sweeps/2183-revolve-profile-crosses-the-axis-refused/expected.json b/tests/kernel-cases/sweeps/2183-revolve-profile-crosses-the-axis-refused/expected.jsonindex 7742911ddf..11bbc57423 100644--- a/tests/kernel-cases/sweeps/2183-revolve-profile-crosses-the-axis-refused/expected.json+++ b/tests/kernel-cases/sweeps/2183-revolve-profile-crosses-the-axis-refused/expected.json@@ -6,5 +6,6 @@"what": "a rectangle that straddles the revolve axis (x from -5 to 15 about the sketch y axis)","source": "invariants","method": "a profile on both sides of the axis would sweep over itself, so no solid exists: the right behaviour is a clean refusal (invalid input), with no body made.",- "outcome": "refused"+ "outcome": "refused",+ "refusal": "the profile crosses the revolve axis"}\ No newline at end of filediff --git a/tests/kernel-cases/sweeps/2607-revolve-axis-outside-the-sketch-plane-refused/expected.json b/tests/kernel-cases/sweeps/2607-revolve-axis-outside-the-sketch-plane-refused/expected.jsonindex 719a43a3dc..dfa6b6518e 100644--- a/tests/kernel-cases/sweeps/2607-revolve-axis-outside-the-sketch-plane-refused/expected.json+++ b/tests/kernel-cases/sweeps/2607-revolve-axis-outside-the-sketch-plane-refused/expected.json@@ -6,5 +6,6 @@"what": "a profile on the XZ plane revolved about the world Y axis, which does not lie in the sketch plane","source": "invariants","method": "the revolve axis must lie in the profile plane (the Y axis is perpendicular to the XZ plane): the right behaviour is a clean refusal, with no body made.",- "outcome": "refused"+ "outcome": "refused",+ "refusal": "the Y axis does not lie in the sketch plane"}\ No newline at end of filediff --git a/tests/kernel-cases/sweeps/2667-sweep-hostile-end-scale-refused/expected.json b/tests/kernel-cases/sweeps/2667-sweep-hostile-end-scale-refused/expected.jsonindex 51da95ffaa..16c8ad7a4b 100644--- a/tests/kernel-cases/sweeps/2667-sweep-hostile-end-scale-refused/expected.json+++ b/tests/kernel-cases/sweeps/2667-sweep-hostile-end-scale-refused/expected.json@@ -5,5 +5,6 @@"what": "a sweep with an end scale of 500 (the engine allows 0.01 to 100): the option check (SweepControl::check) must refuse it","source": "invariants","method": "a scale outside 0.01..100 is a hostile value for the sweep options: the right behaviour is a clean refusal with no body made.",- "outcome": "refused"+ "outcome": "refused",+ "refusal": "`scale` (the end scale) must be between 0.01 and 100"}\ No newline at end of filediff --git a/tests/kernel-cases/sweeps/3412-loft-sections-in-one-plane-refused/expected.json b/tests/kernel-cases/sweeps/3412-loft-sections-in-one-plane-refused/expected.jsonindex ee451e2ece..ea2ebc2b08 100644--- a/tests/kernel-cases/sweeps/3412-loft-sections-in-one-plane-refused/expected.json+++ b/tests/kernel-cases/sweeps/3412-loft-sections-in-one-plane-refused/expected.json@@ -5,5 +5,6 @@"what": "a loft through two circles drawn on the same plane (no volume between them; it built a flat zero-volume body and reported success)","source": "invariants","method": "the two sections are coplanar, so no solid exists between them: the right behaviour is a clean refusal with no body left, never a zero-volume body.",- "outcome": "refused"+ "outcome": "refused",+ "refusal": "loft sections 1 and 2 lie in the same plane"}\ No newline at end of file