#[macro_export]
macro_rules! scad {
($($body:tt)*) => { $crate::__scad_group!($($body)*) };
}
#[doc(hidden)]
#[macro_export]
macro_rules! __scad_group {
($($b:tt)*) => {{
let mut __nodes: ::std::vec::Vec<$crate::Solid> = $crate::__scad_list!([] $($b)*);
if __nodes.len() == 1 {
__nodes.pop().unwrap()
} else {
$crate::union_all(__nodes)
}
}};
}
#[doc(hidden)]
#[macro_export]
macro_rules! __scad_list {
([$($acc:expr,)*]) => { ::std::vec![$($acc),*] };
([$($acc:expr,)*] $p:ident ( $($a:tt)* ) { $($body:tt)* } $($rest:tt)*) => {
$crate::__scad_list!([$($acc,)* $crate::__scad_parent!($p ( $($a)* ) { $($body)* }),] $($rest)*)
};
([$($acc:expr,)*] $e:expr ; $($rest:tt)*) => {
$crate::__scad_list!([$($acc,)* $e,] $($rest)*)
};
}
#[doc(hidden)]
#[macro_export]
macro_rules! __scad_parent {
(union ( ) { $($b:tt)* }) => { $crate::union_all($crate::__scad_list!([] $($b)*)) };
(difference ( ) { $($b:tt)* }) => { $crate::difference_all($crate::__scad_list!([] $($b)*)) };
(intersection ( ) { $($b:tt)* }) => { $crate::intersection_all($crate::__scad_list!([] $($b)*)) };
(hull ( ) { $($b:tt)* }) => { $crate::hull($crate::__scad_list!([] $($b)*)) };
(translate ( $t:expr ) { $($b:tt)* }) => { $crate::__scad_group!($($b)*).translate($t) };
(rotate ( $t:expr ) { $($b:tt)* }) => { $crate::__scad_group!($($b)*).rotate($t) };
(scale ( $t:expr ) { $($b:tt)* }) => { $crate::__scad_group!($($b)*).scale($t) };
(mirror ( $t:expr ) { $($b:tt)* }) => { $crate::__scad_group!($($b)*).mirror($t) };
}
#[macro_export]
macro_rules! union {
($iter:expr $(,)?) => { $crate::union_all(::std::iter::IntoIterator::into_iter($iter).collect()) };
($first:expr, $($rest:expr),+ $(,)?) => { $crate::union_all(::std::vec![$first, $($rest),+]) };
}
#[macro_export]
macro_rules! difference {
($iter:expr $(,)?) => { $crate::difference_all(::std::iter::IntoIterator::into_iter($iter).collect()) };
($first:expr, $($rest:expr),+ $(,)?) => { $crate::difference_all(::std::vec![$first, $($rest),+]) };
}
#[macro_export]
macro_rules! intersection {
($iter:expr $(,)?) => { $crate::intersection_all(::std::iter::IntoIterator::into_iter($iter).collect()) };
($first:expr, $($rest:expr),+ $(,)?) => { $crate::intersection_all(::std::vec![$first, $($rest),+]) };
}
#[macro_export]
macro_rules! hull {
($iter:expr $(,)?) => { $crate::hull(::std::iter::IntoIterator::into_iter($iter).collect()) };
($first:expr, $($rest:expr),+ $(,)?) => { $crate::hull(::std::vec![$first, $($rest),+]) };
}
#[cfg(test)]
mod tests {
use crate::{cube, cylinder, difference_all, solid, sphere, Solid};
fn vol(s: Solid) -> f32 {
let g = s.to_geometry_exact();
let pos = match g.get_attribute("position") {
Some(a) => a.array.clone(),
None => return 0.0,
};
let v = |i: usize| [pos[i * 3], pos[i * 3 + 1], pos[i * 3 + 2]];
let tri = |a: [f32; 3], b: [f32; 3], c: [f32; 3]| {
(a[0] * (b[1] * c[2] - b[2] * c[1]) - a[1] * (b[0] * c[2] - b[2] * c[0])
+ a[2] * (b[0] * c[1] - b[1] * c[0]))
/ 6.0
};
let mut total = 0.0;
if let Some(idx) = &g.index {
for t in idx.as_chunks::<3>().0 {
total += tri(v(t[0] as usize), v(t[1] as usize), v(t[2] as usize));
}
} else {
for k in 0..pos.len() / 9 {
total += tri(v(k * 3), v(k * 3 + 1), v(k * 3 + 2));
}
}
total.abs()
}
#[test]
fn scad_matches_fluent() {
let fluent = cube([20.0, 20.0, 20.0]).difference(cylinder(30.0, 6.0));
let declarative = scad! {
difference() {
cube([20.0, 20.0, 20.0]);
cylinder(30.0, 6.0);
}
};
let (a, b) = (vol(fluent), vol(declarative));
assert!((a - b).abs() < 1.0, "scad! {b} != fluent {a}");
assert!(
b < 8000.0 && b > 5000.0,
"unexpected drilled-box volume {b}"
);
}
#[test]
fn nested_and_implicit_union() {
let m = scad! {
union() {
cube([10.0, 10.0, 10.0]);
translate([20.0, 0.0, 0.0]) {
sphere(5.0);
translate([0.0, 0.0, 8.0]) { sphere(5.0); }
}
}
};
let v = vol(m);
assert!((v - (1000.0 + 2.0 * 523.6)).abs() < 60.0, "volume {v}");
}
#[test]
fn escape_hatch_splices_rust_values() {
let pins: Vec<Solid> = (0..4)
.map(|i| cube([2.0, 2.0, 2.0]).translate([i as f32 * 6.0, 0.0, 0.0]))
.collect();
let spliced = scad! {
union() {
solid(union!(pins));
translate([0.0, 10.0, 0.0]) { cube([2.0, 2.0, 2.0]); }
}
};
let v = vol(spliced);
assert!((v - 40.0).abs() < 1.0, "spliced volume {v}");
}
#[test]
fn variadic_boolean_macros() {
let holes = [
cylinder(30.0, 2.0).translate([-6.0, 0.0, 0.0]),
cylinder(30.0, 2.0).translate([6.0, 0.0, 0.0]),
];
let macro_form = difference![cube([20.0, 20.0, 20.0]), holes[0].clone(), holes[1].clone()];
let fn_form = difference_all(vec![
cube([20.0, 20.0, 20.0]),
holes[0].clone(),
holes[1].clone(),
]);
assert!((vol(macro_form) - vol(fn_form)).abs() < 1.0);
}
#[test]
fn hull_of_solids() {
let both =
vol(cube([2.0, 2.0, 2.0]).union(cube([2.0, 2.0, 2.0]).translate([8.0, 0.0, 0.0])));
let hulled = vol(scad! {
hull() {
cube([2.0, 2.0, 2.0]);
translate([8.0, 0.0, 0.0]) { cube([2.0, 2.0, 2.0]); }
}
});
assert!(
hulled > both + 20.0,
"hull {hulled} should exceed the two cubes {both}"
);
let m = vol(hull![
cube([2.0, 2.0, 2.0]),
cube([2.0, 2.0, 2.0]).translate([8.0, 0.0, 0.0])
]);
assert!((m - hulled).abs() < 1.0, "hull! {m} != scad! hull {hulled}");
}
#[test]
fn mirror_and_rotate_preserve_volume() {
let base = cube([8.0, 4.0, 2.0]);
assert!((vol(base.clone()) - 64.0).abs() < 1e-2);
assert!((vol(base.clone().rotate([37.0, 12.0, 90.0])) - 64.0).abs() < 1e-2);
assert!((vol(base.clone().rotate_axis(45.0, [1.0, 1.0, 0.0])) - 64.0).abs() < 1e-2);
assert!((vol(base.mirror([1.0, 0.0, 0.0])) - 64.0).abs() < 1e-2);
}
}