1b-agent/OneCAD-Draft
1
0 Fork 0
forked from 1b-agent/opencadstudio-upstream
Code Pull Requests Activity
Files
8f5bffd74a629d1e2e080bd90353dd193510fb80
OneCAD-Draft/src/modules/model/primitive_cmd.rs
T

3088 lines
115 KiB
Rust
Raw Blame History

// Interactive kernel primitives stored as ACIS Solid3D entities.
use acadrust::entities::Solid3D;
use acadrust::objects::SolidHistoryOperation;
use acadrust::EntityType;
use cadkernel::brep::Body;
use cadkernel::geom2d::{
fillets_between, Circle as KernelCircle, Curve as KernelCurve, Line as KernelLine,
Tolerance,
};
use glam::DVec3;
use std::sync::{Mutex, OnceLock};
use std::sync::atomic::{AtomicU64, Ordering};
use crate::command::{CadCommand, CmdOption, CmdResult, TangentObject, WorkingPlane};
use crate::scene::model::solid_model;
use crate::scene::model::wire_model::WireModel;
use crate::t;
static LAST_WEDGE_HEIGHT: AtomicU64 = AtomicU64::new(0);
/// Which primitive a `PrimitiveCommand` builds.
#[derive(Clone, Copy, PartialEq, Eq)]
pub enum Shape {
Box,
Wedge,
Cylinder,
Cone,
Sphere,
Pyramid,
Torus,
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum BoxStep {
FirstCorner,
CenterPoint,
OppositeCorner,
CubeSize,
Length,
Width,
Height,
HeightFirstPoint,
HeightSecondPoint,
}
#[derive(Clone, Copy)]
enum SphereStep {
Center,
Radius(DVec3),
Diameter(DVec3),
TwoPointFirst,
TwoPointSecond(DVec3),
ThreePointFirst,
ThreePointSecond(DVec3),
ThreePointThird(DVec3, DVec3),
TtrFirst,
TtrSecond {
object: TangentObject,
hit: DVec3,
},
TtrRadius {
first: TangentObject,
second: TangentObject,
first_hit: DVec3,
second_hit: DVec3,
},
}
#[derive(Clone, Copy)]
enum ConeStep {
BaseCenter,
BaseRadius,
BaseDiameter,
ThreePointFirst,
ThreePointSecond(DVec3),
ThreePointThird(DVec3, DVec3),
TwoPointFirst,
TwoPointSecond(DVec3),
EllipseFirst,
EllipseCenter,
EllipseCenterFirstAxis(DVec3),
EllipseCenterSecondAxis(DVec3, DVec3),
EllipseSecond(DVec3),
EllipseThird(DVec3, DVec3),
TtrFirst,
TtrSecond { object: TangentObject, hit: DVec3 },
TtrRadius {
first: TangentObject,
second: TangentObject,
first_hit: DVec3,
second_hit: DVec3,
},
Height,
HeightAfterTopRadius,
HeightFirstPoint,
HeightSecondPoint(DVec3),
AxisEndpoint,
TopRadius,
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum PyramidType {
Circumscribed,
Inscribed,
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum PyramidStep {
BaseCenter,
Sides,
EdgeFirst,
EdgeSecond,
BaseRadius,
Height,
HeightAfterTopRadius,
HeightFirstPoint,
HeightSecondPoint,
AxisEndpoint,
TopRadius,
}
#[derive(Clone, Copy)]
struct PyramidDefaults {
displayed_base_radius: f64,
displayed_top_radius: f64,
height: f64,
sides: usize,
kind: PyramidType,
}
impl Default for PyramidDefaults {
fn default() -> Self {
Self {
displayed_base_radius: 1.0,
displayed_top_radius: 0.0,
height: 1.0,
sides: 4,
kind: PyramidType::Circumscribed,
}
}
}
#[derive(Clone, Copy)]
struct ConeDefaults {
base_x_radius: f64,
base_y_radius: f64,
top_radius: f64,
height: f64,
}
impl Default for ConeDefaults {
fn default() -> Self {
Self {
base_x_radius: 1.0,
base_y_radius: 1.0,
top_radius: 0.0,
height: 1.0,
}
}
}
fn sphere_radius_store() -> &'static Mutex<f64> {
static VALUE: OnceLock<Mutex<f64>> = OnceLock::new();
VALUE.get_or_init(|| Mutex::new(1.0))
}
fn sphere_radius_default() -> f64 {
sphere_radius_store()
.lock()
.map(|value| *value)
.unwrap_or(1.0)
}
fn remember_sphere_radius(radius: f64) {
if radius.is_finite() && radius > 1e-6 {
if let Ok(mut value) = sphere_radius_store().lock() {
*value = radius;
}
}
}
fn sphere_tangent_local(object: TangentObject, plane: WorkingPlane) -> TangentObject {
match object {
TangentObject::Line { p1, p2 } => TangentObject::Line {
p1: plane.to_local(p1),
p2: plane.to_local(p2),
},
TangentObject::Circle { center, radius } => TangentObject::Circle {
center: plane.to_local(center),
radius,
},
}
}
fn sphere_tangent_curve(object: TangentObject) -> KernelCurve {
match object {
TangentObject::Line { p1, p2 } => KernelCurve::Line(KernelLine {
start: [p1.x, p1.y],
end: [p2.x, p2.y],
}),
TangentObject::Circle { center, radius } => KernelCurve::Circle(KernelCircle {
centre: [center.x, center.y],
radius,
}),
}
}
fn sphere_ttr_centers(
first: TangentObject,
second: TangentObject,
radius: f64,
) -> Vec<DVec3> {
fillets_between(
&sphere_tangent_curve(first),
&sphere_tangent_curve(second),
radius,
Tolerance::default(),
)
.into_iter()
.map(|fillet| DVec3::new(fillet.centre[0], fillet.centre[1], 0.0))
.collect()
}
fn closest_sphere_center(candidates: &[DVec3], hint: DVec3) -> Option<DVec3> {
candidates.iter().copied().min_by(|first, second| {
first
.distance(hint)
.partial_cmp(&second.distance(hint))
.unwrap_or(std::cmp::Ordering::Equal)
})
}
fn sphere_through_three_points(
first: DVec3,
second: DVec3,
third: DVec3,
) -> Option<(DVec3, f64)> {
let circle = cadkernel::geom2d::arc_through_points(
[first.x, first.y],
[second.x, second.y],
[third.x, third.y],
)?;
Some((
DVec3::new(circle.centre[0], circle.centre[1], first.z),
circle.radius,
))
}
fn cone_defaults() -> &'static std::sync::Mutex<ConeDefaults> {
static DEFAULTS: std::sync::OnceLock<std::sync::Mutex<ConeDefaults>> =
std::sync::OnceLock::new();
DEFAULTS.get_or_init(|| std::sync::Mutex::new(ConeDefaults::default()))
}
fn pyramid_defaults() -> &'static Mutex<PyramidDefaults> {
static DEFAULTS: OnceLock<Mutex<PyramidDefaults>> = OnceLock::new();
DEFAULTS.get_or_init(|| Mutex::new(PyramidDefaults::default()))
}
fn pyramid_apothem_factor(sides: usize) -> f64 {
(std::f64::consts::PI / sides.max(3) as f64).cos()
}
fn pyramid_display_to_circumradius(value: f64, kind: PyramidType, sides: usize) -> f64 {
match kind {
PyramidType::Circumscribed => value / pyramid_apothem_factor(sides),
PyramidType::Inscribed => value,
}
}
fn pyramid_circumradius_to_display(value: f64, kind: PyramidType, sides: usize) -> f64 {
match kind {
PyramidType::Circumscribed => value * pyramid_apothem_factor(sides),
PyramidType::Inscribed => value,
}
}
impl Shape {
fn from_id(id: &str) -> Option<Shape> {
Some(match id {
"BOX" => Shape::Box,
"WEDGE" => Shape::Wedge,
"CYLINDER" => Shape::Cylinder,
"CONE" => Shape::Cone,
"SPHERE" => Shape::Sphere,
"PYRAMID" | "PYR" => Shape::Pyramid,
"TORUS" => Shape::Torus,
_ => return None,
})
}
fn name(self) -> &'static str {
match self {
Shape::Box => "BOX",
Shape::Wedge => "WEDGE",
Shape::Cylinder => "CYLINDER",
Shape::Cone => "CONE",
Shape::Sphere => "SPHERE",
Shape::Pyramid => "PYRAMID",
Shape::Torus => "TORUS",
}
}
/// True for footprints picked as a centre + radius (round shapes); false
/// for corner-to-corner footprints (box/wedge).
fn radial(self) -> bool {
!self.rectangular()
}
fn rectangular(self) -> bool {
matches!(self, Shape::Box | Shape::Wedge)
}
/// Whether a height value is collected after the footprint.
fn needs_height(self) -> bool {
!matches!(self, Shape::Sphere | Shape::Torus)
}
}
pub struct PrimitiveCommand {
shape: Shape,
/// Footprint points collected so far (local/world XY, z = 0).
pts: Vec<DVec3>,
/// True once the footprint is set and we are collecting the height.
height_step: bool,
box_step: BoxStep,
box_centered: bool,
box_origin: Option<DVec3>,
box_length: Option<f64>,
box_width: Option<f64>,
box_angle: f64,
box_width_sign: f64,
box_height_anchor: Option<DVec3>,
sphere_step: SphereStep,
sphere_default_radius: f64,
cone_step: ConeStep,
cone_frame: Option<WorkingPlane>,
cone_base_x_radius: f64,
cone_base_y_radius: f64,
cone_top_radius: f64,
cone_defaults: ConeDefaults,
pyramid_step: PyramidStep,
pyramid_frame: Option<WorkingPlane>,
pyramid_edge_first: Option<DVec3>,
pyramid_height_first: Option<DVec3>,
pyramid_base_radius: f64,
pyramid_top_radius: f64,
pyramid_sides: usize,
pyramid_type: PyramidType,
pyramid_defaults: PyramidDefaults,
plane: WorkingPlane,
}
impl PrimitiveCommand {
pub fn new(id: &str) -> Self {
let remembered = cone_defaults()
.lock()
.map(|value| *value)
.unwrap_or_default();
let pyramid_remembered = pyramid_defaults()
.lock()
.map(|value| *value)
.unwrap_or_default();
Self {
shape: Shape::from_id(id).unwrap_or(Shape::Box),
pts: Vec::new(),
height_step: false,
box_step: BoxStep::FirstCorner,
box_centered: false,
box_origin: None,
box_length: None,
box_width: None,
box_angle: 0.0,
box_width_sign: 1.0,
box_height_anchor: None,
sphere_step: SphereStep::Center,
sphere_default_radius: sphere_radius_default(),
cone_step: ConeStep::BaseCenter,
cone_frame: None,
cone_base_x_radius: remembered.base_x_radius,
cone_base_y_radius: remembered.base_y_radius,
cone_top_radius: remembered.top_radius,
cone_defaults: remembered,
pyramid_step: PyramidStep::BaseCenter,
pyramid_frame: None,
pyramid_edge_first: None,
pyramid_height_first: None,
pyramid_base_radius: pyramid_display_to_circumradius(
pyramid_remembered.displayed_base_radius,
pyramid_remembered.kind,
pyramid_remembered.sides,
),
pyramid_top_radius: pyramid_display_to_circumradius(
pyramid_remembered.displayed_top_radius,
pyramid_remembered.kind,
pyramid_remembered.sides,
),
pyramid_sides: pyramid_remembered.sides,
pyramid_type: pyramid_remembered.kind,
pyramid_defaults: pyramid_remembered,
plane: WorkingPlane::default(),
}
}
fn commit_sphere(&mut self, center: DVec3, radius: f64) -> CmdResult {
if !center.is_finite() || !radius.is_finite() || radius <= 1e-6 {
return CmdResult::NeedPoint;
}
self.pts = vec![center, center + DVec3::X * radius];
self.sphere_default_radius = radius;
remember_sphere_radius(radius);
self.commit(0.0)
}
fn sphere_ttr_result(&mut self, radius: f64) -> CmdResult {
let SphereStep::TtrRadius {
first,
second,
first_hit,
second_hit,
} = self.sphere_step
else {
return CmdResult::NeedPoint;
};
let hint = (first_hit + second_hit) * 0.5;
let Some(center) = closest_sphere_center(
&sphere_ttr_centers(first, second, radius),
hint,
) else {
return CmdResult::NeedPoint;
};
self.commit_sphere(center, radius)
}
fn sphere_preview(&self, center: DVec3, radius: f64) -> Option<WireModel> {
if !center.is_finite() || !radius.is_finite() || radius <= 1e-6 {
return None;
}
Some(self.place_preview(footprint_wire(
Shape::Sphere,
&[center, center + DVec3::X * radius],
)))
}
fn cone_frame_at(&self, center: DVec3) -> WorkingPlane {
WorkingPlane {
origin: center,
x: self.plane.x,
y: self.plane.y,
z: self.plane.z,
}
}
fn set_cone_base(
&mut self,
frame: WorkingPlane,
base_x_radius: f64,
base_y_radius: f64,
) -> bool {
if !frame.origin.is_finite()
|| !frame.x.is_finite()
|| !frame.y.is_finite()
|| !frame.z.is_finite()
|| !base_x_radius.is_finite()
|| !base_y_radius.is_finite()
|| base_x_radius < 1e-6
|| base_y_radius < 1e-6
{
return false;
}
self.cone_frame = Some(frame);
self.cone_base_x_radius = base_x_radius;
self.cone_base_y_radius = base_y_radius;
self.cone_step = ConeStep::Height;
true
}
fn cone_three_point_frame(a: DVec3, b: DVec3, c: DVec3) -> Option<(WorkingPlane, f64)> {
let normal = (b - a).cross(c - a).try_normalize()?;
let first_axis = (b - a).try_normalize()?;
let second_axis = normal.cross(first_axis).try_normalize()?;
let plane = WorkingPlane::new(a, first_axis, second_axis);
let local_b = plane.to_local(b);
let local_c = plane.to_local(c);
let circle = cadkernel::geom2d::arc_through_points(
[0.0, 0.0],
[local_b.x, local_b.y],
[local_c.x, local_c.y],
)?;
let center = plane.to_world(DVec3::new(circle.centre[0], circle.centre[1], 0.0));
let x = (a - center).try_normalize()?;
let y = normal.cross(x).try_normalize()?;
Some((WorkingPlane::new(center, x, y), circle.radius))
}
fn cone_axis_frame(&self, axis: DVec3) -> Option<(WorkingPlane, f64)> {
let current = self.cone_frame?;
let height = axis.length();
if !height.is_finite() || height < 1e-6 {
return None;
}
let z = axis / height;
let mut x = current.x - z * current.x.dot(z);
if x.length_squared() < 1e-12 {
x = current.y - z * current.y.dot(z);
}
let x = x.try_normalize()?;
let y = z.cross(x).try_normalize()?;
Some((WorkingPlane::new(current.origin, x, y), height))
}
fn cone_history_transform(frame: WorkingPlane) -> [f64; 16] {
glam::DMat4::from_cols(
frame.x.extend(0.0),
frame.y.extend(0.0),
frame.z.extend(0.0),
frame.origin.extend(1.0),
)
.to_cols_array()
}
fn build_cone(&self, axis: DVec3) -> Option<(Body, SolidHistoryOperation, f64)> {
let (frame, height) = self.cone_axis_frame(axis)?;
let local = solid_model::cone_frustum_solid(
[0.0; 3],
self.cone_base_x_radius,
self.cone_base_y_radius,
self.cone_top_radius,
height,
)?;
let placed = solid_model::placed(
&local,
frame.x.to_array(),
frame.y.to_array(),
frame.z.to_array(),
frame.origin.to_array(),
)?;
Some((
placed,
crate::scene::model::solid_history::cone_op(
Self::cone_history_transform(frame),
self.cone_base_x_radius,
self.cone_base_y_radius,
self.cone_top_radius,
height,
),
height,
))
}
fn commit_cone_axis(&self, axis: DVec3) -> CmdResult {
let Some((solid, history, height)) = self.build_cone(axis) else {
return CmdResult::NeedPoint;
};
if let Ok(mut defaults) = cone_defaults().lock() {
*defaults = ConeDefaults {
base_x_radius: self.cone_base_x_radius,
base_y_radius: self.cone_base_y_radius,
top_radius: self.cone_top_radius,
height,
};
}
let Some(document) = crate::scene::convert::acis_export::solid_to_sat(&solid) else {
return CmdResult::Cancel;
};
let mut entity = Solid3D::new();
entity.set_sat_document(&document);
entity.wires = solid_model::edge_wires(&solid);
CmdResult::CommitSolid {
entity: EntityType::Solid3D(entity),
solid: Box::new(solid),
history,
}
}
fn commit_cone_height(&self, height: f64) -> CmdResult {
let Some(frame) = self.cone_frame else {
return CmdResult::NeedPoint;
};
if !height.is_finite() || height.abs() < 1e-6 {
return CmdResult::NeedPoint;
}
self.commit_cone_axis(frame.z * height)
}
fn cone_height_at(&self, point: DVec3) -> Option<f64> {
let frame = self.cone_frame?;
Some((point - frame.origin).dot(frame.z))
}
fn cone_ttr_center(&self, radius: f64) -> Option<DVec3> {
let ConeStep::TtrRadius {
first,
second,
first_hit,
second_hit,
} = self.cone_step
else {
return None;
};
let candidates = crate::modules::draw::draw::circle::ttr_candidates(first, second, radius);
let local = crate::modules::draw::draw::circle::best_of(
&candidates,
(first_hit + second_hit) * 0.5,
)?;
Some(self.plane.to_world(local))
}
fn cone_preview(&self, axis: DVec3) -> Option<WireModel> {
let (frame, height) = self.cone_axis_frame(axis)?;
let top = frame.origin + frame.z * height;
let top_y = if self.cone_top_radius > 0.0 {
self.cone_top_radius * self.cone_base_y_radius / self.cone_base_x_radius
} else {
0.0
};
let mut points = Vec::new();
push_ellipse_world(
&mut points,
frame.origin,
frame.x,
frame.y,
self.cone_base_x_radius,
self.cone_base_y_radius,
);
if self.cone_top_radius > 1e-9 {
push_ellipse_world(
&mut points,
top,
frame.x,
frame.y,
self.cone_top_radius,
top_y,
);
}
for index in 0..4 {
let angle = index as f64 * std::f64::consts::FRAC_PI_2;
let base = frame.origin
+ frame.x * (self.cone_base_x_radius * angle.cos())
+ frame.y * (self.cone_base_y_radius * angle.sin());
let upper = if self.cone_top_radius > 1e-9 {
top + frame.x * (self.cone_top_radius * angle.cos())
+ frame.y * (top_y * angle.sin())
} else {
top
};
push_segment(&mut points, base, upper);
}
Some(wire("primitive_height_preview", points))
}
fn cone_base_preview(&self, frame: WorkingPlane, x_radius: f64, y_radius: f64) -> WireModel {
let mut points = Vec::new();
push_ellipse_world(
&mut points,
frame.origin,
frame.x,
frame.y,
x_radius.max(1e-9),
y_radius.max(1e-9),
);
wire("primitive_preview", points)
}
fn cone_prompt(&self) -> String {
match self.cone_step {
ConeStep::BaseCenter =>
t!("CONE Specify center point of base or [3P/2P/Ttr/Elliptical]:").into_owned(),
ConeStep::BaseRadius => crate::tf!(
"CONE Specify base radius or [Diameter] <{:.4}>:",
self.cone_defaults.base_x_radius
).into_owned(),
ConeStep::BaseDiameter => crate::tf!(
"CONE Specify base diameter <{:.4}>:",
self.cone_defaults.base_x_radius * 2.0
).into_owned(),
ConeStep::ThreePointFirst => t!("CONE Specify first point on base:").into_owned(),
ConeStep::ThreePointSecond(_) => t!("CONE Specify second point on base:").into_owned(),
ConeStep::ThreePointThird(_, _) => t!("CONE Specify third point on base:").into_owned(),
ConeStep::TwoPointFirst => t!("CONE Specify first endpoint of base diameter:").into_owned(),
ConeStep::TwoPointSecond(_) => t!("CONE Specify second endpoint of base diameter:").into_owned(),
ConeStep::EllipseFirst =>
t!("CONE Specify endpoint of first axis or [Center]:").into_owned(),
ConeStep::EllipseCenter => t!("CONE Specify center point:").into_owned(),
ConeStep::EllipseCenterFirstAxis(_) => crate::tf!(
"CONE Specify distance to first axis <{:.4}>:",
self.cone_defaults.base_x_radius
)
.into_owned(),
ConeStep::EllipseCenterSecondAxis(_, _) =>
t!("CONE Specify endpoint of second axis:").into_owned(),
ConeStep::EllipseSecond(_) => t!("CONE Specify second endpoint of ellipse axis:").into_owned(),
ConeStep::EllipseThird(_, _) => t!("CONE Specify distance to other ellipse axis:").into_owned(),
ConeStep::TtrFirst => t!("CONE Select first tangent object:").into_owned(),
ConeStep::TtrSecond { .. } => t!("CONE Select second tangent object:").into_owned(),
ConeStep::TtrRadius { .. } => crate::tf!(
"CONE Specify base radius <{:.4}>:",
self.cone_defaults.base_x_radius
).into_owned(),
ConeStep::Height => crate::tf!(
"CONE Specify height or [2Point/Axis endpoint/Top radius] <{:.4}>:",
self.cone_defaults.height
).into_owned(),
ConeStep::HeightAfterTopRadius => crate::tf!(
"CONE Specify height or [2Point/Axis endpoint] <{:.4}>:",
self.cone_defaults.height
)
.into_owned(),
ConeStep::HeightFirstPoint => t!("CONE Specify first point for height:").into_owned(),
ConeStep::HeightSecondPoint(_) => t!("CONE Specify second point for height:").into_owned(),
ConeStep::AxisEndpoint => t!("CONE Specify axis endpoint:").into_owned(),
ConeStep::TopRadius => crate::tf!(
"CONE Specify top radius <{:.4}>:",
self.cone_defaults.top_radius
).into_owned(),
}
}
fn cone_options(&self) -> Vec<CmdOption> {
match self.cone_step {
ConeStep::BaseCenter => vec![
CmdOption::new("3P", "3P"),
CmdOption::new("2P", "2P"),
CmdOption::new("Ttr", "TTR"),
CmdOption::new(t!("Elliptical").as_ref(), "E"),
],
ConeStep::BaseRadius => vec![CmdOption::new(t!("Diameter").as_ref(), "D")],
ConeStep::EllipseFirst => vec![CmdOption::new(t!("Center").as_ref(), "C")],
ConeStep::Height => vec![
CmdOption::new("2Point", "2P"),
CmdOption::new(t!("Axis endpoint").as_ref(), "A"),
CmdOption::new(t!("Top radius").as_ref(), "T"),
],
ConeStep::HeightAfterTopRadius => vec![
CmdOption::new("2Point", "2P"),
CmdOption::new(t!("Axis endpoint").as_ref(), "A"),
],
_ => Vec::new(),
}
}
fn on_cone_point(&mut self, point: DVec3) -> CmdResult {
match self.cone_step {
ConeStep::BaseCenter => {
self.cone_frame = Some(self.cone_frame_at(point));
self.cone_step = ConeStep::BaseRadius;
CmdResult::NeedPoint
}
ConeStep::BaseRadius => {
let Some(frame) = self.cone_frame else {
return CmdResult::NeedPoint;
};
let local = frame.to_local(point);
let radius = local.x.hypot(local.y);
self.set_cone_base(frame, radius, radius);
CmdResult::NeedPoint
}
ConeStep::BaseDiameter => {
let Some(frame) = self.cone_frame else {
return CmdResult::NeedPoint;
};
let local = frame.to_local(point);
let radius = local.x.hypot(local.y) * 0.5;
self.set_cone_base(frame, radius, radius);
CmdResult::NeedPoint
}
ConeStep::ThreePointFirst => {
self.cone_step = ConeStep::ThreePointSecond(point);
CmdResult::NeedPoint
}
ConeStep::ThreePointSecond(first) => {
if point.distance_squared(first) > 1e-12 {
self.cone_step = ConeStep::ThreePointThird(first, point);
}
CmdResult::NeedPoint
}
ConeStep::ThreePointThird(first, second) => {
if let Some((frame, radius)) = Self::cone_three_point_frame(first, second, point) {
self.set_cone_base(frame, radius, radius);
}
CmdResult::NeedPoint
}
ConeStep::TwoPointFirst => {
self.cone_step = ConeStep::TwoPointSecond(point);
CmdResult::NeedPoint
}
ConeStep::TwoPointSecond(first) => {
let a = self.plane.to_local(first);
let b = self.plane.to_local(point);
let radius = (b - a).truncate().length() * 0.5;
let center = self.plane.to_world((a + b) * 0.5);
self.set_cone_base(self.cone_frame_at(center), radius, radius);
CmdResult::NeedPoint
}
ConeStep::EllipseFirst => {
self.cone_step = ConeStep::EllipseSecond(point);
CmdResult::NeedPoint
}
ConeStep::EllipseCenter => {
self.cone_step = ConeStep::EllipseCenterFirstAxis(point);
CmdResult::NeedPoint
}
ConeStep::EllipseCenterFirstAxis(center) => {
if point.distance_squared(center) > 1e-12 {
self.cone_step = ConeStep::EllipseCenterSecondAxis(center, point);
}
CmdResult::NeedPoint
}
ConeStep::EllipseCenterSecondAxis(center, first_axis_end) => {
let axis = first_axis_end - center;
if let Some(x) = axis.try_normalize() {
let y = self.plane.z.cross(x).normalize_or_zero();
let frame = WorkingPlane::new(center, x, y);
let local = frame.to_local(point);
self.set_cone_base(frame, axis.length(), local.y.abs());
}
CmdResult::NeedPoint
}
ConeStep::EllipseSecond(first) => {
if point.distance_squared(first) > 1e-12 {
self.cone_step = ConeStep::EllipseThird(first, point);
}
CmdResult::NeedPoint
}
ConeStep::EllipseThird(first, second) => {
let a = self.plane.to_local(first);
let b = self.plane.to_local(second);
let center_local = (a + b) * 0.5;
let axis = (b - a).truncate();
let x_radius = axis.length() * 0.5;
if let Some(x2) = axis.try_normalize() {
let x = self.plane.vector_to_world(DVec3::new(x2.x, x2.y, 0.0));
let y = self.plane.z.cross(x).normalize_or_zero();
let frame = WorkingPlane::new(self.plane.to_world(center_local), x, y);
let local = frame.to_local(point);
self.set_cone_base(frame, x_radius, local.y.abs());
}
CmdResult::NeedPoint
}
ConeStep::TtrRadius { second_hit, .. } => {
let local = self.plane.to_local(point);
let radius = (local - second_hit).truncate().length();
if let Some(center) = self.cone_ttr_center(radius) {
self.set_cone_base(self.cone_frame_at(center), radius, radius);
}
CmdResult::NeedPoint
}
ConeStep::Height | ConeStep::HeightAfterTopRadius => self
.cone_height_at(point)
.map(|height| self.commit_cone_height(height))
.unwrap_or(CmdResult::NeedPoint),
ConeStep::HeightFirstPoint => {
self.cone_step = ConeStep::HeightSecondPoint(point);
CmdResult::NeedPoint
}
ConeStep::HeightSecondPoint(first) => self.commit_cone_height(first.distance(point)),
ConeStep::AxisEndpoint => {
let Some(frame) = self.cone_frame else {
return CmdResult::NeedPoint;
};
self.commit_cone_axis(point - frame.origin)
}
ConeStep::TopRadius => {
let Some(frame) = self.cone_frame else {
return CmdResult::NeedPoint;
};
let local = frame.to_local(point);
let radius = local.x.hypot(local.y);
if radius.is_finite() {
self.cone_top_radius = radius;
self.cone_step = ConeStep::HeightAfterTopRadius;
}
CmdResult::NeedPoint
}
ConeStep::TtrFirst | ConeStep::TtrSecond { .. } => CmdResult::NeedPoint,
}
}
fn on_cone_tangent(&mut self, object: TangentObject, hit: DVec3) -> CmdResult {
let object = crate::modules::draw::draw::circle::tangent_object_local(object, self.plane);
let hit = self.plane.to_local(hit);
match self.cone_step {
ConeStep::TtrFirst => {
self.cone_step = ConeStep::TtrSecond { object, hit };
}
ConeStep::TtrSecond {
object: first,
hit: first_hit,
} => {
self.cone_step = ConeStep::TtrRadius {
first,
second: object,
first_hit,
second_hit: hit,
};
}
_ => {}
}
CmdResult::NeedPoint
}
fn on_cone_text(&mut self, raw: &str) -> Option<CmdResult> {
let token = raw.trim();
let upper = token.to_uppercase();
match self.cone_step {
ConeStep::BaseCenter => {
self.cone_step = match upper.as_str() {
"3P" => ConeStep::ThreePointFirst,
"2P" => ConeStep::TwoPointFirst,
"T" | "TTR" => ConeStep::TtrFirst,
"E" | "ELLIPTICAL" => ConeStep::EllipseFirst,
_ => return None,
};
return Some(CmdResult::NeedPoint);
}
ConeStep::BaseRadius if matches!(upper.as_str(), "D" | "DIAMETER") => {
self.cone_step = ConeStep::BaseDiameter;
return Some(CmdResult::NeedPoint);
}
ConeStep::EllipseFirst if matches!(upper.as_str(), "C" | "CENTER") => {
self.cone_step = ConeStep::EllipseCenter;
return Some(CmdResult::NeedPoint);
}
ConeStep::Height => {
self.cone_step = match upper.as_str() {
"2P" | "2POINT" => ConeStep::HeightFirstPoint,
"A" | "AXIS" | "AXIS ENDPOINT" => ConeStep::AxisEndpoint,
"T" | "TOP" | "TOP RADIUS" => ConeStep::TopRadius,
_ => {
let height = crate::entities::common::parse_typed_length(token)?;
return Some(self.commit_cone_height(height));
}
};
return Some(CmdResult::NeedPoint);
}
ConeStep::HeightAfterTopRadius => {
self.cone_step = match upper.as_str() {
"2P" | "2POINT" => ConeStep::HeightFirstPoint,
"A" | "AXIS" | "AXIS ENDPOINT" => ConeStep::AxisEndpoint,
_ => {
let height = crate::entities::common::parse_typed_length(token)?;
return Some(self.commit_cone_height(height));
}
};
return Some(CmdResult::NeedPoint);
}
_ => {}
}
let number = crate::entities::common::parse_typed_length(token)?;
match self.cone_step {
ConeStep::BaseRadius => {
let frame = self.cone_frame?;
(number > 0.0).then(|| {
self.set_cone_base(frame, number, number);
CmdResult::NeedPoint
})
}
ConeStep::BaseDiameter => {
let frame = self.cone_frame?;
(number > 0.0).then(|| {
self.set_cone_base(frame, number * 0.5, number * 0.5);
CmdResult::NeedPoint
})
}
ConeStep::EllipseCenterFirstAxis(center) => (number > 0.0).then(|| {
self.cone_step = ConeStep::EllipseCenterSecondAxis(
center,
center + self.plane.x * number,
);
CmdResult::NeedPoint
}),
ConeStep::TtrRadius { .. } => {
let center = self.cone_ttr_center(number)?;
(number > 0.0).then(|| {
self.set_cone_base(self.cone_frame_at(center), number, number);
CmdResult::NeedPoint
})
}
ConeStep::TopRadius if number >= 0.0 => {
self.cone_top_radius = number;
self.cone_step = ConeStep::HeightAfterTopRadius;
Some(CmdResult::NeedPoint)
}
_ => None,
}
}
fn cone_mouse_move(&self, point: DVec3) -> Option<WireModel> {
match self.cone_step {
ConeStep::BaseRadius => {
let frame = self.cone_frame?;
let local = frame.to_local(point);
let radius = local.x.hypot(local.y);
Some(self.cone_base_preview(frame, radius, radius))
}
ConeStep::BaseDiameter => {
let frame = self.cone_frame?;
let local = frame.to_local(point);
let radius = local.x.hypot(local.y) * 0.5;
Some(self.cone_base_preview(frame, radius, radius))
}
ConeStep::ThreePointSecond(first) | ConeStep::TwoPointSecond(first) => {
let a = self.plane.to_local(first);
let b = self.plane.to_local(point);
let center = self.plane.to_world((a + b) * 0.5);
let radius = (b - a).truncate().length() * 0.5;
Some(self.cone_base_preview(self.cone_frame_at(center), radius, radius))
}
ConeStep::ThreePointThird(first, second) => {
let (frame, radius) = Self::cone_three_point_frame(first, second, point)?;
Some(self.cone_base_preview(frame, radius, radius))
}
ConeStep::EllipseThird(first, second) => {
let a = self.plane.to_local(first);
let b = self.plane.to_local(second);
let center_local = (a + b) * 0.5;
let axis = (b - a).truncate();
let x2 = axis.try_normalize()?;
let x = self.plane.vector_to_world(DVec3::new(x2.x, x2.y, 0.0));
let y = self.plane.z.cross(x).normalize_or_zero();
let frame = WorkingPlane::new(self.plane.to_world(center_local), x, y);
let local = frame.to_local(point);
Some(self.cone_base_preview(frame, axis.length() * 0.5, local.y.abs()))
}
ConeStep::EllipseCenterSecondAxis(center, first_axis_end) => {
let axis = first_axis_end - center;
let x = axis.try_normalize()?;
let y = self.plane.z.cross(x).normalize_or_zero();
let frame = WorkingPlane::new(center, x, y);
let local = frame.to_local(point);
Some(self.cone_base_preview(frame, axis.length(), local.y.abs()))
}
ConeStep::TtrRadius { second_hit, .. } => {
let local = self.plane.to_local(point);
let radius = (local - second_hit).truncate().length();
let center = self.cone_ttr_center(radius)?;
Some(self.cone_base_preview(self.cone_frame_at(center), radius, radius))
}
ConeStep::Height | ConeStep::HeightAfterTopRadius => {
let frame = self.cone_frame?;
self.cone_preview(frame.z * self.cone_height_at(point)?)
}
ConeStep::HeightSecondPoint(first) => {
let frame = self.cone_frame?;
self.cone_preview(frame.z * first.distance(point))
}
ConeStep::AxisEndpoint => {
let frame = self.cone_frame?;
self.cone_preview(point - frame.origin)
}
_ => None,
}
}
fn pyramid_frame_at(&self, center: DVec3) -> WorkingPlane {
WorkingPlane {
origin: center,
x: self.plane.x,
y: self.plane.y,
z: self.plane.z,
}
}
fn set_pyramid_type(&mut self, kind: PyramidType) {
let displayed_top = pyramid_circumradius_to_display(
self.pyramid_top_radius,
self.pyramid_type,
self.pyramid_sides,
);
self.pyramid_type = kind;
self.pyramid_top_radius =
pyramid_display_to_circumradius(displayed_top, kind, self.pyramid_sides);
}
fn pyramid_set_base_from_point(&mut self, point: DVec3) -> bool {
let Some(frame) = self.pyramid_frame else {
return false;
};
let delta = point - frame.origin;
let planar = delta - frame.z * delta.dot(frame.z);
let displayed_radius = planar.length();
let Some(direction) = planar.try_normalize() else {
return false;
};
if !displayed_radius.is_finite() || displayed_radius < 1e-6 {
return false;
}
let x = match self.pyramid_type {
PyramidType::Inscribed => direction,
PyramidType::Circumscribed => {
let half = std::f64::consts::PI / self.pyramid_sides as f64;
direction * half.cos() - frame.z.cross(direction) * half.sin()
}
};
let Some(x) = x.try_normalize() else {
return false;
};
let Some(y) = frame.z.cross(x).try_normalize() else {
return false;
};
self.pyramid_frame = Some(WorkingPlane::new(frame.origin, x, y));
self.pyramid_base_radius = pyramid_display_to_circumradius(
displayed_radius,
self.pyramid_type,
self.pyramid_sides,
);
self.pyramid_step = PyramidStep::Height;
true
}
fn pyramid_set_base_from_edge(&mut self, first: DVec3, second: DVec3) -> bool {
let delta = second - first;
let planar = delta - self.plane.z * delta.dot(self.plane.z);
let length = planar.length();
let Some(edge) = planar.try_normalize() else {
return false;
};
if !length.is_finite() || length < 1e-6 {
return false;
}
let radius = length
/ (2.0 * (std::f64::consts::PI / self.pyramid_sides as f64).sin());
let apothem = radius * pyramid_apothem_factor(self.pyramid_sides);
let center = (first + second) * 0.5 + self.plane.z.cross(edge) * apothem;
let Some(x) = (first - center).try_normalize() else {
return false;
};
let Some(y) = self.plane.z.cross(x).try_normalize() else {
return false;
};
self.pyramid_frame = Some(WorkingPlane::new(center, x, y));
self.pyramid_base_radius = radius;
self.pyramid_step = PyramidStep::Height;
true
}
fn pyramid_axis_frame(&self, axis: DVec3) -> Option<(WorkingPlane, f64)> {
let current = self.pyramid_frame?;
let height = axis.length();
if !height.is_finite() || height < 1e-6 {
return None;
}
let z = axis / height;
let mut x = current.x - z * current.x.dot(z);
if x.length_squared() < 1e-12 {
x = current.y - z * current.y.dot(z);
}
let x = x.try_normalize()?;
let y = z.cross(x).try_normalize()?;
Some((WorkingPlane::new(current.origin, x, y), height))
}
fn pyramid_history_transform(frame: WorkingPlane) -> [f64; 16] {
glam::DMat4::from_cols(
frame.x.extend(0.0),
frame.y.extend(0.0),
frame.z.extend(0.0),
frame.origin.extend(1.0),
)
.to_cols_array()
}
fn build_pyramid(&self, axis: DVec3) -> Option<(Body, SolidHistoryOperation, f64)> {
let (frame, height) = self.pyramid_axis_frame(axis)?;
let local = solid_model::pyramid_frustum_solid(
[0.0; 3],
self.pyramid_base_radius,
self.pyramid_top_radius,
height,
self.pyramid_sides,
)?;
let placed = solid_model::placed(
&local,
frame.x.to_array(),
frame.y.to_array(),
frame.z.to_array(),
frame.origin.to_array(),
)?;
Some((
placed,
crate::scene::model::solid_history::pyramid_op(
Self::pyramid_history_transform(frame),
self.pyramid_base_radius,
self.pyramid_top_radius,
height,
self.pyramid_sides,
self.pyramid_type == PyramidType::Inscribed,
),
height,
))
}
fn commit_pyramid_axis(&self, axis: DVec3) -> CmdResult {
let Some((solid, history, height)) = self.build_pyramid(axis) else {
return CmdResult::NeedPoint;
};
if let Ok(mut defaults) = pyramid_defaults().lock() {
*defaults = PyramidDefaults {
displayed_base_radius: pyramid_circumradius_to_display(
self.pyramid_base_radius,
self.pyramid_type,
self.pyramid_sides,
),
displayed_top_radius: pyramid_circumradius_to_display(
self.pyramid_top_radius,
self.pyramid_type,
self.pyramid_sides,
),
height,
sides: self.pyramid_sides,
kind: self.pyramid_type,
};
}
let Some(document) = crate::scene::convert::acis_export::solid_to_sat(&solid) else {
return CmdResult::Cancel;
};
let mut entity = Solid3D::new();
entity.set_sat_document(&document);
entity.wires = solid_model::edge_wires(&solid);
CmdResult::CommitSolid {
entity: EntityType::Solid3D(entity),
solid: Box::new(solid),
history,
}
}
fn commit_pyramid_height(&self, height: f64) -> CmdResult {
let Some(frame) = self.pyramid_frame else {
return CmdResult::NeedPoint;
};
if !height.is_finite() || height.abs() < 1e-6 {
return CmdResult::NeedPoint;
}
self.commit_pyramid_axis(frame.z * height)
}
fn pyramid_height_at(&self, point: DVec3) -> Option<f64> {
let frame = self.pyramid_frame?;
Some((point - frame.origin).dot(frame.z))
}
fn pyramid_polygon(frame: WorkingPlane, radius: f64, sides: usize, z: f64) -> Vec<DVec3> {
(0..sides)
.map(|index| {
let angle = std::f64::consts::TAU * index as f64 / sides as f64;
frame.origin
+ frame.x * (radius * angle.cos())
+ frame.y * (radius * angle.sin())
+ frame.z * z
})
.collect()
}
fn pyramid_preview(&self, axis: DVec3) -> Option<WireModel> {
let (frame, height) = self.pyramid_axis_frame(axis)?;
let base = Self::pyramid_polygon(frame, self.pyramid_base_radius, self.pyramid_sides, 0.0);
let top = Self::pyramid_polygon(frame, self.pyramid_top_radius, self.pyramid_sides, height);
let apex = frame.origin + frame.z * height;
let mut points = Vec::new();
push_path_loop(&mut points, &base);
if self.pyramid_top_radius > 1e-9 {
push_path_loop(&mut points, &top);
}
for index in 0..self.pyramid_sides {
push_segment(
&mut points,
base[index],
if self.pyramid_top_radius > 1e-9 { top[index] } else { apex },
);
}
Some(wire("primitive_height_preview", points))
}
fn pyramid_base_preview(&self, frame: WorkingPlane, displayed_radius: f64) -> Option<WireModel> {
if !displayed_radius.is_finite() || displayed_radius < 1e-9 {
return None;
}
let radius = pyramid_display_to_circumradius(
displayed_radius,
self.pyramid_type,
self.pyramid_sides,
);
let points = Self::pyramid_polygon(frame, radius, self.pyramid_sides, 0.0);
let mut wire_points = Vec::new();
push_path_loop(&mut wire_points, &points);
Some(wire("primitive_preview", wire_points))
}
fn pyramid_prompt(&self) -> String {
let base_default = self.pyramid_defaults.displayed_base_radius;
let top_default = self.pyramid_defaults.displayed_top_radius;
match self.pyramid_step {
PyramidStep::BaseCenter => crate::tf!(
"PYRAMID Specify center point of base or [Edge/Sides]:"
).into_owned(),
PyramidStep::Sides => crate::tf!(
"PYRAMID Enter number of sides <{}>:",
self.pyramid_sides
).into_owned(),
PyramidStep::EdgeFirst => t!("PYRAMID Specify first endpoint of edge:").into_owned(),
PyramidStep::EdgeSecond => t!("PYRAMID Specify second endpoint of edge:").into_owned(),
PyramidStep::BaseRadius => match self.pyramid_type {
PyramidType::Circumscribed => crate::tf!(
"PYRAMID Specify base radius or [Inscribed] <{:.4}>:",
base_default
).into_owned(),
PyramidType::Inscribed => crate::tf!(
"PYRAMID Specify base radius or [Circumscribed] <{:.4}>:",
base_default
).into_owned(),
},
PyramidStep::Height => crate::tf!(
"PYRAMID Specify height or [2Point/Axis endpoint/Top radius] <{:.4}>:",
self.pyramid_defaults.height
).into_owned(),
PyramidStep::HeightAfterTopRadius => crate::tf!(
"PYRAMID Specify height or [2Point/Axis endpoint] <{:.4}>:",
self.pyramid_defaults.height
).into_owned(),
PyramidStep::HeightFirstPoint => t!("PYRAMID Specify first point for height:").into_owned(),
PyramidStep::HeightSecondPoint => t!("PYRAMID Specify second point for height:").into_owned(),
PyramidStep::AxisEndpoint => t!("PYRAMID Specify axis endpoint:").into_owned(),
PyramidStep::TopRadius => crate::tf!(
"PYRAMID Specify top radius <{:.4}>:",
top_default
).into_owned(),
}
}
fn pyramid_options(&self) -> Vec<CmdOption> {
match self.pyramid_step {
PyramidStep::BaseCenter => vec![
CmdOption::new(t!("Edge").as_ref(), "E"),
CmdOption::new(t!("Sides").as_ref(), "S"),
],
PyramidStep::BaseRadius => vec![match self.pyramid_type {
PyramidType::Circumscribed => CmdOption::new(t!("Inscribed").as_ref(), "I"),
PyramidType::Inscribed => CmdOption::new(t!("Circumscribed").as_ref(), "C"),
}],
PyramidStep::Height => vec![
CmdOption::new("2Point", "2P"),
CmdOption::new(t!("Axis endpoint").as_ref(), "A"),
CmdOption::new(t!("Top radius").as_ref(), "T"),
],
PyramidStep::HeightAfterTopRadius => vec![
CmdOption::new("2Point", "2P"),
CmdOption::new(t!("Axis endpoint").as_ref(), "A"),
],
_ => Vec::new(),
}
}
fn on_pyramid_point(&mut self, point: DVec3) -> CmdResult {
match self.pyramid_step {
PyramidStep::BaseCenter => {
self.pyramid_frame = Some(self.pyramid_frame_at(point));
self.pyramid_step = PyramidStep::BaseRadius;
CmdResult::NeedPoint
}
PyramidStep::EdgeFirst => {
self.pyramid_edge_first = Some(point);
self.pyramid_step = PyramidStep::EdgeSecond;
CmdResult::NeedPoint
}
PyramidStep::EdgeSecond => {
if let Some(first) = self.pyramid_edge_first {
self.pyramid_set_base_from_edge(first, point);
}
CmdResult::NeedPoint
}
PyramidStep::BaseRadius => {
self.pyramid_set_base_from_point(point);
CmdResult::NeedPoint
}
PyramidStep::Height | PyramidStep::HeightAfterTopRadius => self
.pyramid_height_at(point)
.map(|height| self.commit_pyramid_height(height))
.unwrap_or(CmdResult::NeedPoint),
PyramidStep::HeightFirstPoint => {
self.pyramid_height_first = Some(point);
self.pyramid_step = PyramidStep::HeightSecondPoint;
CmdResult::NeedPoint
}
PyramidStep::HeightSecondPoint => self
.pyramid_height_first
.map(|first| self.commit_pyramid_height(first.distance(point)))
.unwrap_or(CmdResult::NeedPoint),
PyramidStep::AxisEndpoint => {
let Some(frame) = self.pyramid_frame else {
return CmdResult::NeedPoint;
};
self.commit_pyramid_axis(point - frame.origin)
}
PyramidStep::TopRadius => {
let Some(frame) = self.pyramid_frame else {
return CmdResult::NeedPoint;
};
let delta = point - frame.origin;
let displayed = (delta - frame.z * delta.dot(frame.z)).length();
if displayed.is_finite() {
self.pyramid_top_radius = pyramid_display_to_circumradius(
displayed,
self.pyramid_type,
self.pyramid_sides,
);
self.pyramid_step = PyramidStep::HeightAfterTopRadius;
}
CmdResult::NeedPoint
}
PyramidStep::Sides => CmdResult::NeedPoint,
}
}
fn on_pyramid_text(&mut self, raw: &str) -> Option<CmdResult> {
let token = raw.trim();
let upper = token.to_uppercase();
match self.pyramid_step {
PyramidStep::BaseCenter => {
self.pyramid_step = match upper.as_str() {
"E" | "EDGE" => PyramidStep::EdgeFirst,
"S" | "SIDES" => PyramidStep::Sides,
_ => return None,
};
return Some(CmdResult::NeedPoint);
}
PyramidStep::BaseRadius if matches!(upper.as_str(), "I" | "INSCRIBED") => {
self.set_pyramid_type(PyramidType::Inscribed);
return Some(CmdResult::NeedPoint);
}
PyramidStep::BaseRadius if matches!(upper.as_str(), "C" | "CIRCUMSCRIBED") => {
self.set_pyramid_type(PyramidType::Circumscribed);
return Some(CmdResult::NeedPoint);
}
PyramidStep::Height => {
self.pyramid_step = match upper.as_str() {
"2P" | "2POINT" => PyramidStep::HeightFirstPoint,
"A" | "AXIS" | "AXIS ENDPOINT" => PyramidStep::AxisEndpoint,
"T" | "TOP" | "TOP RADIUS" => PyramidStep::TopRadius,
_ => {
let height = crate::entities::common::parse_typed_length(token)?;
return Some(self.commit_pyramid_height(height));
}
};
return Some(CmdResult::NeedPoint);
}
PyramidStep::HeightAfterTopRadius => {
self.pyramid_step = match upper.as_str() {
"2P" | "2POINT" => PyramidStep::HeightFirstPoint,
"A" | "AXIS" | "AXIS ENDPOINT" => PyramidStep::AxisEndpoint,
_ => {
let height = crate::entities::common::parse_typed_length(token)?;
return Some(self.commit_pyramid_height(height));
}
};
return Some(CmdResult::NeedPoint);
}
PyramidStep::Sides => {
let sides = token.parse::<usize>().ok()?;
if !(3..=32).contains(&sides) {
return None;
}
let displayed_top = pyramid_circumradius_to_display(
self.pyramid_top_radius,
self.pyramid_type,
self.pyramid_sides,
);
self.pyramid_sides = sides;
self.pyramid_top_radius = pyramid_display_to_circumradius(
displayed_top,
self.pyramid_type,
self.pyramid_sides,
);
self.pyramid_defaults.sides = sides;
self.pyramid_step = PyramidStep::BaseCenter;
return Some(CmdResult::NeedPoint);
}
_ => {}
}
let number = crate::entities::common::parse_typed_length(token)?;
match self.pyramid_step {
PyramidStep::BaseRadius if number > 0.0 => {
let frame = self.pyramid_frame?;
self.pyramid_set_base_from_point(frame.origin + frame.x * number)
.then_some(CmdResult::NeedPoint)
}
PyramidStep::TopRadius if number >= 0.0 => {
self.pyramid_top_radius = pyramid_display_to_circumradius(
number,
self.pyramid_type,
self.pyramid_sides,
);
self.pyramid_step = PyramidStep::HeightAfterTopRadius;
Some(CmdResult::NeedPoint)
}
_ => None,
}
}
fn pyramid_mouse_move(&self, point: DVec3) -> Option<WireModel> {
match self.pyramid_step {
PyramidStep::EdgeSecond => {
let first = self.pyramid_edge_first?;
let mut preview = PrimitiveCommand::new("PYRAMID");
preview.plane = self.plane;
preview.pyramid_sides = self.pyramid_sides;
preview.pyramid_type = self.pyramid_type;
preview.pyramid_set_base_from_edge(first, point);
let frame = preview.pyramid_frame?;
preview.pyramid_base_preview(
frame,
pyramid_circumradius_to_display(
preview.pyramid_base_radius,
preview.pyramid_type,
preview.pyramid_sides,
),
)
}
PyramidStep::BaseRadius => {
let frame = self.pyramid_frame?;
let delta = point - frame.origin;
let planar = delta - frame.z * delta.dot(frame.z);
let displayed = planar.length();
let direction = planar.try_normalize()?;
let x = match self.pyramid_type {
PyramidType::Inscribed => direction,
PyramidType::Circumscribed => {
let half = std::f64::consts::PI / self.pyramid_sides as f64;
direction * half.cos() - frame.z.cross(direction) * half.sin()
}
}
.try_normalize()?;
let y = frame.z.cross(x).try_normalize()?;
self.pyramid_base_preview(WorkingPlane::new(frame.origin, x, y), displayed)
}
PyramidStep::Height | PyramidStep::HeightAfterTopRadius => {
let frame = self.pyramid_frame?;
self.pyramid_preview(frame.z * self.pyramid_height_at(point)?)
}
PyramidStep::HeightSecondPoint => {
let frame = self.pyramid_frame?;
self.pyramid_preview(frame.z * self.pyramid_height_first?.distance(point))
}
PyramidStep::AxisEndpoint => {
let frame = self.pyramid_frame?;
self.pyramid_preview(point - frame.origin)
}
_ => None,
}
}
/// Number of footprint points the shape needs before the height step.
fn footprint_pts(&self) -> usize {
match self.shape {
Shape::Torus => 3, // centre, major-radius, minor-radius
_ => 2, // corner/corner or centre/radius
}
}
/// A reasonable default height when the user just presses Enter.
fn default_height(&self) -> f64 {
if self.shape == Shape::Wedge {
let bits = LAST_WEDGE_HEIGHT.load(Ordering::Relaxed);
if bits != 0 {
let height = f64::from_bits(bits);
if height.is_finite() && height >= 1e-6 {
return height;
}
}
}
let height = match self.shape {
Shape::Box | Shape::Wedge => match (self.box_length, self.box_width) {
(Some(length), Some(width)) => length.max(width),
_ if self.pts.len() >= 2 => {
let d = self.pts[1] - self.pts[0];
d.x.abs().max(d.y.abs())
}
_ => 1.0,
},
_ if self.pts.len() >= 2 => (self.pts[1] - self.pts[0]).length(),
_ => 1.0,
};
height.max(1.0)
}
fn cursor_height(&self, point: DVec3) -> f64 {
let height = self.plane.to_local(point).z - self.pts[0].z;
if self.shape.rectangular() {
height
} else {
height.max(1e-6)
}
}
fn place_preview(&self, mut preview: WireModel) -> WireModel {
for point in &mut preview.points {
if !point[0].is_nan() {
*point = self
.plane
.to_world(glam::Vec3::from_array(*point).as_dvec3())
.as_vec3()
.to_array();
}
}
preview
}
fn history_transform(&self, origin: DVec3) -> [f64; 16] {
glam::DMat4::from_cols(
self.plane.x.extend(0.0),
self.plane.y.extend(0.0),
self.plane.z.extend(0.0),
self.plane.to_world(origin).extend(1.0),
)
.to_cols_array()
}
fn history_transform_axes(
&self,
origin: DVec3,
x_axis: DVec3,
y_axis: DVec3,
) -> [f64; 16] {
let to_world_vector = |value: DVec3| {
self.plane.x * value.x + self.plane.y * value.y + self.plane.z * value.z
};
glam::DMat4::from_cols(
to_world_vector(x_axis).extend(0.0),
to_world_vector(y_axis).extend(0.0),
self.plane.z.extend(0.0),
self.plane.to_world(origin).extend(1.0),
)
.to_cols_array()
}
fn box_spec(&self, height: f64) -> Option<(DVec3, DVec3, DVec3, f64, f64, f64)> {
let (mut origin, x_axis, y_axis, length, width) =
if let (Some(origin), Some(length), Some(width)) =
(self.box_origin, self.box_length, self.box_width)
{
let (sin, cos) = self.box_angle.sin_cos();
(
origin,
DVec3::new(cos, sin, 0.0),
DVec3::new(-sin, cos, 0.0) * self.box_width_sign,
length,
width,
)
} else {
let (a, b) = (*self.pts.first()?, *self.pts.get(1)?);
(
DVec3::new(a.x.min(b.x), a.y.min(b.y), a.z),
DVec3::X,
DVec3::Y,
(b.x - a.x).abs(),
(b.y - a.y).abs(),
)
};
let height_abs = height.abs();
if !origin.is_finite()
|| !x_axis.is_finite()
|| !y_axis.is_finite()
|| !length.is_finite()
|| !width.is_finite()
|| !height_abs.is_finite()
|| length < 1e-6
|| width < 1e-6
|| height_abs < 1e-6
{
return None;
}
if height < 0.0 {
origin.z += height;
}
if !origin.is_finite() {
return None;
}
Some((origin, x_axis, y_axis, length, width, height_abs))
}
fn build_box(&self, height: f64) -> Option<(Body, SolidHistoryOperation)> {
use crate::scene::model::solid_history;
let (origin, x_axis, y_axis, length, width, height) = self.box_spec(height)?;
let base = solid_model::box_solid(
[length * 0.5, width * 0.5, height * 0.5],
length,
width,
height,
)?;
let placed = solid_model::placed(
&base,
x_axis.to_array(),
y_axis.to_array(),
DVec3::Z.to_array(),
origin.to_array(),
)?;
Some((
placed,
solid_history::box_op(
self.history_transform_axes(origin, x_axis, y_axis),
length,
width,
height,
),
))
}
fn set_box_corner_footprint(&mut self, point: DVec3) -> bool {
let first = self.pts[0];
let delta = point - first;
if delta.x.abs() < 1e-6 || delta.y.abs() < 1e-6 {
return false;
}
if self.box_centered {
self.pts = vec![
DVec3::new(first.x - delta.x.abs(), first.y - delta.y.abs(), first.z),
DVec3::new(first.x + delta.x.abs(), first.y + delta.y.abs(), first.z),
];
} else {
self.pts.push(point);
}
self.box_step = BoxStep::Height;
self.height_step = true;
true
}
fn set_box_cube(&mut self, size: f64, angle: f64) -> Option<CmdResult> {
let size = size.abs();
if !size.is_finite() || !angle.is_finite() || size < 1e-6 {
return None;
}
let (sin, cos) = angle.sin_cos();
let x_axis = DVec3::new(cos, sin, 0.0);
let y_axis = DVec3::new(-sin, cos, 0.0);
let origin = if self.box_centered {
self.pts[0] - x_axis * size * 0.5 - y_axis * size * 0.5
} else {
self.pts[0]
};
self.box_origin = Some(origin);
self.box_length = Some(size);
self.box_width = Some(size);
self.box_angle = angle;
self.box_width_sign = 1.0;
Some(self.commit(size))
}
fn set_box_length(&mut self, length: f64, angle: f64) -> bool {
let length = length.abs();
if !length.is_finite() || !angle.is_finite() || length < 1e-6 {
return false;
}
self.box_origin = self.pts.first().copied();
self.box_length = Some(length);
self.box_angle = angle;
self.box_step = BoxStep::Width;
true
}
fn set_box_width(&mut self, width: f64, sign: f64) -> bool {
let width = width.abs();
if !width.is_finite() || !sign.is_finite() || width < 1e-6 {
return false;
}
self.box_width = Some(width);
self.box_width_sign = if sign < 0.0 { -1.0 } else { 1.0 };
if self.box_centered {
let center = self.pts[0];
let (sin, cos) = self.box_angle.sin_cos();
let x_axis = DVec3::new(cos, sin, 0.0);
let y_axis = DVec3::new(-sin, cos, 0.0) * self.box_width_sign;
self.box_origin = Some(
center
- x_axis * self.box_length.unwrap_or_default() * 0.5
- y_axis * width * 0.5,
);
}
self.box_step = BoxStep::Height;
self.height_step = true;
true
}
fn rectangular_preview(&self, height: f64) -> Option<WireModel> {
let (origin, x_axis, y_axis, length, width, height) = self.box_spec(height)?;
let mut points = Vec::new();
if self.shape == Shape::Wedge {
let near = [
origin,
origin + x_axis * length,
origin + DVec3::Z * height,
];
let far = near.map(|point| point + y_axis * width);
push_loop(&mut points, &near);
push_loop(&mut points, &far);
for index in 0..3 {
push_segment(&mut points, near[index], far[index]);
}
} else {
let base = [
origin,
origin + x_axis * length,
origin + x_axis * length + y_axis * width,
origin + y_axis * width,
];
let top = base.map(|point| point + DVec3::Z * height);
push_loop(&mut points, &base);
push_loop(&mut points, &top);
for index in 0..4 {
push_segment(&mut points, base[index], top[index]);
}
}
Some(self.place_preview(wire("primitive_height_preview", points)))
}
fn build_wedge(&self, height: f64) -> Option<(Body, SolidHistoryOperation)> {
use crate::scene::model::solid_history;
let (origin, x_axis, y_axis, length, width, height) = self.box_spec(height)?;
let base = solid_model::wedge_solid([0.0; 3], length, width, height)?;
let placed = solid_model::placed(
&base,
x_axis.to_array(),
y_axis.to_array(),
DVec3::Z.to_array(),
origin.to_array(),
)?;
Some((
placed,
solid_history::wedge_op(
self.history_transform_axes(origin, x_axis, y_axis),
length,
width,
height,
),
))
}
/// Build the persistent kernel body and its history node.
fn build(&self, height: f64) -> Option<(Body, SolidHistoryOperation)> {
use crate::scene::model::solid_history;
let (solid, history) = match self.shape {
Shape::Box => return self.build_box(height),
Shape::Wedge => return self.build_wedge(height),
Shape::Cylinder => {
let c = self.pts[0];
let r = (self.pts[1] - c).length();
if r < 1e-6 || height < 1e-6 {
return None;
}
let center = [c.x, c.y, c.z];
(
solid_model::cylinder_solid(center, r, height),
solid_history::cylinder_op(self.history_transform(c), r, height),
)
}
Shape::Cone => return None,
Shape::Sphere => {
let c = self.pts[0];
let r = (self.pts[1] - c).length();
if r < 1e-6 {
return None;
}
let center = [c.x, c.y, c.z];
(
solid_model::sphere_solid(center, r),
solid_history::sphere_op(self.history_transform(c), r),
)
}
Shape::Pyramid => return None,
Shape::Torus => {
let c = self.pts[0];
let first = (self.pts[1] - c).length();
let second = (self.pts[2] - c).length();
let outer = first.max(second);
let inner = first.min(second);
if inner < 1e-6 || outer - inner < 1e-6 {
return None;
}
let major = (outer + inner) * 0.5;
let minor = (outer - inner) * 0.5;
let center = [c.x, c.y, c.z];
(
solid_model::torus_solid(center, major, minor),
solid_history::torus_op(
self.history_transform(c),
major,
minor,
),
)
}
};
let solid = solid?;
Some((solid, history))
}
fn commit(&self, height: f64) -> CmdResult {
match self.build(height) {
Some((solid, history)) => {
if self.shape == Shape::Wedge {
LAST_WEDGE_HEIGHT.store(height.abs().to_bits(), Ordering::Relaxed);
}
// Place the local body on the working plane.
let placed = solid_model::placed(
&solid,
[self.plane.x.x, self.plane.x.y, self.plane.x.z],
[self.plane.y.x, self.plane.y.y, self.plane.y.z],
[self.plane.z.x, self.plane.z.y, self.plane.z.z],
[
self.plane.origin.x,
self.plane.origin.y,
self.plane.origin.z,
],
);
match placed {
Some(placed) => {
let Some(document) =
crate::scene::convert::acis_export::solid_to_sat(&placed)
else {
return CmdResult::Cancel;
};
let mut entity = Solid3D::new();
entity.set_sat_document(&document);
entity.wires = solid_model::edge_wires(&placed);
CmdResult::CommitSolid {
entity: EntityType::Solid3D(entity),
solid: Box::new(placed),
history,
}
}
None => CmdResult::Cancel,
}
}
None => CmdResult::Cancel,
}
}
}
impl CadCommand for PrimitiveCommand {
fn set_working_plane(&mut self, plane: WorkingPlane) {
self.plane = plane;
}
fn cursor_axis(&self) -> Option<(DVec3, DVec3)> {
if self.shape == Shape::Cone {
return matches!(self.cone_step, ConeStep::Height | ConeStep::HeightAfterTopRadius)
.then(|| {
let frame = self.cone_frame.unwrap_or(self.plane);
(frame.origin, frame.z.normalize_or_zero())
});
}
if self.shape == Shape::Pyramid {
return matches!(
self.pyramid_step,
PyramidStep::Height | PyramidStep::HeightAfterTopRadius
)
.then(|| {
let frame = self.pyramid_frame.unwrap_or(self.plane);
(frame.origin, frame.z.normalize_or_zero())
});
}
let constrained = if self.shape.rectangular() {
self.box_step == BoxStep::Height
} else {
self.height_step
};
constrained.then(|| {
(
self.plane.to_world(self.pts[0]),
self.plane.z.normalize_or_zero(),
)
})
}
fn name(&self) -> &'static str {
self.shape.name()
}
fn needs_tangent_pick(&self) -> bool {
(self.shape == Shape::Sphere
&& matches!(
self.sphere_step,
SphereStep::TtrFirst | SphereStep::TtrSecond { .. }
))
|| (self.shape == Shape::Cone
&& matches!(
self.cone_step,
ConeStep::TtrFirst | ConeStep::TtrSecond { .. }
))
}
fn on_tangent_point(&mut self, object: TangentObject, hit: DVec3) -> CmdResult {
if self.shape == Shape::Cone {
return self.on_cone_tangent(object, hit);
}
if self.shape != Shape::Sphere {
return self.on_point(hit);
}
let object = sphere_tangent_local(object, self.plane);
let hit = self.plane.to_local(hit);
match self.sphere_step {
SphereStep::TtrFirst => {
self.sphere_step = SphereStep::TtrSecond { object, hit };
CmdResult::NeedPoint
}
SphereStep::TtrSecond {
object: first,
hit: first_hit,
} => {
self.sphere_step = SphereStep::TtrRadius {
first,
second: object,
first_hit,
second_hit: hit,
};
CmdResult::NeedPoint
}
_ => CmdResult::NeedPoint,
}
}
fn prompt(&self) -> String {
let n = self.shape.name();
if self.shape == Shape::Cone {
return self.cone_prompt();
}
if self.shape == Shape::Pyramid {
return self.pyramid_prompt();
}
if self.shape.rectangular() {
return match self.box_step {
BoxStep::FirstCorner => t!("%{n} Specify first corner or [Center]:", n = n),
BoxStep::CenterPoint => t!("%{n} Specify center point:", n = n),
BoxStep::OppositeCorner => {
t!("%{n} Specify other corner or [Cube/Length]:", n = n)
}
BoxStep::CubeSize => t!("%{n} Specify cube length:", n = n),
BoxStep::Length => t!("%{n} Specify length:", n = n),
BoxStep::Width => t!("%{n} Specify width:", n = n),
BoxStep::Height if self.shape == Shape::Wedge => t!(
"%{n} Specify height or [2Point] <%{height}>:",
n = n,
height = format!("{:.4}", self.default_height())
),
BoxStep::Height => t!("%{n} Specify height or [2Point]:", n = n),
BoxStep::HeightFirstPoint => {
t!("%{n} Specify first point for height:", n = n)
}
BoxStep::HeightSecondPoint => {
t!("%{n} Specify second point for height:", n = n)
}
}
.into_owned();
}
if self.shape == Shape::Sphere {
return match self.sphere_step {
SphereStep::Center => {
t!("SPHERE Specify center point or [3P/2P/Ttr]:").into_owned()
}
SphereStep::Radius(_) => crate::tf!(
"SPHERE Specify radius or [Diameter] <{:.4}>:",
self.sphere_default_radius
)
.into_owned(),
SphereStep::Diameter(_) => crate::tf!(
"SPHERE Specify diameter <{:.4}>:",
self.sphere_default_radius * 2.0
)
.into_owned(),
SphereStep::TwoPointFirst => {
t!("SPHERE Specify first end point of diameter:").into_owned()
}
SphereStep::TwoPointSecond(_) => {
t!("SPHERE Specify second end point of diameter:").into_owned()
}
SphereStep::ThreePointFirst => {
t!("SPHERE Specify first point on sphere:").into_owned()
}
SphereStep::ThreePointSecond(_) => {
t!("SPHERE Specify second point on sphere:").into_owned()
}
SphereStep::ThreePointThird(_, _) => {
t!("SPHERE Specify third point on sphere:").into_owned()
}
SphereStep::TtrFirst => {
t!("SPHERE Select first tangent object:").into_owned()
}
SphereStep::TtrSecond { .. } => {
t!("SPHERE Select second tangent object:").into_owned()
}
SphereStep::TtrRadius { .. } => crate::tf!(
"SPHERE Specify radius <{:.4}>:",
self.sphere_default_radius
)
.into_owned(),
};
}
if self.height_step {
return t!("%{n} Specify height <Enter for default>:", n = n).into_owned();
}
match (self.shape, self.pts.len()) {
(Shape::Torus, 0) => t!("%{n} Specify center point:", n = n).into_owned(),
(Shape::Torus, 1) => t!("%{n} Specify outer radius:", n = n).into_owned(),
(Shape::Torus, _) => t!("%{n} Specify inner radius:", n = n).into_owned(),
(shape, 0) if shape.radial() => {
t!("%{n} Specify center point:", n = n).into_owned()
}
(shape, _) if shape.radial() => {
t!("%{n} Specify radius:", n = n).into_owned()
}
(_, 0) => t!("%{n} Specify first corner:", n = n).into_owned(),
(_, _) => t!("%{n} Specify opposite corner:", n = n).into_owned(),
}
}
fn options(&self) -> Vec<CmdOption> {
if self.shape == Shape::Sphere {
return match self.sphere_step {
SphereStep::Center => vec![
CmdOption::new("3P", "3P"),
CmdOption::new("2P", "2P"),
CmdOption::new("Ttr", "T"),
],
SphereStep::Radius(_) => vec![CmdOption::new(t!("Diameter").as_ref(), "D")],
_ => Vec::new(),
};
}
if self.shape == Shape::Cone {
return self.cone_options();
}
if self.shape == Shape::Pyramid {
return self.pyramid_options();
}
if !self.shape.rectangular() {
return Vec::new();
}
match self.box_step {
BoxStep::FirstCorner => vec![CmdOption::new(t!("Center").as_ref(), "C")],
BoxStep::OppositeCorner => vec![
CmdOption::new(t!("Cube").as_ref(), "C"),
CmdOption::new(t!("Length").as_ref(), "L"),
],
BoxStep::Height => vec![CmdOption::new(t!("2Point").as_ref(), "2P")],
_ => Vec::new(),
}
}
fn on_point(&mut self, pt: DVec3) -> CmdResult {
if self.shape == Shape::Sphere {
let local = self.plane.to_local(pt);
if !local.is_finite() {
return CmdResult::NeedPoint;
}
return match self.sphere_step {
SphereStep::Center => {
self.sphere_step = SphereStep::Radius(local);
CmdResult::NeedPoint
}
SphereStep::Radius(center) => self.commit_sphere(center, center.distance(local)),
SphereStep::Diameter(center) => {
self.commit_sphere(center, center.distance(local) * 0.5)
}
SphereStep::TwoPointFirst => {
self.sphere_step = SphereStep::TwoPointSecond(local);
CmdResult::NeedPoint
}
SphereStep::TwoPointSecond(first) => {
self.commit_sphere((first + local) * 0.5, first.distance(local) * 0.5)
}
SphereStep::ThreePointFirst => {
self.sphere_step = SphereStep::ThreePointSecond(local);
CmdResult::NeedPoint
}
SphereStep::ThreePointSecond(first) => {
self.sphere_step = SphereStep::ThreePointThird(first, local);
CmdResult::NeedPoint
}
SphereStep::ThreePointThird(first, second) => {
let Some((center, radius)) =
sphere_through_three_points(first, second, local)
else {
return CmdResult::NeedPoint;
};
self.commit_sphere(center, radius)
}
SphereStep::TtrRadius { second_hit, .. } => {
self.sphere_ttr_result(second_hit.distance(local))
}
SphereStep::TtrFirst | SphereStep::TtrSecond { .. } => CmdResult::NeedPoint,
};
}
if self.shape == Shape::Cone {
return self.on_cone_point(pt);
}
if self.shape == Shape::Pyramid {
return self.on_pyramid_point(pt);
}
if self.shape.rectangular() {
let local = self.plane.to_local(pt);
if !local.is_finite() {
return CmdResult::NeedPoint;
}
return match self.box_step {
BoxStep::FirstCorner | BoxStep::CenterPoint => {
self.pts = vec![local];
self.box_step = BoxStep::OppositeCorner;
CmdResult::NeedPoint
}
BoxStep::OppositeCorner => {
let height = local.z - self.pts[0].z;
if !self.set_box_corner_footprint(local) {
CmdResult::NeedPoint
} else if self.shape == Shape::Wedge && height.abs() >= 1e-6 {
self.commit(height)
} else {
CmdResult::NeedPoint
}
}
BoxStep::CubeSize => {
let delta = local - self.pts[0];
let (size, angle) = if self.shape == Shape::Wedge {
(delta.x.hypot(delta.y), delta.y.atan2(delta.x))
} else {
(delta.length(), 0.0)
};
self.set_box_cube(size, angle)
.unwrap_or(CmdResult::NeedPoint)
}
BoxStep::Length => {
let delta = local - self.pts[0];
if !self.set_box_length(delta.x.hypot(delta.y), delta.y.atan2(delta.x)) {
return CmdResult::NeedPoint;
}
CmdResult::NeedPoint
}
BoxStep::Width => {
let delta = local - self.pts[0];
let normal = DVec3::new(-self.box_angle.sin(), self.box_angle.cos(), 0.0);
let signed = delta.dot(normal);
if !self.set_box_width(signed, signed) {
return CmdResult::NeedPoint;
}
CmdResult::NeedPoint
}
BoxStep::Height => {
let height = self.cursor_height(pt);
if height.abs() < 1e-6 {
CmdResult::NeedPoint
} else {
self.commit(height)
}
}
BoxStep::HeightFirstPoint => {
self.box_height_anchor = Some(local);
self.box_step = BoxStep::HeightSecondPoint;
CmdResult::NeedPoint
}
BoxStep::HeightSecondPoint => {
let Some(first) = self.box_height_anchor else {
return CmdResult::NeedPoint;
};
let height = (local - first).length();
if height < 1e-6 {
CmdResult::NeedPoint
} else {
self.commit(height)
}
}
};
}
if self.height_step {
return self.commit(self.cursor_height(pt));
}
self.pts.push(self.plane.to_local(pt));
if self.pts.len() < self.footprint_pts() {
return CmdResult::NeedPoint;
}
// Footprint complete.
if self.shape.needs_height() {
self.height_step = true;
CmdResult::NeedPoint
} else {
self.commit(0.0)
}
}
fn on_enter(&mut self) -> CmdResult {
if self.shape == Shape::Sphere {
return match self.sphere_step {
SphereStep::Radius(center) => {
self.commit_sphere(center, self.sphere_default_radius)
}
SphereStep::Diameter(center) => {
self.commit_sphere(center, self.sphere_default_radius)
}
SphereStep::TtrRadius { .. } => {
self.sphere_ttr_result(self.sphere_default_radius)
}
_ => CmdResult::Cancel,
};
}
if self.shape == Shape::Cone {
return match self.cone_step {
ConeStep::BaseRadius | ConeStep::BaseDiameter => {
let Some(frame) = self.cone_frame else {
return CmdResult::Cancel;
};
self.set_cone_base(
frame,
self.cone_defaults.base_x_radius,
self.cone_defaults.base_y_radius,
);
CmdResult::NeedPoint
}
ConeStep::TtrRadius { .. } => {
let radius = self.cone_defaults.base_x_radius;
let Some(center) = self.cone_ttr_center(radius) else {
return CmdResult::NeedPoint;
};
self.set_cone_base(self.cone_frame_at(center), radius, radius);
CmdResult::NeedPoint
}
ConeStep::EllipseCenterFirstAxis(center) => {
self.cone_step = ConeStep::EllipseCenterSecondAxis(
center,
center + self.plane.x * self.cone_defaults.base_x_radius,
);
CmdResult::NeedPoint
}
ConeStep::Height | ConeStep::HeightAfterTopRadius => {
self.commit_cone_height(self.cone_defaults.height)
}
ConeStep::TopRadius => {
self.cone_top_radius = self.cone_defaults.top_radius;
self.cone_step = ConeStep::HeightAfterTopRadius;
CmdResult::NeedPoint
}
_ => CmdResult::Cancel,
};
}
if self.shape == Shape::Pyramid {
return match self.pyramid_step {
PyramidStep::Sides => {
self.pyramid_step = PyramidStep::BaseCenter;
CmdResult::NeedPoint
}
PyramidStep::BaseRadius => {
let displayed = self.pyramid_defaults.displayed_base_radius;
let Some(frame) = self.pyramid_frame else {
return CmdResult::Cancel;
};
self.pyramid_set_base_from_point(frame.origin + frame.x * displayed);
CmdResult::NeedPoint
}
PyramidStep::Height | PyramidStep::HeightAfterTopRadius => {
self.commit_pyramid_height(self.pyramid_defaults.height)
}
PyramidStep::TopRadius => {
self.pyramid_top_radius = pyramid_display_to_circumradius(
self.pyramid_defaults.displayed_top_radius,
self.pyramid_type,
self.pyramid_sides,
);
self.pyramid_step = PyramidStep::HeightAfterTopRadius;
CmdResult::NeedPoint
}
_ => CmdResult::Cancel,
};
}
if self.shape.rectangular() {
return if self.shape == Shape::Wedge && self.box_step == BoxStep::Height {
self.commit(self.default_height())
} else {
CmdResult::Cancel
};
}
if self.height_step {
let h = self.default_height();
return self.commit(h);
}
CmdResult::Cancel
}
fn on_escape(&mut self) -> CmdResult {
CmdResult::Cancel
}
fn wants_text_input(&self) -> bool {
if self.shape == Shape::Sphere {
return matches!(
self.sphere_step,
SphereStep::Center
| SphereStep::Radius(_)
| SphereStep::Diameter(_)
| SphereStep::TtrRadius { .. }
);
}
if self.shape == Shape::Cone {
return matches!(
self.cone_step,
ConeStep::BaseCenter
| ConeStep::BaseRadius
| ConeStep::BaseDiameter
| ConeStep::EllipseFirst
| ConeStep::EllipseCenterFirstAxis(_)
| ConeStep::TtrRadius { .. }
| ConeStep::Height
| ConeStep::HeightAfterTopRadius
| ConeStep::TopRadius
);
}
if self.shape == Shape::Pyramid {
return matches!(
self.pyramid_step,
PyramidStep::BaseCenter
| PyramidStep::Sides
| PyramidStep::BaseRadius
| PyramidStep::Height
| PyramidStep::HeightAfterTopRadius
| PyramidStep::TopRadius
);
}
if self.shape.rectangular() {
matches!(
self.box_step,
BoxStep::FirstCorner
| BoxStep::OppositeCorner
| BoxStep::CubeSize
| BoxStep::Length
| BoxStep::Width
| BoxStep::Height
)
} else {
self.height_step
}
}
fn point_step_accepts_keywords(&self) -> bool {
if self.shape == Shape::Sphere {
return matches!(self.sphere_step, SphereStep::Center | SphereStep::Radius(_));
}
if self.shape == Shape::Cone {
return matches!(
self.cone_step,
ConeStep::BaseCenter
| ConeStep::BaseRadius
| ConeStep::EllipseFirst
| ConeStep::Height
| ConeStep::HeightAfterTopRadius
);
}
if self.shape == Shape::Pyramid {
return matches!(
self.pyramid_step,
PyramidStep::BaseCenter
| PyramidStep::BaseRadius
| PyramidStep::Height
| PyramidStep::HeightAfterTopRadius
);
}
self.shape.rectangular()
&& matches!(
self.box_step,
BoxStep::FirstCorner | BoxStep::OppositeCorner | BoxStep::Height
)
}
fn on_text_input(&mut self, raw: &str) -> Option<CmdResult> {
if self.shape == Shape::Sphere {
let token = raw.trim();
let upper = token.to_uppercase();
return match self.sphere_step {
SphereStep::Center if upper == "3P" => {
self.sphere_step = SphereStep::ThreePointFirst;
Some(CmdResult::NeedPoint)
}
SphereStep::Center if upper == "2P" => {
self.sphere_step = SphereStep::TwoPointFirst;
Some(CmdResult::NeedPoint)
}
SphereStep::Center if matches!(upper.as_str(), "T" | "TTR") => {
self.sphere_step = SphereStep::TtrFirst;
Some(CmdResult::NeedPoint)
}
SphereStep::Radius(_) if matches!(upper.as_str(), "D" | "DIAMETER") => {
let SphereStep::Radius(center) = self.sphere_step else {
unreachable!();
};
self.sphere_step = SphereStep::Diameter(center);
Some(CmdResult::NeedPoint)
}
SphereStep::Radius(center) => {
let radius = crate::entities::common::parse_typed_length(token)?;
Some(self.commit_sphere(center, radius))
}
SphereStep::Diameter(center) => {
let diameter = crate::entities::common::parse_typed_length(token)?;
Some(self.commit_sphere(center, diameter * 0.5))
}
SphereStep::TtrRadius { .. } => {
let radius = crate::entities::common::parse_typed_length(token)?;
Some(self.sphere_ttr_result(radius))
}
_ => None,
};
}
if self.shape == Shape::Cone {
return self.on_cone_text(raw);
}
if self.shape == Shape::Pyramid {
return self.on_pyramid_text(raw);
}
if self.shape.rectangular() {
let token = raw.trim();
let upper = token.to_uppercase();
return match self.box_step {
BoxStep::FirstCorner if matches!(upper.as_str(), "C" | "CENTER") => {
self.box_centered = true;
self.box_step = BoxStep::CenterPoint;
Some(CmdResult::NeedPoint)
}
BoxStep::OppositeCorner if matches!(upper.as_str(), "C" | "CUBE") => {
self.box_step = BoxStep::CubeSize;
Some(CmdResult::NeedPoint)
}
BoxStep::OppositeCorner if matches!(upper.as_str(), "L" | "LENGTH") => {
self.box_step = BoxStep::Length;
Some(CmdResult::NeedPoint)
}
BoxStep::Height if matches!(upper.as_str(), "2P" | "2POINT") => {
self.box_step = BoxStep::HeightFirstPoint;
Some(CmdResult::NeedPoint)
}
BoxStep::CubeSize => crate::entities::common::parse_typed_length(token)
.and_then(|value| self.set_box_cube(value, 0.0)),
BoxStep::Length => {
let value = crate::entities::common::parse_typed_length(token)?;
self.set_box_length(value, 0.0)
.then_some(CmdResult::NeedPoint)
}
BoxStep::Width => {
let value = crate::entities::common::parse_typed_length(token)?;
self.set_box_width(value, value)
.then_some(CmdResult::NeedPoint)
}
BoxStep::Height => {
let value = crate::entities::common::parse_typed_length(token)?;
(value.is_finite() && value.abs() >= 1e-6).then(|| self.commit(value))
}
_ => None,
};
}
if !self.height_step {
return None;
}
let h: f64 = raw.trim().parse().ok().filter(|v| *v > 0.0)?;
Some(self.commit(h))
}
fn on_mouse_move(&mut self, pt: DVec3) -> Option<WireModel> {
if self.shape == Shape::Sphere {
let local = self.plane.to_local(pt);
if !local.is_finite() {
return None;
}
return match self.sphere_step {
SphereStep::Radius(center) => self.sphere_preview(center, center.distance(local)),
SphereStep::Diameter(center) => {
self.sphere_preview(center, center.distance(local) * 0.5)
}
SphereStep::TwoPointSecond(first) => {
self.sphere_preview((first + local) * 0.5, first.distance(local) * 0.5)
}
SphereStep::ThreePointSecond(first) => {
self.sphere_preview((first + local) * 0.5, first.distance(local) * 0.5)
}
SphereStep::ThreePointThird(first, second) => {
let (center, radius) = sphere_through_three_points(first, second, local)?;
self.sphere_preview(center, radius)
}
SphereStep::TtrRadius {
first,
second,
first_hit,
second_hit,
} => {
let radius = second_hit.distance(local);
let hint = (first_hit + second_hit) * 0.5;
let center = closest_sphere_center(
&sphere_ttr_centers(first, second, radius),
hint,
)?;
self.sphere_preview(center, radius)
}
_ => None,
};
}
if self.shape == Shape::Cone {
return self.cone_mouse_move(pt);
}
if self.shape == Shape::Pyramid {
return self.pyramid_mouse_move(pt);
}
if self.pts.is_empty() {
return None;
}
if self.shape.rectangular() {
let local = self.plane.to_local(pt);
if !local.is_finite() {
return None;
}
return match self.box_step {
BoxStep::OppositeCorner => {
let first = self.pts[0];
let points = if self.box_centered {
let delta = local - first;
vec![
DVec3::new(
first.x - delta.x.abs(),
first.y - delta.y.abs(),
first.z,
),
DVec3::new(
first.x + delta.x.abs(),
first.y + delta.y.abs(),
first.z,
),
]
} else {
vec![first, local]
};
Some(self.place_preview(footprint_wire(Shape::Box, &points)))
}
BoxStep::CubeSize => {
let delta = local - self.pts[0];
let size = if self.shape == Shape::Wedge {
delta.x.hypot(delta.y)
} else {
delta.length()
}
.max(1e-6);
let mut preview = PrimitiveCommand::new(self.shape.name());
preview.plane = self.plane;
preview.pts = self.pts.clone();
preview.box_length = Some(size);
preview.box_width = Some(size);
preview.box_width_sign = 1.0;
if self.shape == Shape::Wedge {
preview.box_origin = Some(self.pts[0]);
preview.box_angle = delta.y.atan2(delta.x);
} else {
preview.box_origin = Some(if self.box_centered {
self.pts[0] - DVec3::new(size * 0.5, size * 0.5, 0.0)
} else {
self.pts[0]
});
}
if self.shape == Shape::Wedge && self.box_centered {
let (sin, cos) = preview.box_angle.sin_cos();
let x_axis = DVec3::new(cos, sin, 0.0);
let y_axis = DVec3::new(-sin, cos, 0.0);
preview.box_origin = Some(
self.pts[0] - x_axis * size * 0.5 - y_axis * size * 0.5,
);
}
preview.rectangular_preview(size)
}
BoxStep::Length => Some(self.place_preview(wire(
"primitive_preview",
vec![self.pts[0].as_vec3().to_array(), local.as_vec3().to_array()],
))),
BoxStep::Width => {
let delta = local - self.pts[0];
let normal = DVec3::new(-self.box_angle.sin(), self.box_angle.cos(), 0.0);
let signed = delta.dot(normal);
let mut preview = PrimitiveCommand::new(self.shape.name());
preview.plane = self.plane;
preview.pts = self.pts.clone();
preview.box_origin = self.box_origin;
preview.box_length = self.box_length;
preview.box_width = Some(signed.abs().max(1e-6));
preview.box_angle = self.box_angle;
preview.box_width_sign = if signed < 0.0 { -1.0 } else { 1.0 };
preview.rectangular_preview(1e-6)
}
BoxStep::Height => self.rectangular_preview(self.cursor_height(pt)),
BoxStep::HeightSecondPoint => self.box_height_anchor.map(|first| {
self.place_preview(wire(
"primitive_preview",
vec![first.as_vec3().to_array(), local.as_vec3().to_array()],
))
}),
_ => None,
};
}
if self.height_step {
return Some(self.place_preview(height_wire(
self.shape,
&self.pts,
self.cursor_height(pt),
)));
}
let mut foot = self.pts.clone();
foot.push(self.plane.to_local(pt));
Some(self.place_preview(footprint_wire(self.shape, &foot)))
}
fn dyn_spec(&self) -> Option<crate::command::DynSpec> {
use crate::command::{DynAnchor, DynFieldSpec, DynGuide, DynRole, DynSpec};
if self.shape == Shape::Sphere {
let (anchor, role) = match self.sphere_step {
SphereStep::Radius(center) => (center, DynRole::Radius),
SphereStep::Diameter(center) => (center, DynRole::Diameter),
SphereStep::TtrRadius { second_hit, .. } => {
(second_hit, DynRole::Radius)
}
_ => return None,
};
return Some(DynSpec {
anchor: DynAnchor::Point(self.plane.to_world(anchor)),
fields: vec![DynFieldSpec::new(role)],
guide: DynGuide::Radius,
ref_point: None,
});
}
if self.shape == Shape::Cone {
let frame = self.cone_frame.unwrap_or(self.plane);
let (anchor, role) = match self.cone_step {
ConeStep::BaseRadius | ConeStep::TopRadius => {
(frame.origin, DynRole::Radius)
}
ConeStep::BaseDiameter => (frame.origin, DynRole::Diameter),
ConeStep::TtrRadius { second_hit, .. } => {
(self.plane.to_world(second_hit), DynRole::Radius)
}
ConeStep::EllipseCenterFirstAxis(center) => (center, DynRole::Distance),
ConeStep::Height | ConeStep::HeightAfterTopRadius | ConeStep::AxisEndpoint => {
(frame.origin, DynRole::Height)
}
ConeStep::HeightSecondPoint(first) => (first, DynRole::Height),
_ => return None,
};
return Some(DynSpec {
anchor: DynAnchor::Point(anchor),
fields: vec![DynFieldSpec::new(role)],
guide: if matches!(role, DynRole::Radius | DynRole::Diameter) {
DynGuide::Radius
} else {
DynGuide::None
},
ref_point: None,
});
}
if self.shape == Shape::Pyramid {
let frame = self.pyramid_frame.unwrap_or(self.plane);
let (anchor, role) = match self.pyramid_step {
PyramidStep::BaseRadius | PyramidStep::TopRadius => {
(frame.origin, DynRole::Radius)
}
PyramidStep::Height
| PyramidStep::HeightAfterTopRadius
| PyramidStep::AxisEndpoint => (frame.origin, DynRole::Height),
PyramidStep::HeightSecondPoint => {
(self.pyramid_height_first?, DynRole::Height)
}
_ => return None,
};
return Some(DynSpec {
anchor: DynAnchor::Point(anchor),
fields: vec![DynFieldSpec::new(role)],
guide: if role == DynRole::Radius {
DynGuide::Radius
} else {
DynGuide::None
},
ref_point: None,
});
}
let role = if self.shape.rectangular() {
match self.box_step {
BoxStep::CubeSize | BoxStep::Length => DynRole::Distance,
BoxStep::Width => DynRole::Width,
BoxStep::Height => DynRole::Height,
_ => return None,
}
} else if self.height_step {
DynRole::Height
} else {
return None;
};
Some(DynSpec {
anchor: DynAnchor::Point(self.plane.to_world(self.pts[0])),
fields: vec![DynFieldSpec::new(role)],
guide: DynGuide::None,
ref_point: None,
})
}
fn dyn_live_value(&self, cursor: DVec3) -> Option<f64> {
if self.shape == Shape::Sphere {
let local = self.plane.to_local(cursor);
return match self.sphere_step {
SphereStep::Radius(center) => Some(center.distance(local)),
SphereStep::Diameter(center) => Some(center.distance(local)),
SphereStep::TtrRadius { second_hit, .. } => {
Some(second_hit.distance(local))
}
_ => None,
};
}
if self.shape == Shape::Cone {
return match self.cone_step {
ConeStep::BaseRadius | ConeStep::TopRadius => {
let frame = self.cone_frame?;
let local = frame.to_local(cursor);
Some(local.x.hypot(local.y))
}
ConeStep::BaseDiameter => {
let frame = self.cone_frame?;
let local = frame.to_local(cursor);
Some(local.x.hypot(local.y))
}
ConeStep::TtrRadius { second_hit, .. } => {
let local = self.plane.to_local(cursor);
Some((local - second_hit).truncate().length())
}
ConeStep::EllipseCenterFirstAxis(center) => Some(center.distance(cursor)),
ConeStep::Height | ConeStep::HeightAfterTopRadius => {
self.cone_height_at(cursor).map(f64::abs)
}
ConeStep::HeightSecondPoint(first) => Some(first.distance(cursor)),
ConeStep::AxisEndpoint => self.cone_frame.map(|frame| frame.origin.distance(cursor)),
_ => None,
};
}
if self.shape == Shape::Pyramid {
return match self.pyramid_step {
PyramidStep::BaseRadius | PyramidStep::TopRadius => {
let frame = self.pyramid_frame?;
let delta = cursor - frame.origin;
Some((delta - frame.z * delta.dot(frame.z)).length())
}
PyramidStep::Height | PyramidStep::HeightAfterTopRadius => {
self.pyramid_height_at(cursor).map(f64::abs)
}
PyramidStep::HeightSecondPoint => {
Some(self.pyramid_height_first?.distance(cursor))
}
PyramidStep::AxisEndpoint => {
self.pyramid_frame.map(|frame| frame.origin.distance(cursor))
}
_ => None,
};
}
if self.shape.rectangular() {
let local = self.plane.to_local(cursor);
if !local.is_finite() {
return None;
}
return match self.box_step {
BoxStep::CubeSize | BoxStep::Length => {
let delta = local - self.pts[0];
Some(if self.shape == Shape::Wedge {
delta.x.hypot(delta.y)
} else {
delta.length()
})
}
BoxStep::Width => {
let normal = DVec3::new(-self.box_angle.sin(), self.box_angle.cos(), 0.0);
Some((local - self.pts[0]).dot(normal).abs())
}
BoxStep::Height => Some(self.cursor_height(cursor)),
_ => None,
};
}
self.height_step.then(|| self.cursor_height(cursor))
}
}
// ── Footprint preview ───────────────────────────────────────────────────────
fn footprint_wire(shape: Shape, pts: &[DVec3]) -> WireModel {
let mut points: Vec<[f32; 3]> = Vec::new();
if shape == Shape::Pyramid {
let center = pts[0];
let radius = (pts[1] - center).length();
let corners: [DVec3; 4] = std::array::from_fn(|index| {
let angle = index as f64 * std::f64::consts::FRAC_PI_2;
center + DVec3::new(radius * angle.cos(), radius * angle.sin(), 0.0)
});
push_loop(&mut points, &corners);
} else if shape.radial() {
let c = pts[0];
let r = (pts[1] - c).length();
circle_points(&mut points, c, r);
if shape == Shape::Torus && pts.len() >= 3 {
let inner = (pts[2] - c).length();
points.push([f32::NAN; 3]);
circle_points(&mut points, c, inner);
}
} else {
let (a, b) = (pts[0], pts[1]);
points.extend_from_slice(&[
[a.x as f32, a.y as f32, a.z as f32],
[b.x as f32, a.y as f32, a.z as f32],
[b.x as f32, b.y as f32, a.z as f32],
[a.x as f32, b.y as f32, a.z as f32],
[a.x as f32, a.y as f32, a.z as f32],
]);
}
wire("primitive_preview", points)
}
fn height_wire(shape: Shape, pts: &[DVec3], height: f64) -> WireModel {
let mut points = Vec::new();
match shape {
Shape::Box => {
let (a, b) = (pts[0], pts[1]);
let base = [
DVec3::new(a.x, a.y, a.z),
DVec3::new(b.x, a.y, a.z),
DVec3::new(b.x, b.y, a.z),
DVec3::new(a.x, b.y, a.z),
];
let top = base.map(|point| point + DVec3::Z * height);
push_loop(&mut points, &base);
push_loop(&mut points, &top);
for i in 0..4 {
push_segment(&mut points, base[i], top[i]);
}
}
Shape::Wedge => {
let (a, b) = (pts[0], pts[1]);
let (x0, x1) = (a.x.min(b.x), a.x.max(b.x));
let (y0, y1) = (a.y.min(b.y), a.y.max(b.y));
let low = [
DVec3::new(x0, y0, a.z),
DVec3::new(x1, y0, a.z),
DVec3::new(x0, y0, a.z + height),
];
let high = low.map(|point| DVec3::new(point.x, y1, point.z));
push_loop(&mut points, &low);
push_loop(&mut points, &high);
for i in 0..3 {
push_segment(&mut points, low[i], high[i]);
}
}
Shape::Cylinder | Shape::Cone | Shape::Pyramid => {
let center = pts[0];
let radius = (pts[1] - center).length();
if shape == Shape::Pyramid {
let base: [DVec3; 4] = std::array::from_fn(|index| {
let angle = index as f64 * std::f64::consts::FRAC_PI_2;
center + DVec3::new(radius * angle.cos(), radius * angle.sin(), 0.0)
});
push_loop(&mut points, &base);
let apex = center + DVec3::Z * height;
for corner in base {
push_segment(&mut points, corner, apex);
}
return wire("primitive_height_preview", points);
}
push_circle(&mut points, center, radius);
if shape == Shape::Cylinder {
push_circle(&mut points, center + DVec3::Z * height, radius);
for i in 0..4 {
let angle = i as f64 * std::f64::consts::FRAC_PI_2;
let base = center + DVec3::new(angle.cos() * radius, angle.sin() * radius, 0.0);
push_segment(&mut points, base, base + DVec3::Z * height);
}
} else {
let apex = center + DVec3::Z * height;
for i in 0..4 {
let angle = i as f64 * std::f64::consts::FRAC_PI_2;
let base = center + DVec3::new(angle.cos() * radius, angle.sin() * radius, 0.0);
push_segment(&mut points, base, apex);
}
}
}
Shape::Sphere | Shape::Torus => {}
}
wire("primitive_height_preview", points)
}
fn push_break(points: &mut Vec<[f32; 3]>) {
if !points.is_empty() {
points.push([f32::NAN; 3]);
}
}
fn push_loop<const N: usize>(points: &mut Vec<[f32; 3]>, path: &[DVec3; N]) {
push_break(points);
points.extend(path.iter().chain(path.first()).map(|point| point.as_vec3().to_array()));
}
fn push_path_loop(points: &mut Vec<[f32; 3]>, path: &[DVec3]) {
if path.is_empty() {
return;
}
push_break(points);
points.extend(path.iter().chain(path.first()).map(|point| point.as_vec3().to_array()));
}
fn push_segment(points: &mut Vec<[f32; 3]>, a: DVec3, b: DVec3) {
push_break(points);
points.extend([a.as_vec3().to_array(), b.as_vec3().to_array()]);
}
fn push_circle(points: &mut Vec<[f32; 3]>, center: DVec3, radius: f64) {
push_break(points);
circle_points(points, center, radius);
}
fn push_ellipse_world(
points: &mut Vec<[f32; 3]>,
center: DVec3,
x_axis: DVec3,
y_axis: DVec3,
x_radius: f64,
y_radius: f64,
) {
push_break(points);
const SEGMENTS: usize = 64;
for index in 0..=SEGMENTS {
let angle = index as f64 / SEGMENTS as f64 * std::f64::consts::TAU;
let point = center
+ x_axis * (x_radius * angle.cos())
+ y_axis * (y_radius * angle.sin());
points.push(point.as_vec3().to_array());
}
}
fn circle_points(out: &mut Vec<[f32; 3]>, c: DVec3, r: f64) {
const SEG: usize = 48;
for i in 0..=SEG {
let t = i as f64 / SEG as f64 * std::f64::consts::TAU;
out.push([
(c.x + r * t.cos()) as f32,
(c.y + r * t.sin()) as f32,
c.z as f32,
]);
}
}
// ── Autocomplete registry ─────────────────────────────────
inventory::submit!(crate::command::CommandRegistration {
names: &["BOX", "WEDGE", "CYLINDER", "CONE", "SPHERE", "PYRAMID", "PYR", "TORUS"]
});
fn wire(name: &str, points: Vec<[f32; 3]>) -> WireModel {
WireModel {
point_marker: None,
taper_widths: Vec::new(),
pattern_stations: Vec::new(),
world_width: 0.0,
depth_override: None,
display_visible: true,
plot_visible: true,
fill_is_3d: false,
fill_is_2d_solid: false,
render_instance: None,
pick_tris: Vec::new(),
pick_tris_low: Vec::new(),
dash_from_start: false,
dash_align_end: None,
text_verts: Vec::new(),
name: name.into(),
points,
points_low: Vec::new(),
color: WireModel::CYAN,
selected: false,
pattern_length: 0.0,
pattern: [0.0; 8],
line_weight_px: 1.0,
snap_pts: vec![],
tangent_geoms: vec![],
aci: 0,
key_vertices: vec![],
aabb: WireModel::UNBOUNDED_AABB,
plinegen: true,
fill_tris: vec![],
fill_tris_low: Vec::new(),
}
}
View Git Blame Copy Permalink