mirror of
https://github.com/bherbruck/solidcraft.git
synced 2026-11-16 21:51:01 +00:00
dc38349cbf
* Kernel: the B-rep record and the native body file come from solidcore-record
SolidCraft's portable B-rep record (`solidcraft_geom::brep`: brep.rs, topology, history,
envelope, part, curve2) and the native body file (`solidcraft_kernel::native`: the tagged binary
codec and the container) move to solidcore's `solidcore-record` crate: geometry as data, with
structural validation and no maths (solidcore's docs/layers.md, stage 1). Every caller uses
`solidcore_record::brep` and `solidcore_record::native`; the old copies are deleted.
What computes from coordinates stays with the kernel, in geom's `brep`:
- `brep::check`: the record's geometric checks (orthonormal frames, non-degenerate planes,
unit revolution axes, non-singular placements). `check::validate` and
`check::validate_built` are the record's validation and these together, and every caller of
`Brep::validate` uses them, so what is accepted is unchanged;
- `brep::label`: a surface's natural ranges (a cone's apex), `curve_interval`,
`edge_curve_interval` and `form_turns`;
- `brep::pcurve::eval`: a pcurve's point;
- `geometry::check`, `placement::moved` and `split_edges` become functions on the record.
The kernel's native module keeps the conversion between a body and its saved record
(metadata.rs) and checks the decoded record's geometry. `native/analytic.rs`, which no module
declared, is deleted.
solidcore-record is pinned to its rev on solidcore's `layer-record` branch.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NvoxKMbMFSQU8tzRtoJhtT
* Geometry: Vec2, Vec3, Plane and the profile types come from solidcore-record
The plain data of vectors and points, sketch planes and planar profiles (`Seg2`, `Loop2`,
`Region2`) moves to `solidcore-record`, with its constants and component-wise operators only
(owner decision, solidcore layer split). Their geometry stays in geom as traits:
`Vec2Geom`, `Vec3Geom`, `PlaneGeom`, `Seg2Geom`, `Loop2Geom`, `Region2Geom`, `Seg2ArcFit`,
`Loop2ArcFit` and `Region2ArcFit`, in scope with `use solidcraft_geom::prelude::*`. Every caller
names the types from `solidcore_record`; geom no longer defines or re-exports them.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NvoxKMbMFSQU8tzRtoJhtT
* Kernel: pin solidcore-record to solidcore main f5e8e9a29
solidcore-record is merged on solidcore main (tangency-labs/solidcore#2519); its crate there is
identical to the rev pinned before but for its clippy configuration. The lock is regenerated
against the merged rev.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NvoxKMbMFSQU8tzRtoJhtT
---------
Co-authored-by: jyviko <2501648+jyviko@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
190 lines
9.3 KiB
Rust
190 lines
9.3 KiB
Rust
//! Review the real Move overlay and its readouts over the app's headless model render.
|
|
#[path = "support/raster.rs"]
|
|
mod raster;
|
|
use egui::{ColorImage, Event, PointerButton, Pos2, Rect, TextureId, vec2};
|
|
use serde_json::json;
|
|
use solidcore_record::Vec3;
|
|
use solidcraft_engine::Sel;
|
|
use solidcraft_engine::geom::prelude::*;
|
|
use solidcraft_ui_egui::{
|
|
scenario::{self, Harness},
|
|
theme, viewport,
|
|
};
|
|
use std::collections::HashMap;
|
|
|
|
fn bearing(kind: &str) -> (Harness, u64) {
|
|
let mut h = Harness::new();
|
|
h.app.home.open = false;
|
|
h.app.run("component.create", json!({"name":"Housing","grounded":true})).unwrap();
|
|
h.app.run("solid.box", json!({"length":80,"width":20,"height":80,"corner":[-40,0,0]})).unwrap();
|
|
h.app.run("solid.cylinder", json!({"base":[0,0,40],"axis":[0,1,0],"radius":24,"height":20,"operation":"cut"})).unwrap();
|
|
h.app.run("component.activate", json!({"component":"root"})).unwrap();
|
|
let part = h.app.run("component.create", json!({"name":"Bearing","grounded":false})).unwrap();
|
|
h.app.run("solid.cylinder", json!({"base":[0,-20,40],"axis":[0,1,0],"radius":23,"height":28})).unwrap();
|
|
h.app.run("solid.cylinder", json!({"base":[0,-20,40],"axis":[0,1,0],"radius":10,"height":28,"operation":"cut"})).unwrap();
|
|
h.app.run("component.activate", json!({"component":"root"})).unwrap();
|
|
let at = |name: &str| json!({"occurrence":name,"point":[0,0,40],"z":[0,1,0]});
|
|
let joint =
|
|
h.app.run("joint.create", json!({"type":kind,"a":at("Housing"),"b":at("Bearing"),"flip":true,"angle":0,"name":"Guide"})).unwrap()["joint"]
|
|
.as_u64()
|
|
.unwrap();
|
|
let st = h.app.session.world_state().unwrap();
|
|
let body = st.bodies.iter().find(|b| h.app.session.doc.model_body_component(b) == part["component"].as_u64().unwrap()).unwrap();
|
|
let mesh = body.mesh();
|
|
let face = mesh
|
|
.triangles
|
|
.iter()
|
|
.zip(&mesh.tri_face)
|
|
.find(|(t, _)| t.iter().all(|i| (mesh.positions[*i as usize].y + 20.).abs() < 1e-5))
|
|
.map(|(_, f)| *f as usize)
|
|
.unwrap();
|
|
h.app.session.selection = vec![Sel::Face { body: body.name.clone(), index: face, point: Vec3::new(15., -20., 40.) }];
|
|
h.call("ui.view", json!({"view":"iso"}));
|
|
h.app.cam.target = Vec3::new(0., 0., 40.);
|
|
h.app.cam.distance = 240.;
|
|
h.app.preferences.language = "ja".into();
|
|
(h, joint)
|
|
}
|
|
|
|
fn frame(h: &mut Harness, textures: &mut HashMap<TextureId, ColorImage>, events: Vec<Event>) -> egui::FullOutput {
|
|
raster::paint_at(h, textures, events, vec2(1460., 1000.))
|
|
}
|
|
|
|
fn save_frame(h: &mut Harness, textures: &mut HashMap<TextureId, ColorImage>, mut out: egui::FullOutput, path: &std::path::Path) {
|
|
let rect = h.app.viewport.rect.unwrap();
|
|
// This is the app's actual themed model render; handles and panels are actual egui output.
|
|
let png = solidcraft_ui_egui::control::view_png(&h.app, rect.width().round() as u32, rect.height().round() as u32).unwrap();
|
|
let model = image::load_from_memory(&png).unwrap().to_rgba8();
|
|
let id = TextureId::User(77);
|
|
textures.insert(id, ColorImage::from_rgba_unmultiplied([model.width() as usize, model.height() as usize], model.as_raw()));
|
|
let mut background = out
|
|
.shapes
|
|
.iter()
|
|
.position(|s| match &s.shape {
|
|
egui::Shape::Path(path) => path.stroke.width >= 13.5,
|
|
_ => false,
|
|
})
|
|
.expect("Move handle underlay");
|
|
// The dashed axis is painted just before the first arrow's underlay.
|
|
if background > 0 && matches!(&out.shapes[background - 1].shape, egui::Shape::Vec(_)) {
|
|
background -= 1;
|
|
}
|
|
out.shapes.insert(
|
|
background,
|
|
egui::epaint::ClippedShape {
|
|
clip_rect: rect,
|
|
shape: egui::Shape::image(id, rect, Rect::from_min_max(Pos2::ZERO, egui::pos2(1., 1.)), egui::Color32::WHITE),
|
|
},
|
|
);
|
|
raster::raster(h, textures, out).save(path).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn joint_move_has_readable_rotation_and_translation_in_both_themes() {
|
|
let dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../target/joint-move-review");
|
|
std::fs::create_dir_all(&dir).unwrap();
|
|
solidcraft_ui_egui::gpu::install_cpu_picture_renderer();
|
|
for dark in [false, true] {
|
|
for (kind, name) in [("revolute", "rotation"), ("slider", "translation"), ("cylindrical", "combined")] {
|
|
let (mut h, joint) = bearing(kind);
|
|
h.app.ui.dark = dark;
|
|
h.app.preferences.theme = if dark { "dark" } else { "light" }.into();
|
|
h.ctx = egui::Context::default();
|
|
solidcraft_ui_egui::fonts::setup_fonts(&h.ctx);
|
|
theme::set_dark(dark);
|
|
theme::apply(&h.ctx);
|
|
let mut textures = HashMap::new();
|
|
raster::paint(&mut h, &mut textures, vec![]);
|
|
h.app.start("occurrence.move");
|
|
for _ in 0..8 {
|
|
frame(&mut h, &mut textures, vec![]);
|
|
}
|
|
let idle = frame(&mut h, &mut textures, vec![]);
|
|
let heads: Vec<_> = idle
|
|
.shapes
|
|
.iter()
|
|
.filter_map(|s| match &s.shape {
|
|
egui::Shape::Path(path) if path.points.len() == 3 && path.fill == theme::Tokens::get().joint_manipulator => Some(&path.points),
|
|
_ => None,
|
|
})
|
|
.collect();
|
|
assert_eq!(heads.len(), if kind == "cylindrical" { 4 } else { 2 }, "two large heads per movable axis");
|
|
for p in heads {
|
|
let u = p[1] - p[0];
|
|
let v = p[2] - p[0];
|
|
assert!((u.x * v.y - u.y * v.x).abs() * 0.5 >= 400.0, "legible arrowhead, independent of arc tessellation");
|
|
}
|
|
save_frame(&mut h, &mut textures, idle, &dir.join(format!("{}-{name}-idle.png", if dark { "dark" } else { "light" })));
|
|
let from = scenario::handle_at(&format!("joint-move:{joint}:0")).expect("Move handle");
|
|
let rect = h.app.viewport.rect.unwrap();
|
|
let proj = viewport::projection(&h.app, rect);
|
|
let to = if kind != "slider" {
|
|
let origin = Vec3::new(0., -20., 40.);
|
|
let axis = Vec3::Y;
|
|
let (o, d) = proj.ray(from);
|
|
let q = o + d * ((origin - o).dot(axis) / d.dot(axis)) - origin;
|
|
let angle = 27.0_f64.to_radians();
|
|
proj.to_screen(origin + q * angle.cos() + axis.cross(q) * angle.sin()).unwrap()
|
|
} else {
|
|
from + (proj.to_screen(Vec3::Y * 18.75).unwrap() - proj.to_screen(Vec3::ZERO).unwrap())
|
|
};
|
|
frame(
|
|
&mut h,
|
|
&mut textures,
|
|
vec![
|
|
Event::PointerMoved(from),
|
|
Event::PointerButton { pos: from, button: PointerButton::Primary, pressed: true, modifiers: Default::default() },
|
|
],
|
|
);
|
|
for k in 1..=12 {
|
|
frame(&mut h, &mut textures, vec![Event::PointerMoved(from + (to - from) * (k as f32 / 12.))]);
|
|
}
|
|
let out = frame(&mut h, &mut textures, vec![]);
|
|
let readout = if kind != "slider" { "開始位置からの回転角" } else { "開始位置からの移動距離" };
|
|
assert!(
|
|
out.shapes.iter().any(|s| matches!(&s.shape,egui::Shape::Text(t) if t.galley.text().contains(readout))),
|
|
"visible relative readout"
|
|
);
|
|
save_frame(&mut h, &mut textures, out, &dir.join(format!("{}-{name}.png", if dark { "dark" } else { "light" })));
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn joint_move_zero_degree_warning_is_readable_in_both_themes() {
|
|
let dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../target/joint-move-review");
|
|
std::fs::create_dir_all(&dir).unwrap();
|
|
for dark in [false, true] {
|
|
let (mut h, _) = bearing("rigid");
|
|
let before = h.app.session.doc.to_json();
|
|
h.app.ui.dark = dark;
|
|
h.app.preferences.theme = if dark { "dark" } else { "light" }.into();
|
|
h.ctx = egui::Context::default();
|
|
solidcraft_ui_egui::fonts::setup_fonts(&h.ctx);
|
|
theme::set_dark(dark);
|
|
theme::apply(&h.ctx);
|
|
let mut textures = HashMap::new();
|
|
for _ in 0..4 {
|
|
frame(&mut h, &mut textures, vec![]);
|
|
}
|
|
h.app.start("occurrence.move");
|
|
for _ in 0..6 {
|
|
frame(&mut h, &mut textures, vec![]);
|
|
}
|
|
let out = frame(&mut h, &mut textures, vec![]);
|
|
assert!(out.shapes.iter().any(|s| matches!(&s.shape,egui::Shape::Text(t) if t.galley.text().contains("この部品は移動できません"))));
|
|
assert!(out.shapes.iter().any(|s| matches!(&s.shape,egui::Shape::Text(t) if t.galley.text().contains("Rigid合致"))));
|
|
assert_eq!(h.app.session.doc.to_json(), before);
|
|
let rect = scenario::rect_of("dialog:window").unwrap();
|
|
let image = raster::raster(&mut h, &textures, out);
|
|
let x = (rect.min.x.max(0.) as u32).saturating_sub(8);
|
|
let y = (rect.min.y.max(0.) as u32).saturating_sub(8);
|
|
let width = (rect.width().ceil() as u32 + 16).min(image.width() - x);
|
|
let height = (rect.height().ceil() as u32 + 16).min(image.height() - y);
|
|
image::imageops::crop_imm(&image, x, y, width, height)
|
|
.to_image()
|
|
.save(dir.join(format!("{}-warning.png", if dark { "dark" } else { "light" })))
|
|
.unwrap();
|
|
}
|
|
}
|