Wave 21/509: solidcraft-smlib: SMLib bodies into SolidCraft through schema 4
1 commits, squashed; the originals stay reachable from tag archive/merge-main-develop. - 144b56924 jyviko: solidcraft-smlib: SMLib bodies into SolidCraft through schema 4 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01DtL5M41G8Nua7HvuFPZkmJ
This commit is contained in:
@@ -1278,14 +1278,14 @@ impl Body {
|
||||
if let Some(m) = &self.mesh {
|
||||
return Ok(m.to_mesh());
|
||||
}
|
||||
// Two kinds of face truck cannot mesh in its surface's parameters: one trimmed by a
|
||||
// helix, which turns more than once around its cylinder and comes out with triangles
|
||||
// across the solid (#1289), and one that runs across the join of a B-spline surface that
|
||||
// closes on itself, which comes out folded over itself or with a hole in it.
|
||||
// Such a body is meshed from its display plan, which cuts and unwraps those faces.
|
||||
let planned =
|
||||
guard("tessellate", || Ok(crate::tess::seam::turns_more_than_once(&self.solid) || crate::tess::seam::closes_on_itself(&self.solid)));
|
||||
if planned.unwrap_or(false) {
|
||||
// A face trimmed by a helix (a modelled thread from another CAD system) turns more than
|
||||
// once around its cylinder; truck meshes it with triangles across the solid (#1289).
|
||||
// Such a body is meshed from its display plan, which cuts the face along a seam.
|
||||
// So is one bounded by a single seam from pole to pole (a sphere from SMLib), which truck
|
||||
// meshes as nothing.
|
||||
if guard("tessellate", || Ok(crate::tess::seam::turns_more_than_once(&self.solid) || crate::tess::has_pole_to_pole_seam(&self.solid)))
|
||||
.unwrap_or(false)
|
||||
{
|
||||
let turn = (angle.is_finite() && angle > 0.0)
|
||||
.then(|| crate::tess::size::Turn { angle: angle.max(MIN_DISPLAY_ANGLE), floor: tol * DISPLAY_ANGLE_FLOOR });
|
||||
match guard("tessellate", || crate::tess::plan(&self.solid, tol, turn, self.boundary_tol)) {
|
||||
|
||||
@@ -191,7 +191,7 @@ pub use measure::{BodyMeasure, MassMeasure, measure, measure_mass};
|
||||
pub use mesh_convert::convert_prismatic_mesh;
|
||||
pub use meshbody::{MAX_TRIANGLES, mesh_body};
|
||||
#[cfg(feature = "smlib")]
|
||||
pub use native::smlib_body;
|
||||
pub use native::{body_from_smlib, smlib_body};
|
||||
pub use native::{brep_record, decode_native_body, encode_native_body, native_preview_mesh};
|
||||
pub use offset::with_same_surface;
|
||||
pub use ops::{
|
||||
|
||||
@@ -144,6 +144,16 @@ pub fn decode_native_body(bytes: &[u8]) -> Result<Body> {
|
||||
})
|
||||
}
|
||||
|
||||
/// An SMLib body as a kernel body, through its schema 4 record: SMLib's export mapped by
|
||||
/// `solidcraft_smlib` (canonical order, radians, pcurves), then this adapter's decode of a
|
||||
/// foreign record (analytic surfaces as truck's revolutions). The body is oriented as the record
|
||||
/// says; `Body::new` only measures it.
|
||||
#[cfg(feature = "smlib")]
|
||||
pub fn body_from_smlib(brep: &solidcraft_smlib::Brep) -> Result<Body> {
|
||||
let record = brep.to_native().map_err(|e| KernelError::Failed(e.to_string()))?;
|
||||
guard("decode SMLib B-rep", || Body::new(adapter::decode_from(record, adapter::Producer::Foreign)?))
|
||||
}
|
||||
|
||||
fn validate_topology(saved: &SavedBody) -> Result<()> {
|
||||
saved.solid.validate().map_err(invalid)?;
|
||||
let (faces, edges) = (saved.solid.faces.len(), saved.solid.edges.len());
|
||||
|
||||
@@ -162,7 +162,7 @@ pub(super) fn encode(body: &Body) -> Result<b::Brep> {
|
||||
}
|
||||
let result = b::Brep { version: b::VERSION, tolerance, regions, shells: shell_records, faces, edges: edge_records, vertices };
|
||||
result.validate().map_err(invalid)?;
|
||||
compatible(&result)?;
|
||||
compatible(&result, Producer::Own)?;
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
@@ -303,17 +303,36 @@ fn regions(body: &Body) -> Result<Vec<b::Region>> {
|
||||
Ok(regions)
|
||||
}
|
||||
|
||||
fn compatible(body: &b::Brep) -> Result<()> {
|
||||
fn compatible(body: &b::Brep, producer: Producer) -> Result<()> {
|
||||
body.edges.iter().try_for_each(|e| compatible_curve(&e.curve))?;
|
||||
body.faces.iter().try_for_each(|f| compatible_surface(&f.surface))
|
||||
body.faces.iter().try_for_each(|f| match (&f.surface, producer) {
|
||||
// Truck holds a plane by three points: another kernel's axes load rounded once.
|
||||
(b::Surface::Plane { .. }, Producer::Foreign) => Ok(()),
|
||||
(s, _) => compatible_surface(s),
|
||||
})
|
||||
}
|
||||
|
||||
/// Who wrote a record, which sets how exactly it must load.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub(super) enum Producer {
|
||||
/// This adapter: the record loads back number for number, or is refused.
|
||||
Own,
|
||||
/// Another kernel (SMLib): its records load as truck holds them, analytic surfaces as
|
||||
/// revolutions (as for our own) and planes through three points rounded once.
|
||||
#[cfg_attr(not(feature = "smlib"), allow(dead_code))]
|
||||
Foreign,
|
||||
}
|
||||
|
||||
/// The solid of a record: validated, its geometry checked against its topology (truck builds
|
||||
/// edges and faces from it unchecked), then built as the kernel built it.
|
||||
pub(super) fn decode(body: b::Brep) -> Result<mt::Solid> {
|
||||
decode_from(body, Producer::Own)
|
||||
}
|
||||
|
||||
pub(super) fn decode_from(body: b::Brep, producer: Producer) -> Result<mt::Solid> {
|
||||
body.validate().map_err(invalid)?;
|
||||
body.check_geometry().map_err(invalid)?;
|
||||
compatible(&body)?;
|
||||
compatible(&body, producer)?;
|
||||
let b::Brep { shells, faces, edges, vertices, .. } = body;
|
||||
let vertices: Vec<mt::Vertex> = vertices.into_iter().map(|v| mt::Vertex::new(p(v.point))).collect();
|
||||
let vertex = |i: u32| vertices.get(i as usize).ok_or_else(|| invalid("edge vertices"));
|
||||
|
||||
@@ -212,3 +212,42 @@ fn every_pcurve_lifts_onto_its_own_edge() {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// SMLib's primitives load through their schema 4 records as bodies of SMLib's volume, oriented
|
||||
/// as the records say (outward without `Body::new` turning them).
|
||||
#[cfg(feature = "smlib")]
|
||||
#[test]
|
||||
fn smlib_primitives_decode_with_their_volume_and_orientation() {
|
||||
use solidcraft_smlib::Brep as S;
|
||||
let cases = [
|
||||
("box", S::make_box([1., 2., 3.], [10., 20., 30.]).unwrap()),
|
||||
("cylinder", S::make_cylinder([1., 2., 3.], 5., 10.).unwrap()),
|
||||
("sphere", S::make_sphere([1., 2., 3.], 5.).unwrap()),
|
||||
("frustum", S::make_cone([0.; 3], 5., 2., 10.).unwrap()),
|
||||
("widening frustum", S::make_cone([0.; 3], 2., 5., 10.).unwrap()),
|
||||
("cone", S::make_cone([0.; 3], 5., 0., 10.).unwrap()),
|
||||
("torus", S::make_torus([0.; 3], 10., 3.).unwrap()),
|
||||
];
|
||||
for (name, s) in cases {
|
||||
let record = s.to_native().unwrap();
|
||||
let body = crate::native::body_from_smlib(&s).unwrap_or_else(|e| panic!("{name}: {e}"));
|
||||
let forward: Vec<bool> = record
|
||||
.shells
|
||||
.iter()
|
||||
.flat_map(|sh| match sh {
|
||||
b::Shell::Faces { faces, .. } => faces.iter().map(|f| f.forward).collect(),
|
||||
_ => Vec::new(),
|
||||
})
|
||||
.collect();
|
||||
let loaded: Vec<bool> = body.solid.boundaries().iter().flat_map(|sh| sh.face_iter().map(|f| f.orientation()).collect::<Vec<_>>()).collect();
|
||||
assert_eq!(loaded, forward, "{name}: the body was turned inside out");
|
||||
let smlib = s.mass_properties(solidcraft_smlib::MEASURE_ACCURACY).unwrap().volume;
|
||||
let ours = crate::measure(&body).unwrap().volume;
|
||||
assert!((ours - smlib).abs() < 2e-3 * smlib, "{name}: decoded volume {ours}, SMLib's {smlib}");
|
||||
assert_eq!(
|
||||
(body.face_count(), body.edge_count(), body.vertex_count()),
|
||||
(record.faces.len(), record.edges.len(), record.vertices.len()),
|
||||
"{name}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -468,6 +468,60 @@ fn off_surface(rules: &size::Rules) -> f64 {
|
||||
|
||||
/// One face: boundary loops in 3D (shared edge nodes) to parameters and triangles.
|
||||
/// `size`: the face's target side length (mm) and the surface's mean speed along u and v.
|
||||
/// Whether a face of `solid` is bounded by one seam edge alone, used both ways between two
|
||||
/// distinct vertices (poles): a whole sphere as one face, as SMLib writes it. Truck's mesher
|
||||
/// projects both uses onto one parameter line and meshes nothing; the display plan opens the
|
||||
/// loop across the period ([`open_pole_to_pole`]).
|
||||
pub(crate) fn has_pole_to_pole_seam(solid: &Solid) -> bool {
|
||||
solid.face_iter().any(|f| {
|
||||
f.boundaries().iter().any(|w| {
|
||||
let edges: Vec<&mt::Edge> = w.edge_iter().collect();
|
||||
matches!(edges.as_slice(), [a, b] if a.id() == b.id() && a.front() != a.back())
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
/// Twice the signed area of a parameter polygon.
|
||||
fn area2(uv: &[[f64; 2]]) -> f64 {
|
||||
let n = uv.len();
|
||||
(0..n).map(|k| uv.get(k).zip(uv.get((k + 1) % n)).map_or(0.0, |(a, b)| a[0] * b[1] - b[0] * a[1])).sum()
|
||||
}
|
||||
|
||||
/// A loop that runs from one pole to the other and back along the same parameter line (both
|
||||
/// uses of a seam joined only at the poles) encloses nothing once projected: the run after the
|
||||
/// second pole is moved one period along the periodic direction, which way gives the loop a
|
||||
/// positive area, so the face spans the period between its two seam copies.
|
||||
fn open_pole_to_pole(s: &EvalSurface, dom: &uv::Domain, l: &mut seam::Loop) {
|
||||
let n = l.uv.len();
|
||||
let poles: Vec<usize> = (0..n).filter(|&k| l.uv.get(k).is_some_and(|q| (0..2).any(|d| uv::degenerate(s, *q, d)))).collect();
|
||||
let [p0, p1] = poles.as_slice() else { return };
|
||||
let (lo, hi) = l.uv.iter().fold((f64::INFINITY, f64::NEG_INFINITY), |(a, b), q| (a.min(q[0].min(q[1])), b.max(q[0].max(q[1]))));
|
||||
let extent = (hi - lo).abs().max(1e-12);
|
||||
if area2(&l.uv).abs() > 1e-9 * extent * extent {
|
||||
return;
|
||||
}
|
||||
for d in 0..2 {
|
||||
let Some(per) = dom.period[d] else { continue };
|
||||
// Along the seam the periodic parameter is constant between the poles.
|
||||
let second: Vec<usize> = (0..n).filter(|k| (k > p1 || k < p0) && *k != *p0 && *k != *p1).collect();
|
||||
if second.is_empty() {
|
||||
continue;
|
||||
}
|
||||
for sign in [1.0, -1.0] {
|
||||
let mut moved = l.uv.clone();
|
||||
for &k in &second {
|
||||
if let Some(q) = moved.get_mut(k) {
|
||||
q[d] += sign * per;
|
||||
}
|
||||
}
|
||||
if area2(&moved) > 1e-9 * extent * extent {
|
||||
l.uv = moved;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn plan_face(
|
||||
fi: usize,
|
||||
s: &EvalSurface,
|
||||
@@ -533,6 +587,13 @@ fn plan_face(
|
||||
}
|
||||
_ => return Err(fail("boundary winds around the surface both ways")),
|
||||
}
|
||||
// A loop from pole to pole and back along one seam (a whole sphere as one face, as another
|
||||
// kernel writes it) projects onto one parameter line: its second run is a period along.
|
||||
if !seamed {
|
||||
for l in projected.iter_mut() {
|
||||
open_pole_to_pole(s, &dom, l);
|
||||
}
|
||||
}
|
||||
// Split poles.
|
||||
let mut fixed: Vec<Vec3> = Vec::new();
|
||||
let mut uvs: Vec<[f64; 2]> = Vec::new();
|
||||
|
||||
@@ -1 +1 @@
|
||||
40bb855d15391428697d086fd122409c10e5ffee
|
||||
0a48843fd764b0b4a6e8998716e800a91518fe7a
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,136 @@
|
||||
use super::*;
|
||||
|
||||
#[cfg(feature = "native")]
|
||||
mod native_tests {
|
||||
use super::*;
|
||||
use crate::{CheckLevel, MEASURE_ACCURACY};
|
||||
use std::f64::consts::PI;
|
||||
|
||||
/// SMLib's primitives with their closed-form volumes.
|
||||
#[allow(clippy::unwrap_used)] // test fixture
|
||||
fn primitives() -> Vec<(&'static str, Brep, f64)> {
|
||||
vec![
|
||||
("box", Brep::make_box([1.0, 2.0, 3.0], [10.0, 20.0, 30.0]).unwrap(), 6000.0),
|
||||
("cylinder", Brep::make_cylinder([1.0, 2.0, 3.0], 5.0, 10.0).unwrap(), PI * 25.0 * 10.0),
|
||||
("sphere", Brep::make_sphere([1.0, 2.0, 3.0], 5.0).unwrap(), 4.0 / 3.0 * PI * 125.0),
|
||||
("frustum", Brep::make_cone([0.0; 3], 5.0, 2.0, 10.0).unwrap(), PI * 10.0 / 3.0 * (25.0 + 10.0 + 4.0)),
|
||||
("widening frustum", Brep::make_cone([0.0; 3], 2.0, 5.0, 10.0).unwrap(), PI * 10.0 / 3.0 * (25.0 + 10.0 + 4.0)),
|
||||
("cone", Brep::make_cone([0.0; 3], 5.0, 0.0, 10.0).unwrap(), PI * 10.0 / 3.0 * 25.0),
|
||||
("torus", Brep::make_torus([0.0; 3], 10.0, 3.0).unwrap(), 2.0 * PI * PI * 10.0 * 9.0),
|
||||
]
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_primitive_exports_validates_and_keeps_its_volume() {
|
||||
for (name, b, exact) in primitives() {
|
||||
let check = b.check(CheckLevel::All).unwrap();
|
||||
assert!(check.is_valid(), "{name}: {check}");
|
||||
let v = b.mass_properties(MEASURE_ACCURACY).unwrap().volume;
|
||||
assert!((v - exact).abs() < 1e-6 * exact, "{name}: SMLib volume {v}, closed form {exact}");
|
||||
let (native, report) = b.to_native_report().unwrap_or_else(|e| panic!("{name}: {e}"));
|
||||
native.validate().unwrap();
|
||||
native.check_geometry().unwrap_or_else(|e| panic!("{name}: {e}"));
|
||||
assert_eq!(
|
||||
report,
|
||||
Report { recognised_edges: report.recognised_edges, ..Report::default() },
|
||||
"{name}: every edge a line or circle, every face agrees"
|
||||
);
|
||||
let [f, e, n] = b.counts().unwrap();
|
||||
assert_eq!((native.faces.len(), native.edges.len(), native.vertices.len()), (f, e, n), "{name}");
|
||||
// One closed shell bounding one material region; no NURBS edges left.
|
||||
assert_eq!(native.shells.len(), 1, "{name}");
|
||||
assert_eq!(native.regions.len(), 2, "{name}");
|
||||
assert!(!native.regions[0].void && !native.regions[1].void, "{name}");
|
||||
assert!(native.edges.iter().all(|e| matches!(e.curve, b::Curve::Line { .. } | b::Curve::Circle { .. })), "{name}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_primitive_goes_round_through_schema_4_unchanged() {
|
||||
for (name, s, _) in primitives() {
|
||||
let record = s.to_native().unwrap_or_else(|e| panic!("{name}: {e}"));
|
||||
let back = Brep::from_record(&record, true).unwrap_or_else(|e| panic!("{name}: {e}"));
|
||||
let check = back.check(CheckLevel::All).unwrap();
|
||||
assert!(check.is_valid(), "{name}: {check}");
|
||||
assert_eq!(back.counts().unwrap(), s.counts().unwrap(), "{name}");
|
||||
let (v0, v1) = (s.mass_properties(MEASURE_ACCURACY).unwrap().volume, back.mass_properties(MEASURE_ACCURACY).unwrap().volume);
|
||||
assert!((v1 - v0).abs() < 1e-7 * v0, "{name}: volume {v0} -> {v1}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn recognised_edges_are_on_smlibs_curves() {
|
||||
let cyl = Brep::make_cylinder([0.0; 3], 5.0, 10.0).unwrap().to_native().unwrap();
|
||||
let side = cyl.faces.iter().find(|f| matches!(f.surface, b::Surface::Cylinder { .. })).unwrap();
|
||||
assert!((side.domain[0][1] - side.domain[0][0] - TAU).abs() < 1e-12);
|
||||
assert_eq!(side.domain[1], [0.0, 10.0]);
|
||||
for e in &cyl.edges {
|
||||
let eval = b::eval::CurveEval::new(&e.curve).unwrap();
|
||||
let [a, z] = e.interval;
|
||||
// Ends on the edge's vertices.
|
||||
for (t, v) in [(a, e.vertices[0]), (z, e.vertices[1])] {
|
||||
let p = eval.point(t).unwrap();
|
||||
let q = cyl.vertices[v as usize].point;
|
||||
assert!((p - Vec3::new(q[0], q[1], q[2])).len() < 1e-9, "{:?} at {t}", e.curve);
|
||||
}
|
||||
if let b::Curve::Circle { radius, .. } = e.curve {
|
||||
assert!((radius - 5.0).abs() < 1e-12 && (z - a - TAU).abs() < 1e-9);
|
||||
}
|
||||
}
|
||||
// The narrowing cone keeps SMLib's negative half angle.
|
||||
let cone = Brep::make_cone([0.0; 3], 5.0, 0.0, 10.0).unwrap().to_native().unwrap();
|
||||
let half = cone.faces.iter().find_map(|f| if let b::Surface::Cone { half_angle, .. } = f.surface { Some(half_angle) } else { None });
|
||||
assert!((half.unwrap() + 0.5f64.atan()).abs() < 1e-12);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hostile_arrays_are_errors_never_panics() {
|
||||
let good = Brep::make_box([0.0; 3], [1.0, 2.0, 3.0]).unwrap().arrays().unwrap();
|
||||
assert!(native(&good).is_ok());
|
||||
assert!(native(&Arrays::default()).is_err());
|
||||
let ids: Vec<i32> = good.ints.keys().copied().collect();
|
||||
for id in ids {
|
||||
for edit in 0..4 {
|
||||
let mut f = good.clone();
|
||||
let a = f.ints.get_mut(&id).unwrap();
|
||||
match edit {
|
||||
0 => a.clear(),
|
||||
1 => a.iter_mut().for_each(|x| *x = 1 << 40),
|
||||
2 => a.iter_mut().for_each(|x| *x = -1),
|
||||
_ => a.push(7),
|
||||
}
|
||||
let _ = native(&f);
|
||||
}
|
||||
}
|
||||
let ids: Vec<i32> = good.reals.keys().copied().collect();
|
||||
for id in ids {
|
||||
for x in [f64::NAN, f64::INFINITY, 1e300, 0.0] {
|
||||
let mut f = good.clone();
|
||||
f.reals.get_mut(&id).unwrap().iter_mut().for_each(|v| *v = x);
|
||||
let _ = native(&f);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn nurbs_lines_and_arcs_are_recognised_exactly() {
|
||||
let line = Nurbs { knots: vec![2.0, 2.0, 4.0, 4.0], points: vec![[0.0; 3], [1.0, 2.0, 3.0]], weights: vec![1.0, 1.0] };
|
||||
let (c, r) = as_line(&line, [2.0, 4.0]).unwrap_or_else(|| panic!("line"));
|
||||
assert_eq!(c, b::Curve::Line { start: [0.0; 3], end: [1.0, 2.0, 3.0] });
|
||||
assert_eq!(r, [0.0, 1.0]);
|
||||
// A quarter circle of radius 2 about (1, 1, 0) as a rational quadratic Bézier.
|
||||
let w = std::f64::consts::FRAC_1_SQRT_2;
|
||||
let arc = Nurbs {
|
||||
knots: vec![0.0, 0.0, 0.0, 1.0, 1.0, 1.0],
|
||||
points: vec![[3.0, 1.0, 0.0], [3.0, 3.0, 0.0], [1.0, 3.0, 0.0]],
|
||||
weights: vec![1.0, w, 1.0],
|
||||
};
|
||||
let (c, r) = as_circle(&arc, [0.0, 1.0]).unwrap_or_else(|| panic!("arc"));
|
||||
let b::Curve::Circle { frame, radius } = c else { panic!("not a circle") };
|
||||
assert!((radius - 2.0).abs() < 1e-12 && (r[0]).abs() < 1e-12 && (r[1] - std::f64::consts::FRAC_PI_2).abs() < 1e-12, "{r:?}");
|
||||
assert!((frame.origin[0] - 1.0).abs() < 1e-12 && (frame.origin[1] - 1.0).abs() < 1e-12);
|
||||
// A parabola-like quadratic is neither.
|
||||
let not = Nurbs { knots: vec![0.0, 0.0, 0.0, 1.0, 1.0, 1.0], points: vec![[0.0; 3], [1.0, 2.0, 0.0], [2.0, 0.0, 0.0]], weights: vec![1.0; 3] };
|
||||
assert!(as_circle(¬, [0.0, 1.0]).is_none() && as_line(¬, [0.0, 1.0]).is_none());
|
||||
}
|
||||
@@ -197,3 +197,52 @@ extern "C" fn trampoline(_: *mut c_void, level: i32, line: *const c_char) {
|
||||
sink(level, text);
|
||||
}
|
||||
}
|
||||
|
||||
// ---- Primitives (smlib_primitives.cpp) -----------------------------------------------------
|
||||
|
||||
#[cfg(feature = "native")]
|
||||
unsafe extern "C" {
|
||||
fn smlib_make_cylinder(origin: *const f64, radius: f64, height: f64, out: *mut *mut RawBrep) -> i32;
|
||||
fn smlib_make_sphere(center: *const f64, radius: f64, out: *mut *mut RawBrep) -> i32;
|
||||
fn smlib_make_cone(origin: *const f64, base_radius: f64, top_radius: f64, height: f64, out: *mut *mut RawBrep) -> i32;
|
||||
fn smlib_make_torus(center: *const f64, major_radius: f64, minor_radius: f64, out: *mut *mut RawBrep) -> i32;
|
||||
}
|
||||
|
||||
#[cfg(feature = "native")]
|
||||
mod primitive_calls {
|
||||
use super::*;
|
||||
|
||||
pub fn make_cylinder(origin: &[f64; 3], radius: f64, height: f64) -> Result<Handle, i32> {
|
||||
new_brep(|out| unsafe { smlib_make_cylinder(origin.as_ptr(), radius, height, out) })
|
||||
}
|
||||
pub fn make_sphere(center: &[f64; 3], radius: f64) -> Result<Handle, i32> {
|
||||
new_brep(|out| unsafe { smlib_make_sphere(center.as_ptr(), radius, out) })
|
||||
}
|
||||
pub fn make_cone(origin: &[f64; 3], base_radius: f64, top_radius: f64, height: f64) -> Result<Handle, i32> {
|
||||
new_brep(|out| unsafe { smlib_make_cone(origin.as_ptr(), base_radius, top_radius, height, out) })
|
||||
}
|
||||
pub fn make_torus(center: &[f64; 3], major_radius: f64, minor_radius: f64) -> Result<Handle, i32> {
|
||||
new_brep(|out| unsafe { smlib_make_torus(center.as_ptr(), major_radius, minor_radius, out) })
|
||||
}
|
||||
}
|
||||
|
||||
/// The same calls when SMLib is not built: each one fails with [`NOT_BUILT`].
|
||||
#[cfg(not(feature = "native"))]
|
||||
mod primitive_calls {
|
||||
use super::*;
|
||||
|
||||
pub fn make_cylinder(_: &[f64; 3], _: f64, _: f64) -> Result<Handle, i32> {
|
||||
Err(NOT_BUILT)
|
||||
}
|
||||
pub fn make_sphere(_: &[f64; 3], _: f64) -> Result<Handle, i32> {
|
||||
Err(NOT_BUILT)
|
||||
}
|
||||
pub fn make_cone(_: &[f64; 3], _: f64, _: f64, _: f64) -> Result<Handle, i32> {
|
||||
Err(NOT_BUILT)
|
||||
}
|
||||
pub fn make_torus(_: &[f64; 3], _: f64, _: f64) -> Result<Handle, i32> {
|
||||
Err(NOT_BUILT)
|
||||
}
|
||||
}
|
||||
|
||||
pub use primitive_calls::*;
|
||||
|
||||
@@ -100,6 +100,8 @@ pub const FACE_TORUS_AXIS: i32 = 160;
|
||||
pub const FACE_TORUS_REF_DIRECTION: i32 = 161;
|
||||
pub const FACE_TORUS_MAJOR_RADIUS: i32 = 162;
|
||||
pub const FACE_TORUS_MINOR_RADIUS: i32 = 163;
|
||||
/// `SMLIB_FLAT_MAX_LEN`: no array is longer.
|
||||
pub const MAX_LEN: usize = 1 << 27;
|
||||
pub const SURFACE_NURBS: u8 = 0;
|
||||
pub const SURFACE_PLANE: u8 = 1;
|
||||
pub const SURFACE_CYLINDER: u8 = 2;
|
||||
|
||||
@@ -16,6 +16,7 @@ use std::sync::Once;
|
||||
use std::sync::atomic::{AtomicI32, Ordering};
|
||||
|
||||
mod check;
|
||||
pub mod export;
|
||||
mod ffi;
|
||||
pub mod flat;
|
||||
pub mod history;
|
||||
|
||||
Reference in New Issue
Block a user