1b-agent/OneCAD-Draft
1
0 Fork 0
forked from 1b-agent/opencadstudio-upstream
Code Pull Requests Activity

Merge pull request #944 from ramox81/codex/complete-3dmesh-parity

Browse Source 
Complete 3D polygon mesh properties and editing behavior
This commit is contained in:
Hakan Seven authored and GitHub committed 2026-08-31 19:15:22 +03:00
2 parents 3e45cff72f 470e22c80f
commit d80898f2ca
9 files changed
+262 -112
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

locales/en-US/opencadstudio.ftl
+1 -1
View File
@@ -2829,7 +2829,7 @@ properties =
.point-y = Point Y
.point-z = Point Z
.polyfacemesh = PolyfaceMesh
.polygonmesh = PolygonMesh
.polygonmesh = Polygon Mesh
.polyline2d = Polyline2D
.polyline3d = 3D Polyline
.predefined = Predefined
src/app/commands/inquiry.rs
+11 -1
View File
@@ -253,6 +253,7 @@ impl OpenCADStudio {
is_poly: true,
convertible: false,
mesh_size: None,
mesh_closed: None,
},
)),
acadrust::EntityType::Line(_) | acadrust::EntityType::Arc(_) => {
@@ -262,6 +263,7 @@ impl OpenCADStudio {
is_poly: false,
convertible: true,
mesh_size: None,
mesh_closed: None,
},
))
}
@@ -274,6 +276,7 @@ impl OpenCADStudio {
mesh.m_vertex_count.max(0) as usize,
mesh.n_vertex_count.max(0) as usize,
)),
mesh_closed: Some((mesh.is_closed_m(), mesh.is_closed_n())),
},
)),
_ => None,
@@ -284,7 +287,14 @@ impl OpenCADStudio {
// the convert prompt) skips the select step.
let preselected: Vec<acadrust::Handle> =
self.tabs[i].scene.selected.iter().copied().collect();
let cmd_obj = PeditCommand::new(info).with_preselection(&preselected);
let header = &self.tabs[i].scene.document.header;
let cmd_obj = PeditCommand::new(
info,
header.surface_type,
header.surface_u_density,
header.surface_v_density,
)
.with_preselection(&preselected);
self.command_line.push_info(&cmd_obj.prompt());
self.tabs[i].active_cmd = Some(Box::new(cmd_obj));
}
src/app/commands/styleprops.rs
+21 -18
View File
@@ -1667,33 +1667,36 @@ impl OpenCADStudio {
None => Ok((format!("SPLINESEGS = {}", h.spline_segments), false)),
},
"SURFU" => match &value {
Some(v) => v
.parse::<i16>()
.map(|x| {
Some(v) => match v.parse::<i16>() {
Ok(x @ 0..=200) => {
h.surface_u_density = x;
(format!("SURFU = {x}"), true)
})
.map_err(|_| "SETVAR: integer value required.".into()),
Ok((format!("SURFU = {x}"), true))
}
Ok(_) => Err("SETVAR: value must be between 0 and 200.".into()),
Err(_) => Err("SETVAR: integer value required.".into()),
},
None => Ok((format!("SURFU = {}", h.surface_u_density), false)),
},
"SURFV" => match &value {
Some(v) => v
.parse::<i16>()
.map(|x| {
Some(v) => match v.parse::<i16>() {
Ok(x @ 0..=200) => {
h.surface_v_density = x;
(format!("SURFV = {x}"), true)
})
.map_err(|_| "SETVAR: integer value required.".into()),
Ok((format!("SURFV = {x}"), true))
}
Ok(_) => Err("SETVAR: value must be between 0 and 200.".into()),
Err(_) => Err("SETVAR: integer value required.".into()),
},
None => Ok((format!("SURFV = {}", h.surface_v_density), false)),
},
"SURFTYPE" => match &value {
Some(v) => v
.parse::<i16>()
.map(|x| {
Some(v) => match v.parse::<i16>() {
Ok(x @ (5 | 6 | 8)) => {
h.surface_type = x;
(format!("SURFTYPE = {x}"), true)
})
.map_err(|_| "SETVAR: integer value required.".into()),
Ok((format!("SURFTYPE = {x}"), true))
}
Ok(_) => Err("SETVAR: value must be 5, 6, or 8.".into()),
Err(_) => Err("SETVAR: integer value required.".into()),
},
None => Ok((format!("SURFTYPE = {}", h.surface_type), false)),
},
"SHADEDGE" => match &value {
src/app/update/command.rs
+8 -1
View File
@@ -2628,7 +2628,10 @@ pub(super) fn on_tab_close(&mut self, idx: usize) -> Task<Message> {
} else {
raw_val
};
if matches!(field, "current_fit_point" | "current_control_point") {
if matches!(
field,
"current_fit_point" | "current_control_point" | "pm_current_vertex"
) {
let count = handles
.iter()
.filter_map(|handle| {
@@ -2644,6 +2647,10 @@ pub(super) fn on_tab_close(&mut self, idx: usize) -> Task<Message> {
) => Some(
crate::entities::spline::control_vertex_count(spline),
),
(
"pm_current_vertex",
acadrust::EntityType::PolygonMesh(mesh),
) => Some(mesh.vertices.len()),
_ => None,
}
})
src/entities/mesh.rs
+39 -41
View File
@@ -306,13 +306,15 @@ fn polygon_mesh_display(mesh: &PolygonMesh) -> (Vec<[f64; 3]>, usize, usize) {
return (base, m, n);
}
let degree = match mesh.smooth_type {
let (u_degree, v_degree) = match mesh.smooth_type {
SurfaceSmoothType::NoSmooth => return (base, m, n),
SurfaceSmoothType::Quadratic => 2,
SurfaceSmoothType::Cubic | SurfaceSmoothType::Bezier => 3,
SurfaceSmoothType::Quadratic => (2.min(m.saturating_sub(1)), 2.min(n.saturating_sub(1))),
SurfaceSmoothType::Cubic => (3.min(m.saturating_sub(1)), 3.min(n.saturating_sub(1))),
// A Bezier surface uses every row/column in its polynomial patch.
// Giving it the cubic B-spline degree made both choices render the
// same surface even though the stored mesh type was different.
SurfaceSmoothType::Bezier => (m.saturating_sub(1), n.saturating_sub(1)),
};
let u_degree = degree.min(m.saturating_sub(1));
let v_degree = degree.min(n.saturating_sub(1));
if u_degree == 0 || v_degree == 0 {
return (base, m, n);
}
@@ -329,10 +331,10 @@ fn polygon_mesh_display(mesh: &PolygonMesh) -> (Vec<[f64; 3]>, usize, usize) {
let display_m = usize::try_from(mesh.m_smooth_density.max(2))
.unwrap_or(2)
.min(256);
.min(200);
let display_n = usize::try_from(mesh.n_smooth_density.max(2))
.unwrap_or(2)
.min(256);
.min(200);
let parameter = |index: usize, count: usize, closed: bool| {
if closed {
index as f64 / count as f64
@@ -449,24 +451,16 @@ impl PropertyEditable for PolygonMesh {
let current = crate::scene::view::dispatch::prop_current_vertex()
.min(vertex_count.saturating_sub(1));
let vertex = self.vertices.get(current);
let display = if vertex_count == 0 {
"—".to_string()
} else {
format!("{} / {}", current + 1, vertex_count)
};
let smoothed = self.smooth_type != SurfaceSmoothType::NoSmooth;
let density_prop = |label: &str, field: &'static str, value: i16| {
if smoothed {
edit_scalar(label, field, value as f64)
} else {
ro(label, field, value.to_string())
}
};
let current_vertex = if vertex_count == 0 { 0 } else { current + 1 };
vec![
PropSection {
title: t!("Geometry").into_owned(),
props: vec![
stepper(t!("Current Vertex").as_ref(), "pm_current_vertex", display),
edit_scalar(
t!("Current Vertex").as_ref(),
"pm_current_vertex",
current_vertex as f64,
),
edit(t!("Vertex X").as_ref(),
"pm_vx",
vertex.map_or(0.0, |vertex| vertex.location.x),
@@ -479,26 +473,34 @@ impl PropertyEditable for PolygonMesh {
"pm_vz",
vertex.map_or(0.0, |vertex| vertex.location.z),
),
ro(t!("M vertex count").as_ref(), "pm_m", self.m_vertex_count.to_string()),
ro(t!("N vertex count").as_ref(), "pm_n", self.n_vertex_count.to_string()),
Property {
label: t!("M closed").into_owned(),
field: "pm_closed_m",
value: PropValue::BoolToggle {
field: "pm_closed_m",
value: self.is_closed_m(),
value: PropValue::Choice {
selected: if self.is_closed_m() { "Yes" } else { "No" }.to_string(),
options: vec!["No".to_string(), "Yes".to_string()],
},
},
Property {
label: t!("N closed").into_owned(),
field: "pm_closed_n",
value: PropValue::BoolToggle {
field: "pm_closed_n",
value: self.is_closed_n(),
value: PropValue::Choice {
selected: if self.is_closed_n() { "Yes" } else { "No" }.to_string(),
options: vec!["No".to_string(), "Yes".to_string()],
},
},
density_prop(t!("M density").as_ref(), "pm_smooth_m", self.m_smooth_density),
density_prop(t!("N density").as_ref(), "pm_smooth_n", self.n_smooth_density),
edit_scalar(
t!("M density").as_ref(),
"pm_smooth_m",
self.m_smooth_density as f64,
),
edit_scalar(
t!("N density").as_ref(),
"pm_smooth_n",
self.n_smooth_density as f64,
),
ro(t!("M vertex count").as_ref(), "pm_m", self.m_vertex_count.to_string()),
ro(t!("N vertex count").as_ref(), "pm_n", self.n_vertex_count.to_string()),
],
},
PropSection {
@@ -559,26 +561,22 @@ impl PropertyEditable for PolygonMesh {
};
self.smooth_type = smooth;
if self.smooth_type != SurfaceSmoothType::NoSmooth {
if !(2..=256).contains(&self.m_smooth_density) {
if !(2..=200).contains(&self.m_smooth_density) {
self.m_smooth_density = 6;
}
if !(2..=256).contains(&self.n_smooth_density) {
if !(2..=200).contains(&self.n_smooth_density) {
self.n_smooth_density = 6;
}
}
}
"pm_smooth_m" => {
if self.smooth_type != SurfaceSmoothType::NoSmooth {
if let Ok(density @ 2..=256) = value.trim().parse::<i16>() {
self.m_smooth_density = density;
}
if let Ok(density @ 0..=200) = value.trim().parse::<i16>() {
self.m_smooth_density = density;
}
}
"pm_smooth_n" => {
if self.smooth_type != SurfaceSmoothType::NoSmooth {
if let Ok(density @ 2..=256) = value.trim().parse::<i16>() {
self.n_smooth_density = density;
}
if let Ok(density @ 0..=200) = value.trim().parse::<i16>() {
self.n_smooth_density = density;
}
}
"pm_vx" | "pm_vy" | "pm_vz" => {
src/entities/names.rs
+1 -1
View File
@@ -33,7 +33,7 @@ pub fn ui_name(e: &EntityType) -> &'static str {
EntityType::Polyline2D(_) => "Polyline2D",
EntityType::Polyline3D(_) => "Polyline3D",
EntityType::PolyfaceMesh(_) => "PolyfaceMesh",
EntityType::PolygonMesh(_) => "PolygonMesh",
EntityType::PolygonMesh(_) => "Polygon Mesh",
EntityType::Text(_) => "Text",
EntityType::MText(_) => "MText",
EntityType::Dimension(_) => "Dimension",
src/locale_catalog.rs
+1 -1
View File
@@ -2067,7 +2067,7 @@ pub(super) fn message_attribute(source: &str) -> Option<(&'static str, &'static
"Polygon - Circumscribed" => Some(("draw", "polygon-circumscribed")),
"Polygon - Edge" => Some(("draw", "polygon-edge")),
"Polygon - Inscribed" => Some(("draw", "polygon-inscribed")),
"PolygonMesh" => Some(("properties", "polygonmesh")),
"Polygon Mesh" => Some(("properties", "polygonmesh")),
"Polygonal" => Some(("layout", "polygonal")),
"Polyline" => Some(("common", "polyline")),
"Polyline broken at vertex." => Some(("command", "polyline-broken-at-vertex")),
src/modules/draw/modify/pedit.rs
+179 -47
View File
@@ -22,6 +22,9 @@ pub struct PeditTarget {
pub convertible: bool,
/// M/N size for a legacy polygon mesh; absent for ordinary polylines.
pub mesh_size: Option<(usize, usize)>,
/// Current M/N closure state for a polygon mesh. The option list exposes
/// only the operation applicable to each direction.
pub mesh_closed: Option<(bool, bool)>,
}
enum Mode {
@@ -43,15 +46,40 @@ pub struct PeditCommand {
info: HashMap<u64, PeditTarget>,
mode: Mode,
undo_count: usize,
mesh_smooth_type: acadrust::entities::polygon_mesh::SurfaceSmoothType,
mesh_smooth_density: (i16, i16),
mesh_vertex_default: isize,
pending_mesh_closed: Option<(bool, bool)>,
mesh_closed_history: Vec<Option<(bool, bool)>>,
}
impl PeditCommand {
pub fn new(info: HashMap<u64, PeditTarget>) -> Self {
pub fn new(
info: HashMap<u64, PeditTarget>,
surface_type: i16,
surface_u_density: i16,
surface_v_density: i16,
) -> Self {
use acadrust::entities::polygon_mesh::SurfaceSmoothType;
let mesh_smooth_type = match surface_type {
5 => SurfaceSmoothType::Quadratic,
8 => SurfaceSmoothType::Bezier,
_ => SurfaceSmoothType::Cubic,
};
Self {
target: None,
info,
mode: Mode::PickTarget,
undo_count: 0,
mesh_smooth_type,
mesh_smooth_density: (
surface_u_density.clamp(2, 200),
surface_v_density.clamp(2, 200),
),
mesh_vertex_default: 1,
pending_mesh_closed: None,
mesh_closed_history: Vec::new(),
}
}
@@ -79,6 +107,37 @@ impl PeditCommand {
let handle = self.target?;
self.info.get(&handle.value())?.mesh_size
}
fn mesh_closed(&self) -> Option<(bool, bool)> {
let handle = self.target?;
self.info.get(&handle.value())?.mesh_closed
}
fn set_mesh_closed(&mut self, m_direction: bool, closed: bool) {
let Some(handle) = self.target else {
return;
};
let Some(target) = self.info.get_mut(&handle.value()) else {
return;
};
let Some((closed_m, closed_n)) = target.mesh_closed.as_mut() else {
return;
};
if m_direction {
*closed_m = closed;
} else {
*closed_n = closed;
}
}
fn replace_mesh_closed(&mut self, closed: (bool, bool)) {
let Some(handle) = self.target else {
return;
};
if let Some(target) = self.info.get_mut(&handle.value()) {
target.mesh_closed = Some(closed);
}
}
}
impl CadCommand for PeditCommand {
@@ -118,17 +177,26 @@ impl CadCommand for PeditCommand {
fn options(&self) -> Vec<crate::command::CmdOption> {
use crate::command::CmdOption;
match &self.mode {
Mode::Options if self.mesh_size().is_some() => vec![
CmdOption::new(t!("Edit vertex").as_ref(), "E"),
CmdOption::new(t!("Smooth surface").as_ref(), "S"),
CmdOption::new(t!("Desmooth").as_ref(), "D"),
CmdOption::new(t!("M close").as_ref(), "MC"),
CmdOption::new(t!("M open").as_ref(), "MO"),
CmdOption::new(t!("N close").as_ref(), "NC"),
CmdOption::new(t!("N open").as_ref(), "NO"),
CmdOption::new(t!("Undo").as_ref(), "U"),
CmdOption::new(t!("eXit").as_ref(), "X"),
],
Mode::Options if self.mesh_size().is_some() => {
let (closed_m, closed_n) = self.mesh_closed().unwrap_or((false, false));
vec![
CmdOption::new(t!("Edit vertex").as_ref(), "E"),
CmdOption::new(t!("Smooth surface").as_ref(), "S"),
CmdOption::new(t!("Desmooth").as_ref(), "D"),
if closed_m {
CmdOption::new(t!("M open").as_ref(), "MO")
} else {
CmdOption::new(t!("M close").as_ref(), "MC")
},
if closed_n {
CmdOption::new(t!("N open").as_ref(), "NO")
} else {
CmdOption::new(t!("N close").as_ref(), "NC")
},
CmdOption::new(t!("Undo").as_ref(), "U"),
CmdOption::new(t!("eXit").as_ref(), "X"),
]
}
Mode::Options => vec![
CmdOption::new(t!("Close").as_ref(), "C"),
CmdOption::new(t!("Open").as_ref(), "O"),
@@ -214,6 +282,7 @@ impl CadCommand for PeditCommand {
is_poly: true,
convertible: false,
mesh_size: None,
mesh_closed: None,
},
);
self.target = Some(nh);
@@ -223,6 +292,13 @@ impl CadCommand for PeditCommand {
fn on_pedit_applied(&mut self) {
self.undo_count = self.undo_count.saturating_add(1);
if let Some((m_direction, closed)) = self.pending_mesh_closed.take() {
let previous = self.mesh_closed();
self.mesh_closed_history.push(previous);
self.set_mesh_closed(m_direction, closed);
} else {
self.mesh_closed_history.push(None);
}
}
fn wants_text_input(&self) -> bool {
@@ -230,6 +306,7 @@ impl CadCommand for PeditCommand {
}
fn on_text_input(&mut self, text: &str) -> Option<CmdResult> {
self.pending_mesh_closed = None;
let up = text.trim().to_uppercase();
let mesh_size = self.mesh_size();
match &mut self.mode {
@@ -273,12 +350,21 @@ impl CadCommand for PeditCommand {
let row = *index / n;
let column = *index % n;
match up.as_str() {
"N" | "NEXT" => *index = (*index + 1) % count,
"P" | "PREVIOUS" => *index = (*index + count - 1) % count,
"L" | "LEFT" => *index = row * n + (column + n - 1) % n,
"R" | "RIGHT" => *index = row * n + (column + 1) % n,
"U" | "UP" => *index = ((row + m - 1) % m) * n + column,
"D" | "DOWN" => *index = ((row + 1) % m) * n + column,
"N" | "NEXT" => {
self.mesh_vertex_default = 1;
if *index + 1 < count {
*index += 1;
}
}
"P" | "PREVIOUS" => {
self.mesh_vertex_default = -1;
*index = index.saturating_sub(1);
}
"L" | "LEFT" if column > 0 => *index -= 1,
"R" | "RIGHT" if column + 1 < n => *index += 1,
"U" | "UP" if row + 1 < m => *index += n,
"D" | "DOWN" if row > 0 => *index -= n,
"L" | "LEFT" | "R" | "RIGHT" | "U" | "UP" | "D" | "DOWN" => {}
"M" | "MOVE" => self.mode = Mode::MeshVertexMove(*index),
"G" | "REGEN" => {
// Mesh display is regenerated after every edit; keep the
@@ -300,34 +386,54 @@ impl CadCommand for PeditCommand {
}
"S" | "SMOOTH" | "SMOOTH SURFACE" => Some(CmdResult::PeditOp {
handle,
op: PeditOp::SetMeshSmooth(
acadrust::entities::polygon_mesh::SurfaceSmoothType::Quadratic,
),
op: PeditOp::SetMeshSmooth {
smooth: self.mesh_smooth_type,
m_density: self.mesh_smooth_density.0,
n_density: self.mesh_smooth_density.1,
},
}),
"D" | "DESMOOTH" => Some(CmdResult::PeditOp {
handle,
op: PeditOp::SetMeshSmooth(
acadrust::entities::polygon_mesh::SurfaceSmoothType::NoSmooth,
),
}),
"MC" | "MCLOSE" | "M CLOSE" => Some(CmdResult::PeditOp {
handle,
op: PeditOp::SetMeshClosedM(true),
}),
"MO" | "MOPEN" | "M OPEN" => Some(CmdResult::PeditOp {
handle,
op: PeditOp::SetMeshClosedM(false),
}),
"NC" | "NCLOSE" | "N CLOSE" => Some(CmdResult::PeditOp {
handle,
op: PeditOp::SetMeshClosedN(true),
}),
"NO" | "NOPEN" | "N OPEN" => Some(CmdResult::PeditOp {
handle,
op: PeditOp::SetMeshClosedN(false),
op: PeditOp::SetMeshSmooth {
smooth:
acadrust::entities::polygon_mesh::SurfaceSmoothType::NoSmooth,
m_density: self.mesh_smooth_density.0,
n_density: self.mesh_smooth_density.1,
},
}),
"MC" | "MCLOSE" | "M CLOSE" => {
self.pending_mesh_closed = Some((true, true));
Some(CmdResult::PeditOp {
handle,
op: PeditOp::SetMeshClosedM(true),
})
}
"MO" | "MOPEN" | "M OPEN" => {
self.pending_mesh_closed = Some((true, false));
Some(CmdResult::PeditOp {
handle,
op: PeditOp::SetMeshClosedM(false),
})
}
"NC" | "NCLOSE" | "N CLOSE" => {
self.pending_mesh_closed = Some((false, true));
Some(CmdResult::PeditOp {
handle,
op: PeditOp::SetMeshClosedN(true),
})
}
"NO" | "NOPEN" | "N OPEN" => {
self.pending_mesh_closed = Some((false, false));
Some(CmdResult::PeditOp {
handle,
op: PeditOp::SetMeshClosedN(false),
})
}
"U" | "UNDO" if self.undo_count > 0 => {
self.undo_count -= 1;
if let Some(Some(closed)) = self.mesh_closed_history.pop() {
self.replace_mesh_closed(closed);
}
Some(CmdResult::UndoDocument)
}
"U" | "UNDO" => Some(CmdResult::NeedPoint),
@@ -398,7 +504,9 @@ impl CadCommand for PeditCommand {
}
fn on_enter(&mut self) -> CmdResult {
match &self.mode {
let mesh_size = self.mesh_size();
let vertex_default = self.mesh_vertex_default;
match &mut self.mode {
Mode::JoinGather(list) if list.len() >= 2 => CmdResult::JoinEntities(list.clone()),
Mode::JoinGather(_) => {
self.mode = Mode::Options;
@@ -408,6 +516,20 @@ impl CadCommand for PeditCommand {
handle: *h,
op: PeditOp::ConvertToPolyline,
},
Mode::MeshVertex(index) => {
let Some((m, n)) = mesh_size else {
return CmdResult::NeedPoint;
};
let count = m.saturating_mul(n);
if vertex_default >= 0 {
if *index + 1 < count {
*index += 1;
}
} else {
*index = index.saturating_sub(1);
}
CmdResult::NeedPoint
}
_ => CmdResult::Cancel,
}
}
@@ -426,7 +548,11 @@ pub enum PeditOp {
Decurve,
SetMeshClosedM(bool),
SetMeshClosedN(bool),
SetMeshSmooth(acadrust::entities::polygon_mesh::SurfaceSmoothType),
SetMeshSmooth {
smooth: acadrust::entities::polygon_mesh::SurfaceSmoothType,
m_density: i16,
n_density: i16,
},
MoveMeshVertex { index: usize, point: DVec3 },
}
@@ -503,19 +629,25 @@ pub fn apply_pedit(entity: &mut EntityType, op: &PeditOp) -> bool {
}
_ => false,
},
PeditOp::SetMeshSmooth(smooth) => match entity {
PeditOp::SetMeshSmooth {
smooth,
m_density,
n_density,
} => match entity {
EntityType::PolygonMesh(mesh) => {
let mut changed = mesh.smooth_type != *smooth;
mesh.smooth_type = *smooth;
if mesh.smooth_type
!= acadrust::entities::polygon_mesh::SurfaceSmoothType::NoSmooth
{
if !(2..=256).contains(&mesh.m_smooth_density) {
mesh.m_smooth_density = 6;
let m_density = (*m_density).clamp(2, 200);
let n_density = (*n_density).clamp(2, 200);
if mesh.m_smooth_density != m_density {
mesh.m_smooth_density = m_density;
changed = true;
}
if !(2..=256).contains(&mesh.n_smooth_density) {
mesh.n_smooth_density = 6;
if mesh.n_smooth_density != n_density {
mesh.n_smooth_density = n_density;
changed = true;
}
}
src/ui/properties.rs
+1 -1
View File
@@ -1788,7 +1788,7 @@ fn coord_suffix(label: &str) -> Option<(&str, usize)> {
/// Length of the coordinate group starting at `idx`: consecutive text rows
/// labelled "<Base> X", "<Base> Y" and optionally "<Base> Z". 0/1 = no group.
fn coord_group_len(props: &[crate::scene::model::object::Property], idx: usize) -> usize {
if props[idx].field == "pl3_vertex_x" {
if matches!(props[idx].field, "pl3_vertex_x" | "pm_vx") {
return 0;
}
let groupable = |p: &crate::scene::model::object::Property| {