Factored out crates for web version

mandelia_renderer/src/transform.rs

@@ -0,0 +1,130 @@
+use num::Num;
+use super::{Float, Point};
+pub type MTransform = nalgebra::Matrix5<Float>;
+
+#[derive(Debug)]
+pub enum Type {
+    Rotation(u8, u8, Float),
+    Translation(u8, Float),
+    CoordSwap(u8, u8),
+    Scale(Float),
+}
+
+impl From<Type> for MTransform {
+    fn from(ty: Type) -> Self {
+        match ty {
+            Type::Rotation(a0, a1, _) if a0 == a1=> MTransform::identity(),
+            Type::Rotation(a0, a1, delta) => {
+                let a0 = a0 as usize;
+                let a1 = a1 as usize;
+                let delta = delta.to_radians();
+                let s = delta.sin();
+                let c = delta.cos();
+                let mut m = MTransform::identity();
+                m[(a0,a0)] = c;
+                m[(a0,a1)] = -s;
+                m[(a1,a0)] = s;
+                m[(a1,a1)] = c;
+                m
+            }
+            Type::Translation(a, delta) => {
+                let mut m = MTransform::identity();
+                m[(4, a as usize)] = -delta;
+                m
+            }
+            Type::CoordSwap(a, b) => {
+                let mut m = MTransform::identity();
+                let a = a as usize;
+                let b = b as usize;
+                m[(a,a)] = 0.;
+                m[(b,b)] = 0.;
+                m[(a,b)] = 1.;
+                m[(b,a)] = 1.;
+                m
+            }
+            Type::Scale(delta) => {
+                let mut xf = MTransform::identity() / delta;
+                xf[(4,4)] = 1.;
+                xf
+            }
+        }
+    }
+}
+fn parse_axis(c: char) -> Option<u8> {
+    Some(match c {
+        'x' => 0,
+        'y' => 1,
+        'X' => 2,
+        'Y' => 3,
+        _ => return None,
+    })
+}
+
+/// We take a type and distance.
+/// We have four axes, x,y,X,Y. The first two adjust the base point; the second two adjust the delta.
+///
+/// Given that, a plane can be defined with two axes, and a translation can be defined with one.
+/// 
+/// TODO: replace this with a nom parser
+pub fn parse_step(s: &str) -> Option<Type> {
+    if let Some(r) = s.strip_prefix("z") {
+        return Float::from_str_radix(r, 10).ok().map(Type::Scale);
+    }
+    if s.len() < 2 {
+        return None;
+    }
+    let mut chars = s.chars();
+    let axis0 = chars.next().and_then(parse_axis)?;
+    Some(match chars.clone().next()? {
+        '=' => {
+            chars.next();
+            let axis1 = chars.next().and_then(parse_axis)?;
+            Type::CoordSwap(axis0, axis1)
+        }
+        'x' | 'X' | 'y' | 'Y' => {
+            chars.next();
+            let axis1 = chars.next().and_then(parse_axis)?;
+            if axis0 == axis1 {
+                return None;
+            }
+            let val = Float::from_str_radix(chars.as_str().trim(), 10).ok()?;
+            Type::Rotation(axis0, axis1, val)
+        }
+        '0' ..= '9' => {
+            let val = Float::from_str_radix(chars.as_str().trim(), 10).ok()?;
+            Type::Translation(axis0, val)
+        }
+        _ => return None,
+    })
+}
+
+pub fn transform_to_coords(mat: &MTransform) -> super::Transform {
+    let bx = Point::new(mat[(0,0)], mat[(0,1)]);
+    let by = Point::new(mat[(1,0)], mat[(1,1)]);
+    let bd = Point::new(mat[(4,0)], mat[(4,1)]);
+
+    let cx = Point::new(mat[(0,2)], mat[(0,3)]);
+    let cy = Point::new(mat[(1,2)], mat[(1,3)]);
+    let cd = Point::new(mat[(4,2)], mat[(4,3)]);
+    [
+        (bx, cx),
+        (by, cy),
+        (bd, cd),
+    ]    
+}
+
+pub fn parse_transforms<'a>(transforms: impl Iterator<Item=impl AsRef<str>>) ->anyhow::Result<super::Transform> {
+    let mat = transforms
+        .map(|s| parse_step(s.as_ref())
+            .ok_or_else(|| anyhow::anyhow!("Invalid step: {:?}", s.as_ref())))
+            .try_fold(MTransform::identity(),
+                      |acc, new| new.map(|new| acc * MTransform::from(new)))?;
+
+
+    Ok(transform_to_coords(&mat))
+
+}
+
+pub fn parse_transform(s: &str) -> anyhow::Result<super::Transform> {
+    parse_transforms(s.split_whitespace())
+}