forked from 1b-agent/opencadstudio-upstream
Merge pull request #907 from ramox81/codex/fix-helix-command-properties
Fix parametric helix creation and properties
This commit is contained in:
5 files changed
+793
-274
No files matched your search
Generated
+2
-2
@@ -72,7 +72,7 @@ checksum = "366ffbaa4442f4684d91e2cd7c5ea7c4ed8add41959a31447066e279e432b618"
|
|||||||
[[package]]
|
[[package]]
|
||||||
name = "acadrust"
|
name = "acadrust"
|
||||||
version = "0.4.1"
|
version = "0.4.1"
|
||||||
source = "git+https://git@github.com/HakanSeven12/cadcodec.git?rev=788eea0161ba9f3eb7ee6569fd8bb52a8207a2ed#788eea0161ba9f3eb7ee6569fd8bb52a8207a2ed"
|
source = "git+https://git@github.com/HakanSeven12/cadcodec.git?rev=9a332bb3c48eca90c3eefaa17aed514da0b8694a#9a332bb3c48eca90c3eefaa17aed514da0b8694a"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"ahash 0.8.12",
|
"ahash 0.8.12",
|
||||||
"anyhow",
|
"anyhow",
|
||||||
@@ -878,7 +878,7 @@ checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"
|
|||||||
[[package]]
|
[[package]]
|
||||||
name = "cadkernel"
|
name = "cadkernel"
|
||||||
version = "0.1.0"
|
version = "0.1.0"
|
||||||
source = "git+https://github.com/HakanSeven12/cadkernel.git?rev=b2b1d4b#b2b1d4b0cd7def2d26a0d519991fc89a89f916d3"
|
source = "git+https://github.com/HakanSeven12/cadkernel.git?rev=1283cce45439abecdfd49828c7d6b84cb8ba0181#1283cce45439abecdfd49828c7d6b84cb8ba0181"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"acadrust",
|
"acadrust",
|
||||||
"cavalier_contours",
|
"cavalier_contours",
|
||||||
|
|||||||
+3
-3
@@ -27,8 +27,8 @@ glam = { version = "0.33", features = ["bytemuck"] }
|
|||||||
rfd = "0.17"
|
rfd = "0.17"
|
||||||
clap = { version = "4", features = ["derive"] }
|
clap = { version = "4", features = ["derive"] }
|
||||||
env_logger = "0.11"
|
env_logger = "0.11"
|
||||||
acadrust = { git = "https://github.com/HakanSeven12/cadcodec.git", rev = "788eea0161ba9f3eb7ee6569fd8bb52a8207a2ed", features = ["serde"] }
|
acadrust = { git = "https://github.com/HakanSeven12/cadcodec.git", rev = "9a332bb3c48eca90c3eefaa17aed514da0b8694a", features = ["serde"] }
|
||||||
cadkernel = { git = "https://github.com/HakanSeven12/cadkernel.git", rev = "b2b1d4b", features = ["acis", "offset"] }
|
cadkernel = { git = "https://github.com/HakanSeven12/cadkernel.git", rev = "1283cce45439abecdfd49828c7d6b84cb8ba0181", features = ["acis", "offset"] }
|
||||||
dwg-thumbnailer = { path = "crates/dwg-thumbnailer" }
|
dwg-thumbnailer = { path = "crates/dwg-thumbnailer" }
|
||||||
flate2 = "1"
|
flate2 = "1"
|
||||||
image = { version = "0.25", default-features = false, features = ["png", "jpeg", "bmp", "tiff"] }
|
image = { version = "0.25", default-features = false, features = ["png", "jpeg", "bmp", "tiff"] }
|
||||||
@@ -61,7 +61,7 @@ iced_core = { git = "https://github.com/iced-rs/iced.git", rev = "23604ff22ab0aa
|
|||||||
iced_widget = { git = "https://github.com/iced-rs/iced.git", rev = "23604ff22ab0aad9e00b9327cb7b8546ed84db39" }
|
iced_widget = { git = "https://github.com/iced-rs/iced.git", rev = "23604ff22ab0aad9e00b9327cb7b8546ed84db39" }
|
||||||
|
|
||||||
[patch."https://github.com/HakanSeven12/cadcodec.git"]
|
[patch."https://github.com/HakanSeven12/cadcodec.git"]
|
||||||
acadrust = { git = "https://git@github.com/HakanSeven12/cadcodec.git", rev = "788eea0161ba9f3eb7ee6569fd8bb52a8207a2ed" }
|
acadrust = { git = "https://git@github.com/HakanSeven12/cadcodec.git", rev = "9a332bb3c48eca90c3eefaa17aed514da0b8694a" }
|
||||||
|
|
||||||
[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
|
[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
|
||||||
ocs_plugin_api = { path = "crates/ocs_plugin_api", features = ["host"] }
|
ocs_plugin_api = { path = "crates/ocs_plugin_api", features = ["host"] }
|
||||||
|
|||||||
+405
-82
@@ -1,106 +1,427 @@
|
|||||||
// Helix entity (AcDbHelix): a spline curve plus its generating parameters.
|
use acadrust::entities::{Helix, HelixConstraint, Spline};
|
||||||
//
|
use acadrust::types::Vector3;
|
||||||
// A loaded helix carries a fully evaluated `spline` (the NURBS the file
|
use cadkernel::space::{HelixCurve, HelixDirection, NurbsCurve3, Vec3};
|
||||||
// stored) alongside the parameters that generated it (base point, axis,
|
use glam::DVec3;
|
||||||
// radius, turns, turn height, twist, constraint). We render and grip the
|
|
||||||
// entity through its embedded spline, and expose the generating parameters
|
|
||||||
// as the Geometry property group.
|
|
||||||
|
|
||||||
use acadrust::entities::{Helix, HelixConstraint};
|
|
||||||
use crate::t;
|
|
||||||
|
|
||||||
use crate::command::EntityTransform;
|
use crate::command::EntityTransform;
|
||||||
use crate::entities::common::ro_prop as ro;
|
use crate::entities::common::{
|
||||||
use crate::entities::traits::{Grippable, Transformable, RenderConvertible};
|
center_grip, edit_prop as edit, format_angle, format_length, parse_f64, ro_prop as ro,
|
||||||
|
square_grip,
|
||||||
|
};
|
||||||
|
use crate::entities::traits::{Grippable, RenderConvertible, Transformable};
|
||||||
use crate::scene::convert::acad_to_render::RenderEntity;
|
use crate::scene::convert::acad_to_render::RenderEntity;
|
||||||
use crate::scene::model::object::{GripApply, GripDef, PropSection};
|
use crate::scene::model::object::{GripApply, GripDef, PropSection, PropValue, Property};
|
||||||
|
use crate::t;
|
||||||
|
|
||||||
/// Perpendicular distance from `p` to the helix axis (line through
|
const EPSILON: f64 = 1.0e-9;
|
||||||
/// `axis_base_point` along `axis_vector`). Used to recover the top radius
|
|
||||||
/// from the last defining point of the spline.
|
fn point(vector: Vector3) -> Vec3 {
|
||||||
fn radius_from_axis(helix: &Helix, p: &acadrust::types::Vector3) -> Option<f64> {
|
Vec3::new(vector.x, vector.y, vector.z)
|
||||||
let base = &helix.axis_base_point;
|
}
|
||||||
let axis = helix.axis_vector.normalize();
|
|
||||||
// A zero axis vector cannot define a line.
|
fn vector(value: Vec3) -> Vector3 {
|
||||||
if axis.length() < 1e-9 {
|
Vector3::new(value.x, value.y, value.z)
|
||||||
return None;
|
}
|
||||||
|
|
||||||
|
fn display(value: Vec3) -> DVec3 {
|
||||||
|
DVec3::new(value.x, value.y, value.z)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn kernel(value: DVec3) -> Vec3 {
|
||||||
|
Vec3::new(value.x, value.y, value.z)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn finite(value: Vec3) -> bool {
|
||||||
|
value.x.is_finite() && value.y.is_finite() && value.z.is_finite()
|
||||||
|
}
|
||||||
|
|
||||||
|
fn spline_curve(spline: &Spline) -> Option<NurbsCurve3> {
|
||||||
|
let controls: Vec<[f64; 3]> = spline
|
||||||
|
.control_points
|
||||||
|
.iter()
|
||||||
|
.map(|value| [value.x, value.y, value.z])
|
||||||
|
.collect();
|
||||||
|
let degree = usize::try_from(spline.degree).ok()?;
|
||||||
|
let weights = if spline.weights.is_empty() {
|
||||||
|
vec![1.0; controls.len()]
|
||||||
|
} else {
|
||||||
|
spline.weights.clone()
|
||||||
|
};
|
||||||
|
NurbsCurve3::new_strict(degree, controls, spline.knots.clone(), weights)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn axis_frame(helix: &Helix) -> Option<(Vec3, Vec3, Vec3)> {
|
||||||
|
let base = point(helix.axis_base_point);
|
||||||
|
let axis = point(helix.axis_vector).normalize()?;
|
||||||
|
let radial = point(helix.start_point) - base;
|
||||||
|
let start_direction = (radial - axis * radial.dot(axis)).normalize()?;
|
||||||
|
Some((base, axis, start_direction))
|
||||||
|
}
|
||||||
|
|
||||||
|
fn radius_from_axis(helix: &Helix, value: Vec3) -> Option<f64> {
|
||||||
|
let (base, axis, _) = axis_frame(helix)?;
|
||||||
|
let delta = value - base;
|
||||||
|
Some((delta - axis * delta.dot(axis)).length())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn top_radius(helix: &Helix) -> f64 {
|
||||||
|
spline_curve(&helix.spline)
|
||||||
|
.map(|curve| Vec3::from(curve.point_at(1.0)))
|
||||||
|
.and_then(|endpoint| radius_from_axis(helix, endpoint))
|
||||||
|
.unwrap_or(helix.radius)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn kernel_curve(helix: &Helix, top_radius: f64) -> Option<HelixCurve> {
|
||||||
|
let (base, axis, start_direction) = axis_frame(helix)?;
|
||||||
|
Some(HelixCurve {
|
||||||
|
base_center: base.to_array(),
|
||||||
|
axis_direction: axis.to_array(),
|
||||||
|
start_direction: start_direction.to_array(),
|
||||||
|
base_radius: helix.radius,
|
||||||
|
top_radius,
|
||||||
|
height: helix.turns * helix.turn_height,
|
||||||
|
turns: helix.turns,
|
||||||
|
direction: if helix.handedness {
|
||||||
|
HelixDirection::CounterClockwise
|
||||||
|
} else {
|
||||||
|
HelixDirection::Clockwise
|
||||||
|
},
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
fn projected_direction(direction: Vec3, axis: Vec3) -> Option<Vec3> {
|
||||||
|
(direction - axis * direction.dot(axis)).normalize()
|
||||||
|
}
|
||||||
|
|
||||||
|
fn perpendicular(axis: Vec3) -> Option<Vec3> {
|
||||||
|
let basis = if axis.x.abs() <= axis.y.abs() && axis.x.abs() <= axis.z.abs() {
|
||||||
|
Vec3::X
|
||||||
|
} else if axis.y.abs() <= axis.z.abs() {
|
||||||
|
Vec3::Y
|
||||||
|
} else {
|
||||||
|
Vec3::Z
|
||||||
|
};
|
||||||
|
projected_direction(basis, axis)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn rebuild(helix: &mut Helix, top_radius: f64) -> bool {
|
||||||
|
let Some(curve) = kernel_curve(helix, top_radius) else {
|
||||||
|
return false;
|
||||||
|
};
|
||||||
|
let Some(nurbs) = curve.nurbs() else {
|
||||||
|
return false;
|
||||||
|
};
|
||||||
|
helix.spline.degree = nurbs.degree() as i32;
|
||||||
|
helix.spline.knots = nurbs.knots().to_vec();
|
||||||
|
helix.spline.control_points = nurbs
|
||||||
|
.control_points()
|
||||||
|
.iter()
|
||||||
|
.map(|value| Vector3::new(value[0], value[1], value[2]))
|
||||||
|
.collect();
|
||||||
|
helix.spline.weights = if nurbs.is_rational() {
|
||||||
|
nurbs.weights().to_vec()
|
||||||
|
} else {
|
||||||
|
Vec::new()
|
||||||
|
};
|
||||||
|
helix.spline.fit_points.clear();
|
||||||
|
helix.spline.flags.closed = false;
|
||||||
|
helix.spline.flags.periodic = false;
|
||||||
|
helix.spline.flags.rational = nurbs.is_rational();
|
||||||
|
helix.spline.flags.planar = false;
|
||||||
|
helix.spline.flags.linear = false;
|
||||||
|
true
|
||||||
|
}
|
||||||
|
|
||||||
|
fn choice(label: &str, field: &'static str, selected: &str, options: &[String]) -> Property {
|
||||||
|
Property {
|
||||||
|
label: label.to_string(),
|
||||||
|
field,
|
||||||
|
value: PropValue::Choice {
|
||||||
|
selected: selected.to_string(),
|
||||||
|
options: options.to_vec(),
|
||||||
|
},
|
||||||
}
|
}
|
||||||
let vx = p.x - base.x;
|
|
||||||
let vy = p.y - base.y;
|
|
||||||
let vz = p.z - base.z;
|
|
||||||
let proj = vx * axis.x + vy * axis.y + vz * axis.z;
|
|
||||||
let px = vx - proj * axis.x;
|
|
||||||
let py = vy - proj * axis.y;
|
|
||||||
let pz = vz - proj * axis.z;
|
|
||||||
Some((px * px + py * py + pz * pz).sqrt())
|
|
||||||
}
|
}
|
||||||
|
|
||||||
fn grips(helix: &Helix) -> Vec<GripDef> {
|
fn grips(helix: &Helix) -> Vec<GripDef> {
|
||||||
Grippable::grips(&helix.spline)
|
let Some((base, axis, _)) = axis_frame(helix) else {
|
||||||
|
return Vec::new();
|
||||||
|
};
|
||||||
|
let height = helix.turns * helix.turn_height;
|
||||||
|
let top_center = base + axis * height;
|
||||||
|
let top_endpoint = spline_curve(&helix.spline)
|
||||||
|
.map(|curve| Vec3::from(curve.point_at(1.0)))
|
||||||
|
.unwrap_or(top_center);
|
||||||
|
vec![
|
||||||
|
center_grip(0, display(base)),
|
||||||
|
square_grip(1, display(point(helix.start_point))),
|
||||||
|
square_grip(2, display(top_center)),
|
||||||
|
square_grip(3, display(top_endpoint)),
|
||||||
|
]
|
||||||
}
|
}
|
||||||
|
|
||||||
fn properties(helix: &Helix) -> Vec<PropSection> {
|
fn properties(helix: &Helix) -> Vec<PropSection> {
|
||||||
let bp = &helix.axis_base_point;
|
let base = point(helix.axis_base_point);
|
||||||
let turns = helix.turns;
|
let height = helix.turns * helix.turn_height;
|
||||||
let turn_height = helix.turn_height;
|
let top_radius = top_radius(helix);
|
||||||
// Overall height is turns × per-turn rise.
|
let curve = kernel_curve(helix, top_radius);
|
||||||
let height = turns * turn_height;
|
let turn_slope = curve.as_ref().and_then(HelixCurve::turn_slope).unwrap_or(0.0);
|
||||||
let base_radius = helix.radius;
|
let total_length = curve.as_ref().and_then(HelixCurve::length).unwrap_or(0.0);
|
||||||
// Top radius: the axial distance of the last defining point. For a
|
|
||||||
// cylindrical helix this equals the base radius.
|
|
||||||
let top_radius = helix
|
|
||||||
.spline
|
|
||||||
.control_points
|
|
||||||
.last()
|
|
||||||
.or_else(|| helix.spline.fit_points.last())
|
|
||||||
.and_then(|p| radius_from_axis(helix, p))
|
|
||||||
.unwrap_or(base_radius);
|
|
||||||
// Turn slope: rise angle of a single turn against the base circumference.
|
|
||||||
let turn_slope = if base_radius.abs() > 1e-9 {
|
|
||||||
(turn_height / (std::f64::consts::TAU * base_radius))
|
|
||||||
.atan()
|
|
||||||
.to_degrees()
|
|
||||||
} else {
|
|
||||||
0.0
|
|
||||||
};
|
|
||||||
let twist = if helix.handedness { "CW" } else { "CCW" };
|
|
||||||
let constrain = match helix.constraint {
|
let constrain = match helix.constraint {
|
||||||
HelixConstraint::TurnHeight => "Turn Height",
|
HelixConstraint::TurnHeight => t!("Turn Height").into_owned(),
|
||||||
HelixConstraint::Turns => "Turns",
|
HelixConstraint::Turns => t!("Turns").into_owned(),
|
||||||
HelixConstraint::Height => "Height",
|
HelixConstraint::Height => t!("Height").into_owned(),
|
||||||
};
|
};
|
||||||
|
let twist = if helix.handedness {
|
||||||
|
t!("CCW").into_owned()
|
||||||
|
} else {
|
||||||
|
t!("CW").into_owned()
|
||||||
|
};
|
||||||
|
let constraint_options = vec![
|
||||||
|
t!("Turn Height").into_owned(),
|
||||||
|
t!("Turns").into_owned(),
|
||||||
|
t!("Height").into_owned(),
|
||||||
|
];
|
||||||
|
let twist_options = vec![t!("CW").into_owned(), t!("CCW").into_owned()];
|
||||||
|
|
||||||
vec![PropSection {
|
vec![PropSection {
|
||||||
title: t!("Geometry").into_owned(),
|
title: t!("Geometry").into_owned(),
|
||||||
props: vec![
|
props: vec![
|
||||||
ro(t!("Base point X").as_ref(), "base_x", format!("{:.4}", bp.x)),
|
edit(t!("Position X").as_ref(), "position_x", base.x),
|
||||||
ro(t!("Base point Y").as_ref(), "base_y", format!("{:.4}", bp.y)),
|
edit(t!("Position Y").as_ref(), "position_y", base.y),
|
||||||
ro(t!("Base point Z").as_ref(), "base_z", format!("{:.4}", bp.z)),
|
edit(t!("Position Z").as_ref(), "position_z", base.z),
|
||||||
ro(t!("Number of turns").as_ref(), "num_turns", format!("{turns:.4}")),
|
choice(t!("Constrain").as_ref(), "constrain", &constrain, &constraint_options),
|
||||||
ro(t!("Turn height").as_ref(), "turn_height", format!("{turn_height:.4}")),
|
edit(t!("Height").as_ref(), "height", height),
|
||||||
ro(t!("Turns").as_ref(), "turns", format!("{turns:.4}")),
|
edit(t!("Turns").as_ref(), "turns", helix.turns),
|
||||||
ro(t!("Height").as_ref(), "height", format!("{height:.4}")),
|
edit(t!("Turn height").as_ref(), "turn_height", helix.turn_height),
|
||||||
ro(t!("Base radius").as_ref(), "base_radius", format!("{base_radius:.4}")),
|
edit(t!("Base radius").as_ref(), "base_radius", helix.radius),
|
||||||
ro(t!("Top radius").as_ref(), "top_radius", format!("{top_radius:.4}")),
|
edit(t!("Top radius").as_ref(), "top_radius", top_radius),
|
||||||
ro(t!("Turn slope").as_ref(), "turn_slope", format!("{turn_slope:.4}")),
|
choice(t!("Twist").as_ref(), "twist", &twist, &twist_options),
|
||||||
ro(t!("Twist").as_ref(), "twist", twist),
|
ro(t!("Turn slope").as_ref(), "turn_slope", format_angle(turn_slope)),
|
||||||
ro(t!("Constrain").as_ref(), "constrain", constrain),
|
ro(t!("Total length").as_ref(), "total_length", format_length(total_length)),
|
||||||
],
|
],
|
||||||
}]
|
}]
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Helix geometry is derived from the stored spline; the generating
|
fn apply_geom_prop(helix: &mut Helix, field: &str, value: &str) {
|
||||||
/// parameters are read-only (editing one would require regenerating the
|
if field == "constrain" {
|
||||||
/// spline, which the loaded entity does not carry a recipe for).
|
let constraint = if value == t!("Height").as_ref() {
|
||||||
fn apply_geom_prop(_helix: &mut Helix, _field: &str, _value: &str) {}
|
HelixConstraint::Height
|
||||||
|
} else if value == t!("Turns").as_ref() {
|
||||||
fn apply_grip(helix: &mut Helix, grip_id: usize, apply: GripApply) {
|
HelixConstraint::Turns
|
||||||
Grippable::apply_grip(&mut helix.spline, grip_id, apply);
|
} else if value == t!("Turn Height").as_ref() {
|
||||||
|
HelixConstraint::TurnHeight
|
||||||
|
} else {
|
||||||
|
return;
|
||||||
|
};
|
||||||
|
helix.constraint = constraint;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
let original = helix.clone();
|
||||||
|
let top = top_radius(helix);
|
||||||
|
if field == "twist" {
|
||||||
|
if value == t!("CCW").as_ref() {
|
||||||
|
helix.handedness = true;
|
||||||
|
} else if value == t!("CW").as_ref() {
|
||||||
|
helix.handedness = false;
|
||||||
|
} else {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
if !rebuild(helix, top) {
|
||||||
|
*helix = original;
|
||||||
|
}
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
let Some(number) = parse_f64(value).filter(|number| number.is_finite()) else {
|
||||||
|
return;
|
||||||
|
};
|
||||||
|
let old_base = point(helix.axis_base_point);
|
||||||
|
let old_height = helix.turns * helix.turn_height;
|
||||||
|
match field {
|
||||||
|
"position_x" | "position_y" | "position_z" => {
|
||||||
|
let mut base = old_base;
|
||||||
|
match field {
|
||||||
|
"position_x" => base.x = number,
|
||||||
|
"position_y" => base.y = number,
|
||||||
|
_ => base.z = number,
|
||||||
|
}
|
||||||
|
let delta = base - old_base;
|
||||||
|
helix.axis_base_point = vector(base);
|
||||||
|
helix.start_point = vector(point(helix.start_point) + delta);
|
||||||
|
}
|
||||||
|
"height" if number.abs() > EPSILON => {
|
||||||
|
if helix.constraint == HelixConstraint::TurnHeight && helix.turn_height.abs() > EPSILON {
|
||||||
|
let turns = number / helix.turn_height;
|
||||||
|
if turns <= EPSILON {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
helix.turns = turns;
|
||||||
|
} else {
|
||||||
|
helix.turn_height = number / helix.turns.max(EPSILON);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
"turns" if number > EPSILON => {
|
||||||
|
if helix.constraint == HelixConstraint::TurnHeight {
|
||||||
|
helix.turns = number;
|
||||||
|
} else {
|
||||||
|
helix.turns = number;
|
||||||
|
helix.turn_height = old_height / number;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
"turn_height" if number.abs() > EPSILON => {
|
||||||
|
if helix.constraint == HelixConstraint::Turns {
|
||||||
|
helix.turn_height = number;
|
||||||
|
} else {
|
||||||
|
let turns = old_height / number;
|
||||||
|
if turns <= EPSILON {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
helix.turn_height = number;
|
||||||
|
helix.turns = turns;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
"base_radius" if number > EPSILON => {
|
||||||
|
let Some((base, _, start_direction)) = axis_frame(helix) else {
|
||||||
|
return;
|
||||||
|
};
|
||||||
|
helix.radius = number;
|
||||||
|
helix.start_point = vector(base + start_direction * number);
|
||||||
|
}
|
||||||
|
"top_radius" if number >= 0.0 => {
|
||||||
|
if !rebuild(helix, number) {
|
||||||
|
*helix = original;
|
||||||
|
}
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
_ => return,
|
||||||
|
}
|
||||||
|
if !rebuild(helix, top) {
|
||||||
|
*helix = original;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn apply_transform(helix: &mut Helix, t: &EntityTransform) {
|
fn apply_grip(helix: &mut Helix, grip_id: usize, apply: GripApply) {
|
||||||
// Move the visible curve, then keep the generating points in step.
|
let original = helix.clone();
|
||||||
Transformable::apply_transform(&mut helix.spline, t);
|
let top = top_radius(helix);
|
||||||
|
let Some((base, axis, start_direction)) = axis_frame(helix) else {
|
||||||
|
return;
|
||||||
|
};
|
||||||
|
match (grip_id, apply) {
|
||||||
|
(0, GripApply::Translate(delta)) => {
|
||||||
|
let delta = kernel(delta);
|
||||||
|
if !finite(delta) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
helix.axis_base_point = vector(base + delta);
|
||||||
|
helix.start_point = vector(point(helix.start_point) + delta);
|
||||||
|
}
|
||||||
|
(0, GripApply::Absolute(position)) => {
|
||||||
|
let position = kernel(position);
|
||||||
|
if !finite(position) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
let delta = position - base;
|
||||||
|
helix.axis_base_point = vector(position);
|
||||||
|
helix.start_point = vector(point(helix.start_point) + delta);
|
||||||
|
}
|
||||||
|
(1, GripApply::Absolute(position)) => {
|
||||||
|
let position = kernel(position);
|
||||||
|
if !finite(position) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
let radial = position - base - axis * (position - base).dot(axis);
|
||||||
|
let radius = radial.length();
|
||||||
|
if radius <= EPSILON {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
helix.radius = radius;
|
||||||
|
helix.start_point = vector(base + radial);
|
||||||
|
}
|
||||||
|
(2, GripApply::Absolute(position)) => {
|
||||||
|
let position = kernel(position);
|
||||||
|
if !finite(position) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
let axis_vector = position - base;
|
||||||
|
let height = axis_vector.length();
|
||||||
|
if height <= EPSILON {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
let target_axis = axis_vector / height;
|
||||||
|
if helix.constraint == HelixConstraint::TurnHeight && helix.turn_height.abs() > EPSILON {
|
||||||
|
helix.axis_vector = vector(target_axis * helix.turn_height.signum());
|
||||||
|
helix.turns = height / helix.turn_height.abs();
|
||||||
|
} else {
|
||||||
|
helix.axis_vector = vector(target_axis);
|
||||||
|
helix.turn_height = height / helix.turns.max(EPSILON);
|
||||||
|
}
|
||||||
|
let new_axis = point(helix.axis_vector);
|
||||||
|
let start_direction = projected_direction(start_direction, new_axis)
|
||||||
|
.or_else(|| perpendicular(new_axis));
|
||||||
|
let Some(start_direction) = start_direction else {
|
||||||
|
*helix = original;
|
||||||
|
return;
|
||||||
|
};
|
||||||
|
helix.start_point = vector(base + start_direction * helix.radius);
|
||||||
|
}
|
||||||
|
(3, GripApply::Absolute(position)) => {
|
||||||
|
let position = kernel(position);
|
||||||
|
if !finite(position) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
let delta = position - base;
|
||||||
|
let height = delta.dot(axis);
|
||||||
|
let radius = (delta - axis * height).length();
|
||||||
|
if height.abs() <= EPSILON {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
if helix.constraint == HelixConstraint::TurnHeight && helix.turn_height.abs() > EPSILON {
|
||||||
|
let turns = height / helix.turn_height;
|
||||||
|
if turns <= EPSILON {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
helix.turns = turns;
|
||||||
|
} else {
|
||||||
|
helix.turn_height = height / helix.turns.max(EPSILON);
|
||||||
|
}
|
||||||
|
if !rebuild(helix, radius) {
|
||||||
|
*helix = original;
|
||||||
|
}
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
_ => return,
|
||||||
|
}
|
||||||
|
if !rebuild(helix, top) {
|
||||||
|
*helix = original;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn apply_transform(helix: &mut Helix, transform: &EntityTransform) {
|
||||||
|
match transform {
|
||||||
|
EntityTransform::Translate(delta) => {
|
||||||
|
acadrust::Entity::translate(helix, Vector3::new(delta.x, delta.y, delta.z));
|
||||||
|
}
|
||||||
|
EntityTransform::Rotate { center, axis, angle_rad } => {
|
||||||
|
crate::scene::view::transform::apply_standard_transform(
|
||||||
|
helix,
|
||||||
|
*center,
|
||||||
|
*axis,
|
||||||
|
*angle_rad,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
EntityTransform::Scale { center, factor } => {
|
||||||
|
crate::scene::view::transform::apply_standard_scale(helix, *center, *factor);
|
||||||
|
}
|
||||||
|
EntityTransform::Mirror { p1, p2, working_normal } => {
|
||||||
|
let reflection = crate::scene::view::transform::reflection_about_working_line(
|
||||||
|
*p1,
|
||||||
|
*p2,
|
||||||
|
*working_normal,
|
||||||
|
);
|
||||||
|
acadrust::Entity::apply_transform(helix, &reflection);
|
||||||
|
}
|
||||||
|
EntityTransform::Affine(value) => acadrust::Entity::apply_transform(helix, value),
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl RenderConvertible for Helix {
|
impl RenderConvertible for Helix {
|
||||||
@@ -113,6 +434,7 @@ impl Grippable for Helix {
|
|||||||
fn grips(&self) -> Vec<GripDef> {
|
fn grips(&self) -> Vec<GripDef> {
|
||||||
grips(self)
|
grips(self)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn apply_grip(&mut self, grip_id: usize, apply: GripApply) {
|
fn apply_grip(&mut self, grip_id: usize, apply: GripApply) {
|
||||||
apply_grip(self, grip_id, apply);
|
apply_grip(self, grip_id, apply);
|
||||||
}
|
}
|
||||||
@@ -122,13 +444,14 @@ impl crate::entities::traits::PropertyEditable for Helix {
|
|||||||
fn geometry_properties(&self, _text_style_names: &[String]) -> Vec<PropSection> {
|
fn geometry_properties(&self, _text_style_names: &[String]) -> Vec<PropSection> {
|
||||||
properties(self)
|
properties(self)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn apply_geom_prop(&mut self, field: &str, value: &str) {
|
fn apply_geom_prop(&mut self, field: &str, value: &str) {
|
||||||
apply_geom_prop(self, field, value);
|
apply_geom_prop(self, field, value);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Transformable for Helix {
|
impl Transformable for Helix {
|
||||||
fn apply_transform(&mut self, t: &EntityTransform) {
|
fn apply_transform(&mut self, transform: &EntityTransform) {
|
||||||
apply_transform(self, t);
|
apply_transform(self, transform);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -1,5 +1,4 @@
|
|||||||
// Persistent command defaults — last-used values survive across command runs
|
// Last-used command values for this session.
|
||||||
// within the same session. Uses thread_local! so no synchronisation needed.
|
|
||||||
|
|
||||||
use std::cell::Cell;
|
use std::cell::Cell;
|
||||||
|
|
||||||
@@ -28,6 +27,10 @@ thread_local! {
|
|||||||
static RECT_FILLET: Cell<f64> = Cell::new(0.0);
|
static RECT_FILLET: Cell<f64> = Cell::new(0.0);
|
||||||
static DONUT_INNER_DIAMETER: Cell<f64> = Cell::new(0.5);
|
static DONUT_INNER_DIAMETER: Cell<f64> = Cell::new(0.5);
|
||||||
static DONUT_OUTER_DIAMETER: Cell<f64> = Cell::new(1.0);
|
static DONUT_OUTER_DIAMETER: Cell<f64> = Cell::new(1.0);
|
||||||
|
static HELIX_BASE_RADIUS: Cell<f64> = Cell::new(1.0);
|
||||||
|
static HELIX_HEIGHT: Cell<f64> = Cell::new(1.0);
|
||||||
|
static HELIX_TURNS: Cell<f64> = Cell::new(3.0);
|
||||||
|
static HELIX_COUNTER_CLOCKWISE: Cell<bool> = Cell::new(true);
|
||||||
}
|
}
|
||||||
|
|
||||||
macro_rules! accessors {
|
macro_rules! accessors {
|
||||||
@@ -70,6 +73,16 @@ accessors!(get_rect_rotation, set_rect_rotation, RECT_ROTATION);
|
|||||||
accessors!(get_rect_chamfer1, set_rect_chamfer1, RECT_CHAMFER1);
|
accessors!(get_rect_chamfer1, set_rect_chamfer1, RECT_CHAMFER1);
|
||||||
accessors!(get_rect_chamfer2, set_rect_chamfer2, RECT_CHAMFER2);
|
accessors!(get_rect_chamfer2, set_rect_chamfer2, RECT_CHAMFER2);
|
||||||
accessors!(get_rect_fillet, set_rect_fillet, RECT_FILLET);
|
accessors!(get_rect_fillet, set_rect_fillet, RECT_FILLET);
|
||||||
|
accessors!(get_helix_base_radius, set_helix_base_radius, HELIX_BASE_RADIUS);
|
||||||
|
accessors!(get_helix_height, set_helix_height, HELIX_HEIGHT);
|
||||||
|
accessors!(get_helix_turns, set_helix_turns, HELIX_TURNS);
|
||||||
|
pub fn get_helix_counter_clockwise() -> bool {
|
||||||
|
HELIX_COUNTER_CLOCKWISE.with(|value| value.get())
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn set_helix_counter_clockwise(value: bool) {
|
||||||
|
HELIX_COUNTER_CLOCKWISE.with(|current| current.set(value));
|
||||||
|
}
|
||||||
accessors!(
|
accessors!(
|
||||||
get_donut_inner_diameter,
|
get_donut_inner_diameter,
|
||||||
set_donut_inner_diameter,
|
set_donut_inner_diameter,
|
||||||
|
|||||||
+368
-185
@@ -1,35 +1,18 @@
|
|||||||
// Parametric helix tool — interactive command.
|
use acadrust::entities::{Helix, HelixConstraint, Spline};
|
||||||
//
|
|
||||||
// Command: HELIX — build a parametric 3D helix and commit it as a single 3D
|
|
||||||
// polyline whose straight segments approximate the curve. The user picks a
|
|
||||||
// base centre point, then types the base radius, the top radius (Enter keeps
|
|
||||||
// it equal to the base radius for a cylindrical helix), the height, and the
|
|
||||||
// number of turns (Enter accepts a default of three turns).
|
|
||||||
//
|
|
||||||
// The curve is sampled at a fixed angular resolution: with `SEG_PER_TURN`
|
|
||||||
// samples per turn the helix has `turns * SEG_PER_TURN` segments. For each
|
|
||||||
// sample the radius interpolates linearly from base to top, the elevation
|
|
||||||
// interpolates linearly from zero to the height, and the planar position is
|
|
||||||
// `(radius*cos(angle), radius*sin(angle))` offset from the centre.
|
|
||||||
|
|
||||||
use acadrust::entities::Polyline3D;
|
|
||||||
use acadrust::types::Vector3;
|
use acadrust::types::Vector3;
|
||||||
use acadrust::EntityType;
|
use acadrust::EntityType;
|
||||||
use crate::t;
|
use cadkernel::space::{HelixCurve, HelixDirection, Vec3};
|
||||||
|
|
||||||
use crate::command::{CadCommand, CmdResult, DynField, WorkingPlane};
|
|
||||||
use crate::modules::{IconKind, ModuleEvent, ToolDef};
|
|
||||||
use crate::scene::model::wire_model::WireModel;
|
|
||||||
use glam::DVec3;
|
use glam::DVec3;
|
||||||
|
|
||||||
/// Angular samples per full turn of the helix.
|
use crate::command::{CadCommand, CmdOption, CmdResult, DynField, WorkingPlane};
|
||||||
const SEG_PER_TURN: usize = 36;
|
use crate::modules::draw::defaults;
|
||||||
/// Default number of turns when the user accepts the prompt with Enter.
|
use crate::modules::{IconKind, ModuleEvent, ToolDef};
|
||||||
const DEFAULT_TURNS: f64 = 3.0;
|
use crate::scene::model::wire_model::WireModel;
|
||||||
|
use crate::t;
|
||||||
|
|
||||||
// ── Ribbon definition ─────────────────────────────────────────────────────
|
const EPSILON: f64 = 1.0e-9;
|
||||||
|
|
||||||
#[allow(dead_code)] // ribbon definition ready for wiring; command works via the command line
|
#[allow(dead_code)]
|
||||||
pub fn tool() -> ToolDef {
|
pub fn tool() -> ToolDef {
|
||||||
ToolDef {
|
ToolDef {
|
||||||
id: "HELIX",
|
id: "HELIX",
|
||||||
@@ -39,16 +22,18 @@ pub fn tool() -> ToolDef {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// ── Command implementation ────────────────────────────────────────────────
|
|
||||||
|
|
||||||
/// Which parameter the command is currently collecting.
|
|
||||||
#[derive(Clone, Copy, PartialEq, Eq)]
|
#[derive(Clone, Copy, PartialEq, Eq)]
|
||||||
enum Step {
|
enum Step {
|
||||||
Center,
|
Center,
|
||||||
BaseRadius,
|
BaseRadius,
|
||||||
|
BaseDiameter,
|
||||||
TopRadius,
|
TopRadius,
|
||||||
Height,
|
TopDiameter,
|
||||||
|
Final,
|
||||||
|
AxisEndpoint,
|
||||||
Turns,
|
Turns,
|
||||||
|
TurnHeight,
|
||||||
|
Twist,
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct HelixCommand {
|
pub struct HelixCommand {
|
||||||
@@ -58,58 +43,130 @@ pub struct HelixCommand {
|
|||||||
top_radius: f64,
|
top_radius: f64,
|
||||||
height: f64,
|
height: f64,
|
||||||
turns: f64,
|
turns: f64,
|
||||||
|
requested_turn_height: Option<f64>,
|
||||||
|
counter_clockwise: bool,
|
||||||
|
constraint: HelixConstraint,
|
||||||
plane: WorkingPlane,
|
plane: WorkingPlane,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl HelixCommand {
|
impl HelixCommand {
|
||||||
pub fn new() -> Self {
|
pub fn new() -> Self {
|
||||||
|
let base_radius = defaults::get_helix_base_radius();
|
||||||
Self {
|
Self {
|
||||||
step: Step::Center,
|
step: Step::Center,
|
||||||
center: DVec3::ZERO,
|
center: DVec3::ZERO,
|
||||||
base_radius: 0.0,
|
base_radius,
|
||||||
top_radius: 0.0,
|
top_radius: base_radius,
|
||||||
height: 0.0,
|
height: defaults::get_helix_height(),
|
||||||
turns: DEFAULT_TURNS,
|
turns: defaults::get_helix_turns(),
|
||||||
|
requested_turn_height: None,
|
||||||
|
counter_clockwise: defaults::get_helix_counter_clockwise(),
|
||||||
|
constraint: HelixConstraint::Turns,
|
||||||
plane: WorkingPlane::default(),
|
plane: WorkingPlane::default(),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Sample the helix into a list of world points.
|
|
||||||
fn sample_points(&self, base_radius: f64, top_radius: f64, height: f64, turns: f64) -> Vec<DVec3> {
|
|
||||||
let turns = if turns <= 0.0 { DEFAULT_TURNS } else { turns };
|
|
||||||
let segments = ((turns * SEG_PER_TURN as f64).round() as usize).max(1);
|
|
||||||
let mut pts = Vec::with_capacity(segments + 1);
|
|
||||||
for t in 0..=segments {
|
|
||||||
let frac = t as f64 / segments as f64;
|
|
||||||
let angle = turns * std::f64::consts::TAU * frac;
|
|
||||||
let radius = base_radius + (top_radius - base_radius) * frac;
|
|
||||||
let z = height * frac;
|
|
||||||
pts.push(
|
|
||||||
self.center
|
|
||||||
+ self.plane.x * (radius * angle.cos())
|
|
||||||
+ self.plane.y * (radius * angle.sin())
|
|
||||||
+ self.plane.z * z,
|
|
||||||
);
|
|
||||||
}
|
|
||||||
pts
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Build the committed helix entity from the collected parameters.
|
|
||||||
fn build(&self) -> Option<EntityType> {
|
|
||||||
let pts = self.sample_points(self.base_radius, self.top_radius, self.height, self.turns);
|
|
||||||
if pts.len() < 2 {
|
|
||||||
return None;
|
|
||||||
}
|
|
||||||
let verts: Vec<Vector3> = pts.iter().map(|p| Vector3::new(p.x, p.y, p.z)).collect();
|
|
||||||
let mut pl = Polyline3D::from_points(verts);
|
|
||||||
pl.flags.closed = false;
|
|
||||||
Some(EntityType::Polyline3D(pl))
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Parse a positive distance from typed text; returns `None` on failure.
|
|
||||||
fn parse_value(text: &str) -> Option<f64> {
|
fn parse_value(text: &str) -> Option<f64> {
|
||||||
crate::entities::common::parse_typed_length(text)
|
crate::entities::common::parse_typed_length(text)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
fn parse_turns(text: &str) -> Option<f64> {
|
||||||
|
text.trim().replace(',', ".").parse().ok().filter(|value: &f64| value.is_finite())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn axis_start_direction(&self, axis: Vec3) -> Option<Vec3> {
|
||||||
|
let project = |direction: DVec3| {
|
||||||
|
let direction = Vec3::from(direction.to_array());
|
||||||
|
(direction - axis * direction.dot(axis)).normalize()
|
||||||
|
};
|
||||||
|
project(self.plane.x).or_else(|| project(self.plane.y))
|
||||||
|
}
|
||||||
|
|
||||||
|
fn resolved_turns(&self, height: f64) -> f64 {
|
||||||
|
match self.requested_turn_height {
|
||||||
|
Some(turn_height) if turn_height > EPSILON => (height.abs() / turn_height).max(EPSILON),
|
||||||
|
_ => self.turns,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn kernel_curve(&self, height: f64, axis: DVec3) -> Option<HelixCurve> {
|
||||||
|
let axis = Vec3::from(axis.to_array())
|
||||||
|
.normalize()
|
||||||
|
.or_else(|| Vec3::from(self.plane.z.to_array()).normalize())?;
|
||||||
|
Some(HelixCurve {
|
||||||
|
base_center: self.center.to_array(),
|
||||||
|
axis_direction: axis.to_array(),
|
||||||
|
start_direction: self.axis_start_direction(axis)?.to_array(),
|
||||||
|
base_radius: self.base_radius,
|
||||||
|
top_radius: self.top_radius,
|
||||||
|
height,
|
||||||
|
turns: self.resolved_turns(height),
|
||||||
|
direction: if self.counter_clockwise {
|
||||||
|
HelixDirection::CounterClockwise
|
||||||
|
} else {
|
||||||
|
HelixDirection::Clockwise
|
||||||
|
},
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
fn build(&self, height: f64, axis: DVec3) -> Option<EntityType> {
|
||||||
|
let curve = self.kernel_curve(height, axis)?;
|
||||||
|
let nurbs = curve.nurbs()?;
|
||||||
|
let axis = DVec3::from_array(curve.axis_direction).normalize_or(self.plane.z);
|
||||||
|
let start_direction = DVec3::from_array(curve.start_direction).normalize_or(self.plane.x);
|
||||||
|
let mut spline = Spline::new();
|
||||||
|
spline.degree = nurbs.degree() as i32;
|
||||||
|
spline.knots = nurbs.knots().to_vec();
|
||||||
|
spline.control_points = nurbs
|
||||||
|
.control_points()
|
||||||
|
.iter()
|
||||||
|
.map(|point| Vector3::new(point[0], point[1], point[2]))
|
||||||
|
.collect();
|
||||||
|
spline.flags.planar = false;
|
||||||
|
spline.flags.rational = nurbs.is_rational();
|
||||||
|
if spline.flags.rational {
|
||||||
|
spline.weights = nurbs.weights().to_vec();
|
||||||
|
}
|
||||||
|
|
||||||
|
let mut helix = Helix::new();
|
||||||
|
helix.spline = spline;
|
||||||
|
helix.axis_base_point = Vector3::new(self.center.x, self.center.y, self.center.z);
|
||||||
|
let start = self.center + start_direction * curve.base_radius;
|
||||||
|
helix.start_point = Vector3::new(start.x, start.y, start.z);
|
||||||
|
helix.axis_vector = Vector3::new(axis.x, axis.y, axis.z);
|
||||||
|
helix.radius = curve.base_radius;
|
||||||
|
helix.turns = curve.turns;
|
||||||
|
helix.turn_height = height / curve.turns;
|
||||||
|
helix.handedness = self.counter_clockwise;
|
||||||
|
helix.constraint = self.constraint;
|
||||||
|
Some(EntityType::Helix(helix))
|
||||||
|
}
|
||||||
|
|
||||||
|
fn commit(&mut self, height: f64, axis: DVec3) -> CmdResult {
|
||||||
|
let Some(entity) = self.build(height, axis) else {
|
||||||
|
return CmdResult::NeedPoint;
|
||||||
|
};
|
||||||
|
self.height = height;
|
||||||
|
self.turns = self.resolved_turns(height);
|
||||||
|
defaults::set_helix_base_radius(self.base_radius);
|
||||||
|
defaults::set_helix_height(height);
|
||||||
|
defaults::set_helix_turns(self.turns);
|
||||||
|
defaults::set_helix_counter_clockwise(self.counter_clockwise);
|
||||||
|
CmdResult::CommitAndExit(entity)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn preview(&self, height: f64, axis: DVec3) -> Option<WireModel> {
|
||||||
|
let points = self
|
||||||
|
.kernel_curve(height, axis)?
|
||||||
|
.nurbs()?
|
||||||
|
.tessellate_angle(cadkernel::tessellation::DEFAULT_ANGLE);
|
||||||
|
Some(WireModel::solid_f64(
|
||||||
|
"helix_preview".to_string(),
|
||||||
|
points,
|
||||||
|
WireModel::CYAN,
|
||||||
|
false,
|
||||||
|
))
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl CadCommand for HelixCommand {
|
impl CadCommand for HelixCommand {
|
||||||
@@ -123,65 +180,158 @@ impl CadCommand for HelixCommand {
|
|||||||
|
|
||||||
fn prompt(&self) -> String {
|
fn prompt(&self) -> String {
|
||||||
match self.step {
|
match self.step {
|
||||||
Step::Center => t!("HELIX Specify centre point of base:").into_owned(),
|
Step::Center => crate::tf!(
|
||||||
Step::BaseRadius => t!("HELIX Specify base radius:").into_owned(),
|
"HELIX Number of turns = {:.4} Twist = {}\nSpecify center point of base:",
|
||||||
Step::TopRadius => t!("HELIX Specify top radius <same as base>:").into_owned(),
|
self.turns,
|
||||||
Step::Height => t!("HELIX Specify helix height:").into_owned(),
|
if self.counter_clockwise { "CCW" } else { "CW" }
|
||||||
Step::Turns => t!("HELIX Enter number of turns <3>:").into_owned(),
|
)
|
||||||
|
.into_owned(),
|
||||||
|
Step::BaseRadius => crate::tf!(
|
||||||
|
"HELIX Specify base radius or [Diameter] <{:.4}>:",
|
||||||
|
self.base_radius
|
||||||
|
)
|
||||||
|
.into_owned(),
|
||||||
|
Step::BaseDiameter => crate::tf!(
|
||||||
|
"HELIX Specify base diameter <{:.4}>:",
|
||||||
|
self.base_radius * 2.0
|
||||||
|
)
|
||||||
|
.into_owned(),
|
||||||
|
Step::TopRadius => crate::tf!(
|
||||||
|
"HELIX Specify top radius or [Diameter] <{:.4}>:",
|
||||||
|
self.base_radius
|
||||||
|
)
|
||||||
|
.into_owned(),
|
||||||
|
Step::TopDiameter => crate::tf!(
|
||||||
|
"HELIX Specify top diameter <{:.4}>:",
|
||||||
|
self.base_radius * 2.0
|
||||||
|
)
|
||||||
|
.into_owned(),
|
||||||
|
Step::Final => crate::tf!(
|
||||||
|
"HELIX Specify helix height or [Axis endpoint/Turns/turn Height/tWist] <{:.4}>:",
|
||||||
|
self.height
|
||||||
|
)
|
||||||
|
.into_owned(),
|
||||||
|
Step::AxisEndpoint => t!("HELIX Specify axis endpoint:").into_owned(),
|
||||||
|
Step::Turns => crate::tf!("HELIX Enter number of turns <{:.4}>:", self.turns).into_owned(),
|
||||||
|
Step::TurnHeight => crate::tf!(
|
||||||
|
"HELIX Specify distance between turns <{:.4}>:",
|
||||||
|
self.height.abs() / self.turns.max(EPSILON)
|
||||||
|
)
|
||||||
|
.into_owned(),
|
||||||
|
Step::Twist => crate::tf!(
|
||||||
|
"HELIX Enter twist direction [Clockwise/Counterclockwise] <{}>:",
|
||||||
|
if self.counter_clockwise { "CCW" } else { "CW" }
|
||||||
|
)
|
||||||
|
.into_owned(),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn on_point(&mut self, pt: DVec3) -> CmdResult {
|
fn options(&self) -> Vec<CmdOption> {
|
||||||
|
match self.step {
|
||||||
|
Step::BaseRadius | Step::TopRadius => vec![CmdOption::new(t!("Diameter").as_ref(), "D")],
|
||||||
|
Step::Final => vec![
|
||||||
|
CmdOption::new(t!("Axis endpoint").as_ref(), "A"),
|
||||||
|
CmdOption::new(t!("Turns").as_ref(), "T"),
|
||||||
|
CmdOption::new(t!("Turn Height").as_ref(), "H"),
|
||||||
|
CmdOption::new(t!("Twist").as_ref(), "W"),
|
||||||
|
],
|
||||||
|
Step::Twist => vec![
|
||||||
|
CmdOption::new(t!("Clockwise").as_ref(), "CW"),
|
||||||
|
CmdOption::new(t!("Counterclockwise").as_ref(), "CCW"),
|
||||||
|
],
|
||||||
|
_ => Vec::new(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn point_step_accepts_keywords(&self) -> bool {
|
||||||
|
matches!(self.step, Step::BaseRadius | Step::TopRadius | Step::Final | Step::Twist)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn on_point(&mut self, point: DVec3) -> CmdResult {
|
||||||
match self.step {
|
match self.step {
|
||||||
Step::Center => {
|
Step::Center => {
|
||||||
self.center = pt;
|
self.center = point;
|
||||||
self.step = Step::BaseRadius;
|
self.step = Step::BaseRadius;
|
||||||
CmdResult::NeedPoint
|
CmdResult::NeedPoint
|
||||||
}
|
}
|
||||||
Step::BaseRadius => {
|
Step::BaseRadius | Step::BaseDiameter => {
|
||||||
// A point click resolves the base radius as the planar distance
|
let local = self.plane.vector_to_local(point - self.center);
|
||||||
// from the centre to the picked point.
|
let distance = local.x.hypot(local.y);
|
||||||
let delta = self.plane.vector_to_local(pt - self.center);
|
let radius = if self.step == Step::BaseDiameter {
|
||||||
let r = delta.x.hypot(delta.y);
|
distance * 0.5
|
||||||
if r > 0.0 {
|
} else {
|
||||||
self.base_radius = r;
|
distance
|
||||||
|
};
|
||||||
|
if radius > EPSILON {
|
||||||
|
self.base_radius = radius;
|
||||||
|
self.top_radius = radius;
|
||||||
self.step = Step::TopRadius;
|
self.step = Step::TopRadius;
|
||||||
}
|
}
|
||||||
CmdResult::NeedPoint
|
CmdResult::NeedPoint
|
||||||
}
|
}
|
||||||
Step::TopRadius => {
|
Step::TopRadius | Step::TopDiameter => {
|
||||||
let delta = self.plane.vector_to_local(pt - self.center);
|
let local = self.plane.vector_to_local(point - self.center);
|
||||||
let r = delta.x.hypot(delta.y);
|
let distance = local.x.hypot(local.y);
|
||||||
self.top_radius = if r > 0.0 { r } else { self.base_radius };
|
self.top_radius = if self.step == Step::TopDiameter {
|
||||||
self.step = Step::Height;
|
distance * 0.5
|
||||||
|
} else {
|
||||||
|
distance
|
||||||
|
};
|
||||||
|
self.step = Step::Final;
|
||||||
CmdResult::NeedPoint
|
CmdResult::NeedPoint
|
||||||
}
|
}
|
||||||
Step::Height => {
|
Step::Final => {
|
||||||
// Use the elevation of the picked point relative to the centre.
|
let height = (point - self.center).dot(self.plane.z);
|
||||||
let h = (pt - self.center).dot(self.plane.z);
|
if height.abs() <= EPSILON {
|
||||||
if h.abs() > 0.0 {
|
CmdResult::NeedPoint
|
||||||
self.height = h;
|
} else {
|
||||||
self.step = Step::Turns;
|
self.commit(height, self.plane.z)
|
||||||
}
|
}
|
||||||
CmdResult::NeedPoint
|
|
||||||
}
|
}
|
||||||
Step::Turns => CmdResult::NeedPoint,
|
Step::AxisEndpoint => {
|
||||||
|
let vector = point - self.center;
|
||||||
|
let height = vector.length();
|
||||||
|
if height <= EPSILON {
|
||||||
|
CmdResult::NeedPoint
|
||||||
|
} else {
|
||||||
|
self.commit(height, vector / height)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Step::Turns | Step::TurnHeight | Step::Twist => CmdResult::NeedPoint,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn on_enter(&mut self) -> CmdResult {
|
fn on_enter(&mut self) -> CmdResult {
|
||||||
match self.step {
|
match self.step {
|
||||||
Step::TopRadius => {
|
Step::Center => CmdResult::Cancel,
|
||||||
// Enter keeps the top radius equal to the base radius.
|
Step::BaseRadius | Step::BaseDiameter => {
|
||||||
self.top_radius = self.base_radius;
|
self.top_radius = self.base_radius;
|
||||||
self.step = Step::Height;
|
self.step = Step::TopRadius;
|
||||||
|
CmdResult::NeedPoint
|
||||||
|
}
|
||||||
|
Step::TopRadius | Step::TopDiameter => {
|
||||||
|
self.top_radius = self.base_radius;
|
||||||
|
self.step = Step::Final;
|
||||||
|
CmdResult::NeedPoint
|
||||||
|
}
|
||||||
|
Step::Final => self.commit(self.height, self.plane.z),
|
||||||
|
Step::AxisEndpoint => CmdResult::NeedPoint,
|
||||||
|
Step::Turns => {
|
||||||
|
self.constraint = HelixConstraint::Turns;
|
||||||
|
self.requested_turn_height = None;
|
||||||
|
self.step = Step::Final;
|
||||||
|
CmdResult::NeedPoint
|
||||||
|
}
|
||||||
|
Step::TurnHeight => {
|
||||||
|
self.constraint = HelixConstraint::TurnHeight;
|
||||||
|
self.requested_turn_height = Some(self.height.abs() / self.turns.max(EPSILON));
|
||||||
|
self.step = Step::Final;
|
||||||
|
CmdResult::NeedPoint
|
||||||
|
}
|
||||||
|
Step::Twist => {
|
||||||
|
self.step = Step::Final;
|
||||||
CmdResult::NeedPoint
|
CmdResult::NeedPoint
|
||||||
}
|
}
|
||||||
Step::Turns => match self.build() {
|
|
||||||
Some(e) => CmdResult::CommitAndExit(e),
|
|
||||||
None => CmdResult::Cancel,
|
|
||||||
},
|
|
||||||
_ => CmdResult::NeedPoint,
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -190,123 +340,156 @@ impl CadCommand for HelixCommand {
|
|||||||
}
|
}
|
||||||
|
|
||||||
fn wants_text_input(&self) -> bool {
|
fn wants_text_input(&self) -> bool {
|
||||||
// Every step past the centre pick reads a typed numeric value.
|
|
||||||
self.step != Step::Center
|
self.step != Step::Center
|
||||||
}
|
}
|
||||||
|
|
||||||
fn dyn_field(&self) -> DynField {
|
fn dyn_field(&self) -> DynField {
|
||||||
match self.step {
|
match self.step {
|
||||||
Step::Center => DynField::Point,
|
Step::Center | Step::AxisEndpoint => DynField::Point,
|
||||||
Step::BaseRadius | Step::TopRadius => DynField::Distance,
|
Step::BaseRadius | Step::BaseDiameter | Step::TopRadius | Step::TopDiameter | Step::Final | Step::TurnHeight => DynField::Distance,
|
||||||
Step::Height => DynField::Distance,
|
Step::Turns | Step::Twist => DynField::Scalar,
|
||||||
Step::Turns => DynField::Scalar,
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn on_text_input(&mut self, text: &str) -> Option<CmdResult> {
|
fn on_text_input(&mut self, text: &str) -> Option<CmdResult> {
|
||||||
let t = text.trim();
|
let value = text.trim();
|
||||||
|
let keyword = value.to_ascii_uppercase();
|
||||||
match self.step {
|
match self.step {
|
||||||
Step::Center => None,
|
Step::Center => None,
|
||||||
|
Step::BaseRadius if matches!(keyword.as_str(), "D" | "DIAMETER") => {
|
||||||
|
self.step = Step::BaseDiameter;
|
||||||
|
Some(CmdResult::NeedPoint)
|
||||||
|
}
|
||||||
|
Step::TopRadius if matches!(keyword.as_str(), "D" | "DIAMETER") => {
|
||||||
|
self.step = Step::TopDiameter;
|
||||||
|
Some(CmdResult::NeedPoint)
|
||||||
|
}
|
||||||
|
Step::Final if matches!(keyword.as_str(), "A" | "AXIS" | "AXIS ENDPOINT") => {
|
||||||
|
self.step = Step::AxisEndpoint;
|
||||||
|
Some(CmdResult::NeedPoint)
|
||||||
|
}
|
||||||
|
Step::Final if matches!(keyword.as_str(), "T" | "TURNS") => {
|
||||||
|
self.step = Step::Turns;
|
||||||
|
Some(CmdResult::NeedPoint)
|
||||||
|
}
|
||||||
|
Step::Final if matches!(keyword.as_str(), "H" | "HEIGHT" | "TURN HEIGHT") => {
|
||||||
|
self.step = Step::TurnHeight;
|
||||||
|
Some(CmdResult::NeedPoint)
|
||||||
|
}
|
||||||
|
Step::Final if matches!(keyword.as_str(), "W" | "TWIST") => {
|
||||||
|
self.step = Step::Twist;
|
||||||
|
Some(CmdResult::NeedPoint)
|
||||||
|
}
|
||||||
Step::BaseRadius => {
|
Step::BaseRadius => {
|
||||||
if let Some(v) = Self::parse_value(t) {
|
let radius = Self::parse_value(value)?;
|
||||||
if v > 0.0 {
|
if radius > EPSILON {
|
||||||
self.base_radius = v;
|
self.base_radius = radius;
|
||||||
self.step = Step::TopRadius;
|
self.top_radius = radius;
|
||||||
}
|
self.step = Step::TopRadius;
|
||||||
|
}
|
||||||
|
Some(CmdResult::NeedPoint)
|
||||||
|
}
|
||||||
|
Step::BaseDiameter => {
|
||||||
|
let diameter = Self::parse_value(value)?;
|
||||||
|
if diameter > EPSILON {
|
||||||
|
self.base_radius = diameter * 0.5;
|
||||||
|
self.top_radius = self.base_radius;
|
||||||
|
self.step = Step::TopRadius;
|
||||||
}
|
}
|
||||||
Some(CmdResult::NeedPoint)
|
Some(CmdResult::NeedPoint)
|
||||||
}
|
}
|
||||||
Step::TopRadius => {
|
Step::TopRadius => {
|
||||||
if t.is_empty() {
|
let radius = Self::parse_value(value)?;
|
||||||
// Empty entry keeps the top radius equal to the base radius.
|
if radius >= 0.0 {
|
||||||
self.top_radius = self.base_radius;
|
self.top_radius = radius;
|
||||||
self.step = Step::Height;
|
self.step = Step::Final;
|
||||||
} else if let Some(v) = Self::parse_value(t) {
|
|
||||||
self.top_radius = if v > 0.0 { v } else { self.base_radius };
|
|
||||||
self.step = Step::Height;
|
|
||||||
}
|
}
|
||||||
Some(CmdResult::NeedPoint)
|
Some(CmdResult::NeedPoint)
|
||||||
}
|
}
|
||||||
Step::Height => {
|
Step::TopDiameter => {
|
||||||
if let Some(v) = Self::parse_value(t) {
|
let diameter = Self::parse_value(value)?;
|
||||||
if v != 0.0 {
|
if diameter >= 0.0 {
|
||||||
self.height = v;
|
self.top_radius = diameter * 0.5;
|
||||||
self.step = Step::Turns;
|
self.step = Step::Final;
|
||||||
}
|
|
||||||
}
|
}
|
||||||
Some(CmdResult::NeedPoint)
|
Some(CmdResult::NeedPoint)
|
||||||
}
|
}
|
||||||
|
Step::Final => {
|
||||||
|
let height = Self::parse_value(value)?;
|
||||||
|
(height.abs() > EPSILON).then(|| self.commit(height, self.plane.z))
|
||||||
|
}
|
||||||
|
Step::AxisEndpoint => None,
|
||||||
Step::Turns => {
|
Step::Turns => {
|
||||||
self.turns = if t.is_empty() {
|
let turns = Self::parse_turns(value)?;
|
||||||
DEFAULT_TURNS
|
if turns > EPSILON {
|
||||||
} else {
|
self.turns = turns;
|
||||||
match Self::parse_value(t) {
|
self.requested_turn_height = None;
|
||||||
Some(v) if v > 0.0 => v,
|
self.constraint = HelixConstraint::Turns;
|
||||||
_ => return Some(CmdResult::NeedPoint),
|
self.step = Step::Final;
|
||||||
}
|
|
||||||
};
|
|
||||||
match self.build() {
|
|
||||||
Some(e) => Some(CmdResult::CommitAndExit(e)),
|
|
||||||
None => Some(CmdResult::Cancel),
|
|
||||||
}
|
}
|
||||||
|
Some(CmdResult::NeedPoint)
|
||||||
|
}
|
||||||
|
Step::TurnHeight => {
|
||||||
|
let turn_height = Self::parse_value(value)?;
|
||||||
|
if turn_height > EPSILON {
|
||||||
|
self.requested_turn_height = Some(turn_height);
|
||||||
|
self.constraint = HelixConstraint::TurnHeight;
|
||||||
|
self.step = Step::Final;
|
||||||
|
}
|
||||||
|
Some(CmdResult::NeedPoint)
|
||||||
|
}
|
||||||
|
Step::Twist => {
|
||||||
|
match keyword.as_str() {
|
||||||
|
"C" | "CW" | "CLOCKWISE" => self.counter_clockwise = false,
|
||||||
|
"CC" | "CCW" | "COUNTERCLOCKWISE" => self.counter_clockwise = true,
|
||||||
|
_ => return Some(CmdResult::NeedPoint),
|
||||||
|
}
|
||||||
|
self.step = Step::Final;
|
||||||
|
Some(CmdResult::NeedPoint)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn on_mouse_move(&mut self, pt: DVec3) -> Option<WireModel> {
|
fn on_mouse_move(&mut self, point: DVec3) -> Option<WireModel> {
|
||||||
// Preview the helix once enough parameters are known. Before a base
|
|
||||||
// radius is fixed, track the cursor distance to size a live ring.
|
|
||||||
match self.step {
|
match self.step {
|
||||||
Step::Center => None,
|
Step::Center => None,
|
||||||
Step::BaseRadius => {
|
Step::BaseRadius | Step::BaseDiameter => {
|
||||||
let delta = self.plane.vector_to_local(pt - self.center);
|
let local = self.plane.vector_to_local(point - self.center);
|
||||||
let r = delta.x.hypot(delta.y);
|
let old = (self.base_radius, self.top_radius);
|
||||||
if r <= 0.0 {
|
let distance = local.x.hypot(local.y);
|
||||||
return None;
|
self.base_radius = if self.step == Step::BaseDiameter {
|
||||||
}
|
distance * 0.5
|
||||||
let pts = self.sample_points(r, r, 0.0, 1.0);
|
|
||||||
let raw: Vec<[f64; 3]> = pts.iter().map(|p| [p.x, p.y, p.z]).collect();
|
|
||||||
Some(WireModel::solid_f64(
|
|
||||||
"helix_preview".to_string(),
|
|
||||||
raw,
|
|
||||||
WireModel::CYAN,
|
|
||||||
false,
|
|
||||||
))
|
|
||||||
}
|
|
||||||
_ => {
|
|
||||||
// Use the parameters fixed so far; for the height step let the
|
|
||||||
// cursor elevation drive the live height.
|
|
||||||
let height = if self.step == Step::Height {
|
|
||||||
(pt - self.center).dot(self.plane.z)
|
|
||||||
} else {
|
} else {
|
||||||
self.height
|
distance
|
||||||
};
|
|
||||||
let top = if self.step == Step::TopRadius {
|
|
||||||
let delta = self.plane.vector_to_local(pt - self.center);
|
|
||||||
let r = delta.x.hypot(delta.y);
|
|
||||||
if r > 0.0 {
|
|
||||||
r
|
|
||||||
} else {
|
|
||||||
self.base_radius
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
self.top_radius
|
|
||||||
};
|
|
||||||
let pts = self.sample_points(self.base_radius, top, height, self.turns);
|
|
||||||
if pts.len() < 2 {
|
|
||||||
return None;
|
|
||||||
}
|
}
|
||||||
let raw: Vec<[f64; 3]> = pts.iter().map(|p| [p.x, p.y, p.z]).collect();
|
.max(EPSILON);
|
||||||
Some(WireModel::solid_f64(
|
self.top_radius = self.base_radius;
|
||||||
"helix_preview".to_string(),
|
let preview = self.preview(0.0, self.plane.z);
|
||||||
raw,
|
(self.base_radius, self.top_radius) = old;
|
||||||
WireModel::CYAN,
|
preview
|
||||||
false,
|
|
||||||
))
|
|
||||||
}
|
}
|
||||||
|
Step::TopRadius | Step::TopDiameter => {
|
||||||
|
let local = self.plane.vector_to_local(point - self.center);
|
||||||
|
let old = self.top_radius;
|
||||||
|
let distance = local.x.hypot(local.y);
|
||||||
|
self.top_radius = if self.step == Step::TopDiameter {
|
||||||
|
distance * 0.5
|
||||||
|
} else {
|
||||||
|
distance
|
||||||
|
};
|
||||||
|
let preview = self.preview(0.0, self.plane.z);
|
||||||
|
self.top_radius = old;
|
||||||
|
preview
|
||||||
|
}
|
||||||
|
Step::Final => self.preview((point - self.center).dot(self.plane.z), self.plane.z),
|
||||||
|
Step::AxisEndpoint => {
|
||||||
|
let vector = point - self.center;
|
||||||
|
let height = vector.length();
|
||||||
|
(height > EPSILON).then(|| self.preview(height, vector / height)).flatten()
|
||||||
|
}
|
||||||
|
Step::Turns | Step::TurnHeight | Step::Twist => self.preview(self.height, self.plane.z),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// ── Autocomplete registry ─────────────────────────────────
|
inventory::submit!(crate::command::CommandRegistration { names: &["HELIX"] });
|
||||||
inventory::submit!(crate::command::CommandRegistration { names: &["HELIX"] }); // HelixCommand
|
|
||||||
Reference in new issue
Block a user