// ACIS B-rep → truck B-rep → mesh. // // Rebuilds every ACIS face as a truck topological `Face` and lets truck's // meshing kernel triangulate it, routing loaded 3DSOLID / BODY / REGION / // SURFACE geometry through the same NURBS/B-rep kernel the Model tab builds on // instead of the bespoke per-surface sampler in `solid3d_tess`. // // plane-surface → planar face from the sampled boundary loop // cone-surface → partial revolutions via rsweep; closed revolutions use // the parametric sampler // sphere-surface → bespoke sampler, clipped to the boundary window (truck // builds a full ball and cannot trim it to a partial face) // torus-surface → bespoke sampler, clipped to the revolution arc between // the tube's end caps (truck builds a full closed ring) // spline-surface → truck BSplineSurface, grid-sampled (see spline_tess) // // Each face is meshed independently and its triangles are oriented outward // using an analytic per-surface normal — truck's own face orientation is not // consistent across independently built faces, so normals/winding are derived // from geometry instead. Face coverage is recorded on `MeshLodSet`; partial // shells remain displayable but cannot masquerade as complete solid topology. use truck_meshalgo::tessellation::{MeshableShape, MeshedShape}; use truck_modeling::{builder, Face, InnerSpace, Point3, Rad, Shell, Vector3, Wire}; use truck_polymesh::PolygonMesh; use acadrust::entities::acis::types::Sense; use acadrust::entities::acis::{ SatConeSurface, SatDocument, SatFace, SatPlaneSurface, SatSphereSurface, SatTorusSurface, }; use crate::scene::convert::solid3d_tess::{ body_transform, collect_face_loops, cone_axis_span, finalize_mesh, tess_cone_face, tess_plane_face, tess_sphere_face, tess_torus_face, LodConfig, BOUNDARY_CHORD_FRAC, TRUCK_CHORD_FRAC, }; use crate::scene::model::mesh_model::MeshLodSet; use rustc_hash::FxHashMap; /// Slightly over 2π so revolution builders close the loop. const FULL: f64 = std::f64::consts::TAU + 0.2; /// Triangle mesh chord tolerance (world units) for planar faces, where the /// surface itself adds no curvature. const MESH_TOL: f64 = 0.01; /// Analytic outward-normal rule for a face, used to orient triangles and /// supply smooth per-vertex normals (truck's face orientation is unreliable /// for independently built faces). enum Outward { /// Constant normal (planar face). Const([f64; 3]), /// Cone/cylinder: radial away from the axis, tilted by the half-angle. Cone { center: [f64; 3], axis: [f64; 3], sin: f64, cos: f64, }, } impl Outward { fn at(&self, p: [f64; 3]) -> [f64; 3] { match self { Outward::Const(n) => *n, Outward::Cone { center, axis, sin, cos, } => { let d = vsub(p, *center); let h = vdot(d, *axis); let radial = vnorm(vsub(d, vscale(*axis, h))); vnorm(vsub(vscale(radial, *cos), vscale(*axis, *sin))) } } } } /// Tessellate an ACIS SAT document by rebuilding it as truck faces. /// /// Returns `None` when no face could be rebuilt (caller should fall back to /// the bespoke sampler). pub fn tessellate_sat_truck( sat: &SatDocument, name: String, color: [f32; 4], _facet_res: f64, ) -> Option { // Vertices accumulate in f64 world/local space; `finalize_mesh` splits them // into the double-single (high, low) pair once, so a solid at UTM scale // keeps full precision instead of quantizing to the f32 grid. let mut verts: Vec<[f64; 3]> = Vec::new(); let mut normals: Vec<[f32; 3]> = Vec::new(); let mut indices: Vec = Vec::new(); let face_materials: FxHashMap = sat .records .iter() .filter(|record| record.entity_type == "material-adesk-attrib") .filter_map(|record| { let owner = record.token_pointer(2)?.0; let handle = record.token(3)?.as_integer()?; (owner >= 0 && handle > 0) .then(|| (owner, acadrust::Handle::new(handle as u64))) }) .collect(); let face_colors: FxHashMap = sat .records .iter() .filter(|record| record.entity_type == "color-adesk-attrib") .filter_map(|record| { let owner = record.token_pointer(2)?.0; let value = record.token(3)?.as_integer()?; let face_color = if (1..=255).contains(&value) { acadrust::Color::from_index(value as i16) } else if value > 257 { acadrust::Color::from_true_color_value(value as i32) } else { return None; }; Some(( owner, { let mut rgba = crate::scene::convert::tess_util::aci_to_rgba(&face_color); rgba[3] = color[3]; rgba }, )) }) .collect(); let mut triangle_material_handles: Vec> = Vec::new(); let mut triangle_colors: Vec> = Vec::new(); let face_record_indices: Vec = sat .records .iter() .filter(|record| record.is_a("face")) .map(|record| record.index) .collect(); let mut complete = true; for (face, face_record_index) in sat.faces().into_iter().zip(face_record_indices) { let Some(surf_rec) = sat.resolve(face.surface()) else { complete = false; continue; }; let before = indices.len(); let mut appended = false; if let Some((faces, outward, tol)) = build_face_group(sat, &face, surf_rec) { if !faces.is_empty() { let shell: Shell = faces.into(); let poly = shell.triangulation(tol).to_polygon(); if !poly.tri_faces().is_empty() { append_group(&mut verts, &mut normals, &mut indices, &poly, &outward); appended = true; } } } // Truck's rsweep/triangulation degenerates to zero triangles on some // short-arc cones (a curved wall face whose profile passes through the // local origin), leaving a see-through gap. Fall back to the bespoke // parametric sampler for just that face — it writes into the same // buffers, so the shared finalize below still applies uniformly. if !appended { bespoke_face(sat, &face, surf_rec, &mut verts, &mut normals, &mut indices); appended = indices.len() > before; } if !appended { complete = false; } else { let material = face_materials.get(&face_record_index).copied(); triangle_material_handles.extend( std::iter::repeat(material).take((indices.len() - before) / 3), ); let face_color = face_colors.get(&face_record_index).copied(); triangle_colors.extend( std::iter::repeat(face_color).take((indices.len() - before) / 3), ); } } if indices.is_empty() { return None; } let mesh = finalize_mesh( name, verts, normals, indices, triangle_material_handles, triangle_colors, color, body_transform(sat), ); let mut set = MeshLodSet::from_lods(vec![mesh]); set.complete = complete; Some(set) } /// Fill one face with the bespoke parametric sampler (body-local verts into the /// shared mesh buffers) when truck produced no triangles for it. Mirrors the /// surface dispatch of the standalone sampler. fn bespoke_face( sat: &SatDocument, face: &SatFace, surf_rec: &acadrust::entities::acis::SatRecord, v: &mut Vec<[f64; 3]>, n: &mut Vec<[f32; 3]>, i: &mut Vec, ) { match surf_rec.entity_type.as_str() { "plane-surface" => { if let Some(p) = SatPlaneSurface::from_record(surf_rec) { tess_plane_face(sat, face, &p, LodConfig::HIGH.chord_frac, v, n, i); } } "cone-surface" => { if let Some(c) = SatConeSurface::from_record(surf_rec) { tess_cone_face(sat, face, &c, LodConfig::HIGH, v, n, i); } } "sphere-surface" => { if let Some(s) = SatSphereSurface::from_record(surf_rec) { tess_sphere_face(sat, face, &s, LodConfig::HIGH, v, n, i); } } "torus-surface" => { if let Some(t) = SatTorusSurface::from_record(surf_rec) { tess_torus_face(sat, face, &t, LodConfig::HIGH, v, n, i); } } "spline-surface" | "meshsurf-surface" | "bs3-surface" => { crate::scene::convert::spline_tess::tess_spline_face( sat, face, LodConfig::HIGH, v, n, i, ); } _ => {} } } /// Build the truck face(s) + outward rule for one analytic ACIS face. fn build_face_group( sat: &SatDocument, face: &SatFace, surf_rec: &acadrust::entities::acis::SatRecord, ) -> Option<(Vec, Outward, f64)> { // Chord tolerance scaled to a curved surface's radius, so the facet count // is radius-independent (matching the circle/arc wire tessellation) rather // than exploding on large radii. let curve_tol = |radius: f64| (radius.abs() * TRUCK_CHORD_FRAC).max(1e-6); match surf_rec.entity_type.as_str() { "plane-surface" => { let plane = SatPlaneSurface::from_record(surf_rec)?; let f = plane_face(sat, face)?; let (nx, ny, nz) = plane.normal(); let n = if matches!(face.sense(), Sense::Reversed) { [-nx, -ny, -nz] } else { [nx, ny, nz] }; Some((vec![f], Outward::Const(vnorm(n)), MESH_TOL)) } "cone-surface" => { let cone = SatConeSurface::from_record(surf_rec)?; let tol = curve_tol(cone.radius()); let (faces, out) = cone_faces(sat, face, &cone)?; Some((faces, out, tol)) } // Truck builds a sphere as a full revolution and cannot trim it to the // face's boundary, so a partial sphere renders as a whole ball. Route // sphere faces to the bespoke sampler instead — it meshes only the // boundary's parametric window (see `tess_sphere_face`). "sphere-surface" => None, // Like a sphere, truck builds a torus as a full revolution and cannot // trim it to the face's boundary, so an open "C" tube renders as a whole // closed ring. Route torus faces to the bespoke sampler, which meshes // only the revolution arc between the tube's end caps (see // `tess_torus_face` / `torus_phi_range`). "torus-surface" => None, _ => None, } } // ── Planar face ──────────────────────────────────────────────────────────── /// Build a planar truck face from a face's sampled boundary loop. Curved /// boundary edges (circles) are sampled into line segments, which keeps the /// wire planar so `try_attach_plane` can fit the plane. fn plane_face(sat: &SatDocument, face: &SatFace) -> Option { // A pierced face (e.g. a wall with a window opening) has one outer boundary // loop plus an inner loop per hole. `try_attach_plane` fits the plane from // the first wire and cuts the rest as holes, letting truck's mesher trim // them. ACIS records no outer-vs-hole flag — the kernel classifies loops at // runtime from geometry — so we derive the outer boundary here. (#123) let loops = collect_face_loops(sat, face, BOUNDARY_CHORD_FRAC); if loops.is_empty() { return None; } // The outer boundary is the loop that encloses the rest — i.e. the one with // the largest area. ACIS does not guarantee it comes first in the face's // loop list (a pierced wall lists its window holes before the wall edge), // so pick it by area rather than trusting index 0. (#123) let outer_idx = (0..loops.len()) .max_by(|&a, &b| { vlen(loop_normal(&loops[a])) .partial_cmp(&vlen(loop_normal(&loops[b]))) .unwrap_or(std::cmp::Ordering::Equal) }) .unwrap(); if loops[outer_idx].len() < 3 { return None; } // `try_attach_plane` fits its plane normal from the first (outer) wire, so // feeding the outer in its sampled order makes truck read it as CCW. truck // then cuts an inner wire as a hole only when it winds the *opposite* way, // so reverse any hole loop whose area normal agrees with the outer's. The // outer normal has the largest magnitude (largest area), keeping the sign // test robust against sampling noise on small holes. (#123) let outer_n = loop_normal(&loops[outer_idx]); let mut wires: Vec = Vec::new(); wires.push(polygon_wire(&loops[outer_idx], false)?); for (i, lp) in loops.iter().enumerate() { if i == outer_idx { continue; } let same = vdot(loop_normal(lp), outer_n) > 0.0; if let Some(w) = polygon_wire(lp, same) { wires.push(w); } } builder::try_attach_plane(&wires).ok() } fn polygon_wire(pts: &[[f64; 3]], reverse: bool) -> Option { if pts.len() < 3 { return None; } let verts: Vec<_> = if reverse { pts.iter() .rev() .map(|p| builder::vertex(Point3::new(p[0], p[1], p[2]))) .collect() } else { pts.iter() .map(|p| builder::vertex(Point3::new(p[0], p[1], p[2]))) .collect() }; let n = verts.len(); let edges: Vec<_> = (0..n) .map(|i| builder::line(&verts[i], &verts[(i + 1) % n])) .collect(); Some(edges.into()) } /// Newell area-weighted normal of a closed 3-D polygon (orientation only). fn loop_normal(pts: &[[f64; 3]]) -> [f64; 3] { let mut n = [0.0f64; 3]; let m = pts.len(); for i in 0..m { let a = pts[i]; let b = pts[(i + 1) % m]; n[0] += (a[1] - b[1]) * (a[2] + b[2]); n[1] += (a[2] - b[2]) * (a[0] + b[0]); n[2] += (a[0] - b[0]) * (a[1] + b[1]); } n } // ── Cone / cylinder face ───────────────────────────────────────────────────── /// Build a pierced cone/cylinder lateral surface as revolution faces. A /// single-loop face uses the parametric sampler, avoiding partial revolution /// segments that can disappear when the profile crosses a coordinate plane. fn cone_faces( sat: &SatDocument, face: &SatFace, cone: &SatConeSurface, ) -> Option<(Vec, Outward)> { let (cx, cy, cz) = cone.center(); let (ax, ay, az) = cone.axis(); let (ux, uy, uz) = cone.major_axis(); let radius = cone.radius(); let sin = cone.sin_half_angle(); let cos = cone.cos_half_angle(); let axis = norm(Vector3::new(ax, ay, az)); let udir = norm(Vector3::new(ux, uy, uz)); // v = axis × u completes the right-handed frame; angles increase from u // toward v (CCW about the axis), matching `builder::rsweep`. let vdir = Vector3::new( axis.y * udir.z - axis.z * udir.y, axis.z * udir.x - axis.x * udir.z, axis.x * udir.y - axis.y * udir.x, ); let center = Point3::new(cx, cy, cz); let (hmin, hmax) = cone_axis_span(sat, face, cone, [axis.x, axis.y, axis.z], [cx, cy, cz])?; let r_at = |h: f64| { if cos.abs() > 1e-9 { radius + h * sin / cos } else { radius } }; let loops = collect_face_loops(sat, face, BOUNDARY_CHORD_FRAC); if loops.len() == 1 { return None; } let arcs: Vec<(f64, f64)> = loops .iter() .map(|lp| cone_boundary_arc(lp, [cx, cy, cz], axis, udir, vdir)) .collect(); let outer_idx = arcs .iter() .enumerate() .max_by(|(_, a), (_, b)| a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal)) .map(|(i, _)| i)?; let (theta0, sweep) = arcs[outer_idx]; let closed = sweep >= std::f64::consts::TAU; let hole_indices: Vec = arcs .iter() .enumerate() .filter_map(|(i, arc)| (i != outer_idx && arc.1 < std::f64::consts::TAU).then_some(i)) .collect(); if closed && hole_indices.is_empty() { return None; } // Radial direction at the arc's start angle (u rotated by theta0 about axis). let rad0 = udir * theta0.cos() + vdir * theta0.sin(); let p0 = center + rad0 * r_at(hmin) + axis * hmin; let p1 = center + rad0 * r_at(hmax) + axis * hmax; let profile = builder::line(&builder::vertex(p0), &builder::vertex(p1)); let shell: Shell = builder::rsweep(&profile, center, axis, Rad(sweep)); let mut faces: Vec = shell.face_iter().cloned().collect(); if closed { let lateral = faces.first_mut()?; for index in hole_indices { let wire = polygon_wire(&loops[index], false)?; lateral.try_add_boundary(wire).ok()?; } } let out = Outward::Cone { center: [cx, cy, cz], axis: [axis.x, axis.y, axis.z], sin, cos, }; Some((faces, out)) } /// Smallest angular arc `(theta_start, sweep)` about the cone axis enclosing the /// face's boundary points, robust to the ±π seam. Returns `(0.0, FULL)` when the /// points wrap the whole revolution (a closed rim) or the boundary is unusable, /// so a real cylinder/cone still sweeps a complete (overlapped) circle. fn cone_boundary_arc( poly: &[[f64; 3]], center: [f64; 3], _axis: Vector3, udir: Vector3, vdir: Vector3, ) -> (f64, f64) { use std::f64::consts::TAU; let mut angles: Vec = Vec::new(); for p in poly { let d = [p[0] - center[0], p[1] - center[1], p[2] - center[2]]; let ru = d[0] * udir.x + d[1] * udir.y + d[2] * udir.z; let rv = d[0] * vdir.x + d[1] * vdir.y + d[2] * vdir.z; if ru.hypot(rv) > 1e-9 { angles.push(rv.atan2(ru)); } } if angles.len() < 2 { return (0.0, FULL); } angles.sort_by(|a, b| a.partial_cmp(b).unwrap()); // Largest angular gap between consecutive samples (wrapping past the seam); // the enclosing arc is its complement. let mut max_gap = 0.0; let mut gap_at = angles.len() - 1; for i in 0..angles.len() { let a = angles[i]; let b = if i + 1 < angles.len() { angles[i + 1] } else { angles[0] + TAU }; let g = b - a; if g > max_gap { max_gap = g; gap_at = i; } } let span = TAU - max_gap; // Nearly a full revolution → treat as a closed rim. if span >= TAU * 0.98 - 1e-9 || span < 1e-6 { return (0.0, FULL); } // Start at the sample just after the largest gap, sweep CCW by `span`. let start = angles[(gap_at + 1) % angles.len()]; (start, span) } // ── Mesh append with analytic outward normals ──────────────────────────────── /// Append one face's triangulation to `mesh`, computing smooth per-vertex /// normals from the outward rule and flipping any triangle whose winding /// disagrees with that outward direction. fn append_group( verts: &mut Vec<[f64; 3]>, normals: &mut Vec<[f32; 3]>, out_indices: &mut Vec, poly: &PolygonMesh, outward: &Outward, ) { let positions = poly.positions(); let base = verts.len() as u32; for p in positions { let pos = [p.x, p.y, p.z]; verts.push(pos); let n = outward.at(pos); normals.push([n[0] as f32, n[1] as f32, n[2] as f32]); } for tri in poly.tri_faces() { let (i0, i1, i2) = (tri[0].pos, tri[1].pos, tri[2].pos); let a = pt(positions[i0]); let b = pt(positions[i1]); let c = pt(positions[i2]); let gn = vcross(vsub(b, a), vsub(c, a)); let cen = [ (a[0] + b[0] + c[0]) / 3.0, (a[1] + b[1] + c[1]) / 3.0, (a[2] + b[2] + c[2]) / 3.0, ]; let out = outward.at(cen); let (j0, j1, j2) = (base + i0 as u32, base + i1 as u32, base + i2 as u32); if vdot(gn, out) < 0.0 { out_indices.extend_from_slice(&[j0, j2, j1]); } else { out_indices.extend_from_slice(&[j0, j1, j2]); } } } #[inline] fn pt(p: Point3) -> [f64; 3] { [p.x, p.y, p.z] } // ── Vector helpers (cgmath Vector3) ────────────────────────────────────────── #[inline] fn norm(v: Vector3) -> Vector3 { let len = v.magnitude(); if len < 1e-12 { Vector3::unit_z() } else { v / len } } // ── Vector helpers ([f64; 3]) ──────────────────────────────────────────────── #[inline] fn vsub(a: [f64; 3], b: [f64; 3]) -> [f64; 3] { [a[0] - b[0], a[1] - b[1], a[2] - b[2]] } #[inline] fn vscale(a: [f64; 3], s: f64) -> [f64; 3] { [a[0] * s, a[1] * s, a[2] * s] } #[inline] fn vdot(a: [f64; 3], b: [f64; 3]) -> f64 { a[0] * b[0] + a[1] * b[1] + a[2] * b[2] } #[inline] fn vcross(a: [f64; 3], b: [f64; 3]) -> [f64; 3] { [ a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0], ] } #[inline] fn vlen(a: [f64; 3]) -> f64 { vdot(a, a).sqrt() } #[inline] fn vnorm(a: [f64; 3]) -> [f64; 3] { let l = vlen(a); if l < 1e-12 { [0.0, 0.0, 1.0] } else { [a[0] / l, a[1] / l, a[2] / l] } }