forked from 1b-agent/opencadstudio-upstream
Hakan SevenandClaude Opus 5.5
f537aff75c
The codec and kernel repositories and crates are renamed opencadcodec and opencadkernel. Inside OCS they are depended on under short keys, so code reads `codec::`, `kernel::` and the new `graph::` (opencadgraph, the node graph engine). File-format and protocol spellings stay as they were: the ACIS product id `acadrust`, the ACADRUST_* switches and the plugin version keys `acadrust_version` / `acadrust_source`. A button left of MCP on the command line opens a translucent node graph over the viewport, with a palette of object, input, math, logic, list, text and geometry nodes added by click or drag. An object node owns drawing entities and its rows are the Properties panel's own rows for them: the single-object page is extracted from refresh_properties as entity_property_sections, values use the control protocol's property_json, and writes go through set_property_value with a property target override, so the panel, MCP and the graph share one read/write path. A list reaching an object row makes one entity per element. Each graph action is one undo step; the canvas pans and zooms. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
507 lines
19 KiB
Rust
507 lines
19 KiB
Rust
//! Light entity display glyph (point / spot / distant).
|
||
//!
|
||
//! Lights are nonprint helper entities: the DWG reader decodes the source
|
||
//! position and aim point (see `opencadcodec`'s `Light`); here we synthesize a
|
||
//! wireframe glyph so the light is visible and selectable in the editor, the
|
||
//! same way AutoCAD shows a light symbol.
|
||
//!
|
||
//! The glyph is sized in **screen space** (a roughly constant pixel size across
|
||
//! zoom) via [`relative_render`], falling back to a small fixed world size when
|
||
//! no world-per-pixel factor is available (e.g. snapshot tessellation).
|
||
|
||
use codec::entities::Light;
|
||
use codec::EntityType;
|
||
use crate::t;
|
||
|
||
use crate::command::EntityTransform;
|
||
use crate::entities::common::{
|
||
center_grip, edit_angle_prop, edit_prop as edit, ro_prop, square_grip,
|
||
};
|
||
use crate::entities::traits::{Grippable, PropertyEditable, Transformable, RenderConvertible};
|
||
use crate::scene::convert::acad_to_render::{RenderEntity, RenderObject};
|
||
use crate::scene::model::object::{GripApply, GripDef, PropSection, PropValue, Property};
|
||
use crate::scene::model::wire_model::SnapHint;
|
||
|
||
/// On-screen glyph radius in pixels for the screen-relative path.
|
||
const GLYPH_PX: f64 = 16.0;
|
||
/// Fixed world-space glyph radius used when no zoom factor is available.
|
||
const FIXED_WORLD: f64 = 2.0;
|
||
|
||
// ── vector helpers (f64, absolute world space) ─────────────────────────────
|
||
|
||
fn sub(a: [f64; 3], b: [f64; 3]) -> [f64; 3] {
|
||
[a[0] - b[0], a[1] - b[1], a[2] - b[2]]
|
||
}
|
||
fn add(a: [f64; 3], b: [f64; 3]) -> [f64; 3] {
|
||
[a[0] + b[0], a[1] + b[1], a[2] + b[2]]
|
||
}
|
||
fn scale(a: [f64; 3], s: f64) -> [f64; 3] {
|
||
[a[0] * s, a[1] * s, a[2] * s]
|
||
}
|
||
fn cross(a: [f64; 3], b: [f64; 3]) -> [f64; 3] {
|
||
[
|
||
a[1] * b[2] - a[2] * b[1],
|
||
a[2] * b[0] - a[0] * b[2],
|
||
a[0] * b[1] - a[1] * b[0],
|
||
]
|
||
}
|
||
fn norm(a: [f64; 3]) -> [f64; 3] {
|
||
let l = (a[0] * a[0] + a[1] * a[1] + a[2] * a[2]).sqrt();
|
||
if l < 1e-12 {
|
||
[0.0, 0.0, 0.0]
|
||
} else {
|
||
[a[0] / l, a[1] / l, a[2] / l]
|
||
}
|
||
}
|
||
|
||
fn pos(l: &Light) -> [f64; 3] {
|
||
[l.position.x, l.position.y, l.position.z]
|
||
}
|
||
fn tgt(l: &Light) -> [f64; 3] {
|
||
[l.target.x, l.target.y, l.target.z]
|
||
}
|
||
|
||
/// Unit aim direction (position → target), defaulting to straight down when
|
||
/// the target coincides with the source (point lights carry no meaningful aim).
|
||
fn aim(l: &Light) -> [f64; 3] {
|
||
let d = norm(sub(tgt(l), pos(l)));
|
||
if d == [0.0, 0.0, 0.0] {
|
||
[0.0, 0.0, -1.0]
|
||
} else {
|
||
d
|
||
}
|
||
}
|
||
|
||
/// Two unit axes spanning the plane perpendicular to `a`.
|
||
fn perp_basis(a: [f64; 3]) -> ([f64; 3], [f64; 3]) {
|
||
let up = if a[2].abs() > 0.9 {
|
||
[1.0, 0.0, 0.0]
|
||
} else {
|
||
[0.0, 0.0, 1.0]
|
||
};
|
||
let u = norm(cross(up, a));
|
||
let v = cross(a, u);
|
||
(u, v)
|
||
}
|
||
|
||
const NAN: [f64; 3] = [f64::NAN, f64::NAN, f64::NAN];
|
||
|
||
/// Append a disconnected segment, NaN-separated from prior geometry.
|
||
fn push_seg(out: &mut Vec<[f64; 3]>, a: [f64; 3], b: [f64; 3]) {
|
||
if !out.is_empty() {
|
||
out.push(NAN);
|
||
}
|
||
out.push(a);
|
||
out.push(b);
|
||
}
|
||
|
||
/// Append a closed ring of radius `r` in the (u, v) plane about `c`.
|
||
fn push_ring(out: &mut Vec<[f64; 3]>, c: [f64; 3], u: [f64; 3], v: [f64; 3], r: f64, n: usize) {
|
||
if !out.is_empty() {
|
||
out.push(NAN);
|
||
}
|
||
for i in 0..=n {
|
||
let a = i as f64 * std::f64::consts::TAU / n as f64;
|
||
let (ca, sa) = (a.cos() * r, a.sin() * r);
|
||
out.push([
|
||
c[0] + u[0] * ca + v[0] * sa,
|
||
c[1] + u[1] * ca + v[1] * sa,
|
||
c[2] + u[2] * ca + v[2] * sa,
|
||
]);
|
||
}
|
||
}
|
||
|
||
/// Build the light glyph wire (absolute world coordinates) at radius `r`.
|
||
fn light_wire(l: &Light, r: f64) -> Vec<[f64; 3]> {
|
||
let p = pos(l);
|
||
let mut out: Vec<[f64; 3]> = Vec::new();
|
||
match l.light_type {
|
||
// ── Spot (cone / flashlight) ──────────────────────────────────────
|
||
3 => {
|
||
let a = aim(l);
|
||
let (u, v) = perp_basis(a);
|
||
let len = r * 2.4;
|
||
let base_r = r;
|
||
let c = add(p, scale(a, len));
|
||
// Emitter ring at the source.
|
||
push_ring(&mut out, p, u, v, r * 0.35, 12);
|
||
// Cone mouth + rays from the source to the rim.
|
||
push_ring(&mut out, c, u, v, base_r, 16);
|
||
for k in 0..4 {
|
||
let ang = k as f64 * std::f64::consts::FRAC_PI_2;
|
||
let rim = add(
|
||
c,
|
||
add(scale(u, ang.cos() * base_r), scale(v, ang.sin() * base_r)),
|
||
);
|
||
push_seg(&mut out, p, rim);
|
||
}
|
||
}
|
||
// ── Distant (sun with parallel rays) ─────────────────────────────
|
||
1 => {
|
||
let (u, v) = ([1.0, 0.0, 0.0], [0.0, 1.0, 0.0]);
|
||
push_ring(&mut out, p, u, v, r * 0.6, 16);
|
||
// A few parallel rays streaming off toward −X.
|
||
let dir = [-1.0, 0.0, 0.0];
|
||
for k in -1..=1 {
|
||
let off = scale(v, k as f64 * r * 0.5);
|
||
let a = add(add(p, off), scale(u, r * 0.6));
|
||
let b = add(a, scale(dir, r * 1.4));
|
||
push_seg(&mut out, a, b);
|
||
}
|
||
}
|
||
// ── Point (radiant sphere) ───────────────────────────────────────
|
||
_ => {
|
||
push_ring(&mut out, p, [1.0, 0.0, 0.0], [0.0, 1.0, 0.0], r, 20);
|
||
push_ring(&mut out, p, [1.0, 0.0, 0.0], [0.0, 0.0, 1.0], r, 20);
|
||
push_ring(&mut out, p, [0.0, 1.0, 0.0], [0.0, 0.0, 1.0], r, 20);
|
||
// Short radial ticks to read as a light source.
|
||
for k in 0..4 {
|
||
let ang = k as f64 * std::f64::consts::FRAC_PI_2 + std::f64::consts::FRAC_PI_4;
|
||
let d = [ang.cos(), ang.sin(), 0.0];
|
||
push_seg(&mut out, add(p, scale(d, r)), add(p, scale(d, r * 1.5)));
|
||
}
|
||
}
|
||
}
|
||
out
|
||
}
|
||
|
||
fn build(l: &Light, r: f64) -> RenderEntity {
|
||
let p = pos(l);
|
||
let snap = glam::DVec3::new(p[0], p[1], p[2]);
|
||
let mut snap_pts = vec![(snap, SnapHint::Node)];
|
||
let mut key = vec![p];
|
||
if l.is_spot() {
|
||
let t = tgt(l);
|
||
snap_pts.push((glam::DVec3::new(t[0], t[1], t[2]), SnapHint::Node));
|
||
key.push(t);
|
||
}
|
||
RenderEntity {
|
||
pick_tris: Vec::new(),
|
||
object: RenderObject::Lines(light_wire(l, r)),
|
||
snap_pts,
|
||
tangent_geoms: vec![],
|
||
key_vertices: key,
|
||
fill_tris: vec![],
|
||
}
|
||
}
|
||
|
||
/// Viewport-aware glyph: constant on-screen size from the world-per-pixel
|
||
/// factor. Returns `None` for a non-light entity or when no factor is
|
||
/// available (the caller then falls back to the fixed-world [`to_render`]).
|
||
pub fn relative_render(
|
||
entity: &EntityType,
|
||
_document: &codec::CadDocument,
|
||
wpp: Option<f32>,
|
||
) -> Option<RenderEntity> {
|
||
let EntityType::Light(l) = entity else {
|
||
return None;
|
||
};
|
||
let w = wpp.filter(|w| *w > 0.0)? as f64;
|
||
Some(build(l, w * GLYPH_PX))
|
||
}
|
||
|
||
impl RenderConvertible for Light {
|
||
fn to_render(&self, _document: &codec::CadDocument) -> Option<RenderEntity> {
|
||
Some(build(self, FIXED_WORLD))
|
||
}
|
||
}
|
||
|
||
impl Grippable for Light {
|
||
fn grips(&self) -> Vec<GripDef> {
|
||
let p = pos(self);
|
||
let mut g = vec![square_grip(0, glam::DVec3::new(p[0], p[1], p[2]))];
|
||
if self.is_spot() {
|
||
let t = tgt(self);
|
||
g.push(center_grip(1, glam::DVec3::new(t[0], t[1], t[2])));
|
||
}
|
||
g
|
||
}
|
||
|
||
fn apply_grip(&mut self, grip_id: usize, apply: GripApply) {
|
||
match (grip_id, apply) {
|
||
// Grip 0 — light source: moves the whole light (aim preserved).
|
||
(0, GripApply::Translate(d)) => {
|
||
self.position.x += d.x as f64;
|
||
self.position.y += d.y as f64;
|
||
self.position.z += d.z as f64;
|
||
self.target.x += d.x as f64;
|
||
self.target.y += d.y as f64;
|
||
self.target.z += d.z as f64;
|
||
}
|
||
(0, GripApply::Absolute(p)) => {
|
||
let dx = p.x as f64 - self.position.x;
|
||
let dy = p.y as f64 - self.position.y;
|
||
let dz = p.z as f64 - self.position.z;
|
||
self.position.x += dx;
|
||
self.position.y += dy;
|
||
self.position.z += dz;
|
||
self.target.x += dx;
|
||
self.target.y += dy;
|
||
self.target.z += dz;
|
||
}
|
||
// Grip 1 — spot target: re-aims the light.
|
||
(1, GripApply::Translate(d)) => {
|
||
self.target.x += d.x as f64;
|
||
self.target.y += d.y as f64;
|
||
self.target.z += d.z as f64;
|
||
}
|
||
(1, GripApply::Absolute(p)) => {
|
||
self.target.x = p.x as f64;
|
||
self.target.y = p.y as f64;
|
||
self.target.z = p.z as f64;
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
}
|
||
|
||
impl PropertyEditable for Light {
|
||
fn geometry_properties(&self, _text_style_names: &[String]) -> Vec<PropSection> {
|
||
let kind = match self.light_type {
|
||
1 => "Distant",
|
||
3 => "Spot",
|
||
_ => "Point",
|
||
};
|
||
let mut props = vec![
|
||
ro_prop(t!("Name").as_ref(), "li_name", self.name.clone()),
|
||
ro_prop(t!("Type").as_ref(), "li_type", kind),
|
||
edit(t!("Position X").as_ref(), "li_px", self.position.x),
|
||
edit(t!("Position Y").as_ref(), "li_py", self.position.y),
|
||
edit(t!("Position Z").as_ref(), "li_pz", self.position.z),
|
||
];
|
||
if self.light_type != 2 {
|
||
props.push(edit(t!("Target X").as_ref(), "li_tx", self.target.x));
|
||
props.push(edit(t!("Target Y").as_ref(), "li_ty", self.target.y));
|
||
props.push(edit(t!("Target Z").as_ref(), "li_tz", self.target.z));
|
||
}
|
||
let mut sections = vec![
|
||
PropSection {
|
||
title: t!("Geometry").into_owned(),
|
||
props,
|
||
},
|
||
PropSection {
|
||
title: t!("Light").into_owned(),
|
||
props: vec![
|
||
Property {
|
||
label: t!("On").into_owned(),
|
||
field: "li_status",
|
||
value: PropValue::BoolToggle {
|
||
field: "li_status",
|
||
value: self.status,
|
||
},
|
||
},
|
||
Property {
|
||
label: t!("Plot Glyph").into_owned(),
|
||
field: "li_plot_glyph",
|
||
value: PropValue::BoolToggle {
|
||
field: "li_plot_glyph",
|
||
value: self.plot_glyph,
|
||
},
|
||
},
|
||
ro_prop(t!("Color").as_ref(), "li_color", format!("{:?}", self.light_color)),
|
||
edit(t!("Intensity").as_ref(), "li_intensity", self.intensity),
|
||
Property {
|
||
label: t!("Attenuation").into_owned(),
|
||
field: "li_attenuation",
|
||
value: PropValue::Choice {
|
||
selected: match self.attenuation_type {
|
||
1 => "Inverse Linear",
|
||
2 => "Inverse Square",
|
||
_ => "None",
|
||
}
|
||
.to_string(),
|
||
options: vec![
|
||
"None".to_string(),
|
||
"Inverse Linear".to_string(),
|
||
"Inverse Square".to_string(),
|
||
],
|
||
},
|
||
},
|
||
Property {
|
||
label: t!("Use Limits").into_owned(),
|
||
field: "li_use_limits",
|
||
value: PropValue::BoolToggle {
|
||
field: "li_use_limits",
|
||
value: self.use_attenuation_limits,
|
||
},
|
||
},
|
||
edit(t!("Start Limit").as_ref(), "li_start", self.attenuation_start_limit),
|
||
edit(t!("End Limit").as_ref(), "li_end", self.attenuation_end_limit),
|
||
edit_angle_prop(t!("Hotspot Angle").as_ref(),
|
||
"li_hotspot",
|
||
self.hotspot_angle.to_degrees(),
|
||
),
|
||
edit_angle_prop(t!("Falloff Angle").as_ref(),
|
||
"li_falloff",
|
||
self.falloff_angle.to_degrees(),
|
||
),
|
||
],
|
||
},
|
||
PropSection {
|
||
title: t!("Shadows").into_owned(),
|
||
props: vec![
|
||
Property {
|
||
label: t!("Cast Shadows").into_owned(),
|
||
field: "li_shadows",
|
||
value: PropValue::BoolToggle {
|
||
field: "li_shadows",
|
||
value: self.cast_shadows,
|
||
},
|
||
},
|
||
ro_prop(t!("Type").as_ref(), "li_shadow_type", self.shadow_type.to_string()),
|
||
ro_prop(t!("Map Size").as_ref(), "li_shadow_size", self.shadow_map_size.to_string()),
|
||
ro_prop(t!("Softness").as_ref(),
|
||
"li_shadow_softness",
|
||
self.shadow_map_softness.to_string(),
|
||
),
|
||
],
|
||
},
|
||
];
|
||
if let Some(photo) = &self.photometric_data {
|
||
sections.push(PropSection {
|
||
title: t!("Photometric").into_owned(),
|
||
props: vec![
|
||
ro_prop(t!("Web File").as_ref(), "li_web_file", photo.web_file.clone()),
|
||
ro_prop(t!("Physical Method").as_ref(),
|
||
"li_physical_method",
|
||
photo.physical_intensity_method.to_string(),
|
||
),
|
||
edit(t!("Physical Intensity").as_ref(),
|
||
"li_physical_intensity",
|
||
photo.physical_intensity,
|
||
),
|
||
edit(t!("Illuminance Distance").as_ref(),
|
||
"li_illuminance_distance",
|
||
photo.illuminance_distance,
|
||
),
|
||
edit(t!("Color Temperature").as_ref(),
|
||
"li_color_temperature",
|
||
photo.lamp_color_temperature,
|
||
),
|
||
ro_prop(t!("Lamp Preset").as_ref(),
|
||
"li_lamp_preset",
|
||
photo.lamp_color_preset.to_string(),
|
||
),
|
||
ro_prop(t!("Shape").as_ref(),
|
||
"li_shape",
|
||
format!(
|
||
"{} · {:.6} × {:.6} · radius {:.6}",
|
||
photo.extended_light_shape,
|
||
photo.extended_light_length,
|
||
photo.extended_light_width,
|
||
photo.extended_light_radius
|
||
),
|
||
),
|
||
ro_prop(t!("Web").as_ref(),
|
||
"li_web",
|
||
format!(
|
||
"type {}; symmetry {}; flux {:.6}; angles {:?}; rotation {:.6},{:.6},{:.6}",
|
||
photo.web_file_type,
|
||
photo.web_symmetry,
|
||
photo.web_flux,
|
||
photo.web_angles,
|
||
photo.web_rotation.x,
|
||
photo.web_rotation.y,
|
||
photo.web_rotation.z
|
||
),
|
||
),
|
||
],
|
||
});
|
||
}
|
||
sections
|
||
}
|
||
|
||
fn apply_geom_prop(&mut self, field: &str, value: &str) {
|
||
match field {
|
||
"li_status" => {
|
||
if let Ok(value) = value.parse::<bool>() {
|
||
self.status = value;
|
||
}
|
||
return;
|
||
}
|
||
"li_plot_glyph" => {
|
||
if let Ok(value) = value.parse::<bool>() {
|
||
self.plot_glyph = value;
|
||
}
|
||
return;
|
||
}
|
||
"li_use_limits" => {
|
||
if let Ok(value) = value.parse::<bool>() {
|
||
self.use_attenuation_limits = value;
|
||
}
|
||
return;
|
||
}
|
||
"li_shadows" => {
|
||
if let Ok(value) = value.parse::<bool>() {
|
||
self.cast_shadows = value;
|
||
}
|
||
return;
|
||
}
|
||
"li_attenuation" => {
|
||
self.attenuation_type = match value {
|
||
"Inverse Linear" => 1,
|
||
"Inverse Square" => 2,
|
||
_ => 0,
|
||
};
|
||
return;
|
||
}
|
||
_ => {}
|
||
}
|
||
let Ok(v) = value.trim().parse::<f64>() else {
|
||
return;
|
||
};
|
||
match field {
|
||
"li_px" => self.position.x = v,
|
||
"li_py" => self.position.y = v,
|
||
"li_pz" => self.position.z = v,
|
||
"li_tx" => self.target.x = v,
|
||
"li_ty" => self.target.y = v,
|
||
"li_tz" => self.target.z = v,
|
||
"li_intensity" => self.intensity = v.max(0.0),
|
||
"li_start" => self.attenuation_start_limit = v,
|
||
"li_end" => self.attenuation_end_limit = v,
|
||
"li_hotspot" => self.hotspot_angle = v.to_radians(),
|
||
"li_falloff" => self.falloff_angle = v.to_radians(),
|
||
"li_physical_intensity" => {
|
||
if let Some(photo) = self.photometric_data.as_mut() {
|
||
photo.physical_intensity = v;
|
||
}
|
||
}
|
||
"li_illuminance_distance" => {
|
||
if let Some(photo) = self.photometric_data.as_mut() {
|
||
photo.illuminance_distance = v;
|
||
}
|
||
}
|
||
"li_color_temperature" => {
|
||
if let Some(photo) = self.photometric_data.as_mut() {
|
||
photo.lamp_color_temperature = v;
|
||
}
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
}
|
||
|
||
impl Transformable for Light {
|
||
fn apply_transform(&mut self, t: &EntityTransform) {
|
||
crate::scene::view::transform::apply_standard_entity_transform(
|
||
self,
|
||
t,
|
||
|entity, p1, p2| {
|
||
crate::scene::view::transform::reflect_xy_point(
|
||
&mut entity.position.x,
|
||
&mut entity.position.y,
|
||
p1,
|
||
p2,
|
||
);
|
||
crate::scene::view::transform::reflect_xy_point(
|
||
&mut entity.target.x,
|
||
&mut entity.target.y,
|
||
p1,
|
||
p2,
|
||
);
|
||
},
|
||
);
|
||
}
|
||
}
|