Wave 303/509: Section hatch by part: touching cut parts never look alike (and 1 more)
2 commits, squashed; the originals stay reachable from tag archive/merge-main-develop. - cfaf4ab55 jyviko: Kernel rig: the reason each refused sheet-metal, sweep, crash and ladder case must be refused for - 30dc4c860 jyviko: Section hatch by part: touching cut parts never look alike Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
This commit is contained in:
@@ -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": "单一样式"
|
||||
}
|
||||
}
|
||||
@@ -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 lighting
|
||||
sel: 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) {
|
||||
|
||||
@@ -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),
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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]],
|
||||
|
||||
+54
-11
@@ -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, acces
|
||||
ssaa: 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");
|
||||
|
||||
+70
-29
@@ -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,
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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))
|
||||
}
|
||||
@@ -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, SamplingQua
|
||||
pub 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};
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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)?;
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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");
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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(())
|
||||
|
||||
@@ -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(),
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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],
|
||||
}
|
||||
|
||||
|
||||
@@ -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) -> soli
|
||||
sketch_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());
|
||||
|
||||
@@ -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"
|
||||
}
|
||||
|
||||
+2
-1
@@ -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"
|
||||
}
|
||||
|
||||
@@ -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"
|
||||
}
|
||||
+2
-1
@@ -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"
|
||||
}
|
||||
+2
-1
@@ -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"
|
||||
}
|
||||
+2
-1
@@ -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"
|
||||
}
|
||||
+2
-1
@@ -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"
|
||||
}
|
||||
+2
-1
@@ -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"
|
||||
}
|
||||
@@ -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"
|
||||
}
|
||||
@@ -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"
|
||||
}
|
||||
Reference in New Issue
Block a user