Parsing transform from tokens

assets/scenes/00.scene

@@ -1 +1 @@
-00/a.entity
+00/camera.entity

assets/scenes/00/a.entity

@@ -1,3 +0,0 @@
-name "Hello world"
-# camera3d
-# transform ...

assets/scenes/00/camera.entity

@@ -0,0 +1,2 @@
+camera
+; transform translation 2.0 2.0 2.0 ...

assets/scenes/00/light.entity

@@ -0,0 +1,3 @@
+; spatial3d
+; transform ...
+; pointLight color #ffffff intensity 800

assets/scenes/00/van.entity

@@ -0,0 +1,3 @@
+# spatial3d
+# transform ...
+# model "models/van.glb"

src/main.rs

@@ -32,7 +32,12 @@ fn main() {
         // .add_plugins(menu::MenuPlugin)
         // .add_plugins(window::WindowPlugin)
         .add_plugins(save::SavePlugin {
-            fns: vec![parse_save_name],
+            fns: vec![
+                parse_save_name,
+                parse_save_camera,
+                parse_save_visibility,
+                parse_save_transform,
+            ],
         })
         .run();
 }

src/parser.rs

@@ -1,3 +1,15 @@
+use bevy::{
+    core_pipeline::{
+        core_3d::graph::Core3d,
+        tonemapping::{DebandDither, Tonemapping},
+    },
+    render::{
+        camera::{CameraMainTextureUsages, CameraRenderGraph, Exposure},
+        primitives::Frustum,
+        view::{ColorGrading, VisibleEntities},
+    },
+};
+
 use crate::prelude::*;
 
 #[derive(Error, Debug)]
@@ -33,21 +45,23 @@ pub(crate) fn tokenize(line: &str) -> Vec<Token> {
     let mut tokens = Vec::new();
 
     // Check for comment
-    if let Ok((_, (_start, content))) = tuple((char::<&str, ()>('#'), not_line_ending))(line) {
+    if let Ok((_, (_start, content))) = tuple((char::<&str, ()>(';'), not_line_ending))(line) {
         tokens.push(Token::Comment(content.strip_prefix(" ").unwrap().into()));
     } else {
         // Check for all other token types in a loop
         while l.len() > 0 {
-            if let Ok((rem, (_, s, _))) = tuple((
+            if let Ok((rem, (_, _, s, _, _))) = tuple((
+                space0,
                 char::<&str, ()>('"'),
                 take_until("\""),
                 char::<&str, ()>('"'),
+                space0,
             ))(l)
             {
                 debug!("Parsed string {:?}", s);
                 tokens.push(Token::Str(s.into()));
                 l = rem;
-            } else if let Ok((rem, num)) = float::<&str, ()>(l) {
+            } else if let Ok((rem, (_, num, _))) = tuple((space0, float::<&str, ()>, space0))(l) {
                 debug!("Parsed float {:?}", num);
                 tokens.push(Token::Num(num.into()));
                 l = rem;
@@ -69,7 +83,6 @@ pub(crate) fn tokenize(line: &str) -> Vec<Token> {
             }
         }
     }
-
     debug!("Parsed tokens: {:?}", tokens);
 
     tokens
@@ -96,34 +109,156 @@ fn test_tokenize() {
 ///
 /// Returns reflected `Transform`
 ///
+/// A fairly complicated parse function because Transform is sort of 3 components in one
+/// (translation, rotation, scale).
+///
+/// It might get more complicated as I add more ways to express rotation!
+///
 pub(crate) fn parse_save_transform(
     tokens: &Vec<Token>,
-) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
+) -> Result<Vec<Box<dyn Reflect>>, SaveEntityParseError> {
-    // Tag(Transform),
+    if tokens[0] == Token::Tag("transform".into()) {
-    //      Tag(Translation), Number, Number, Number
+        let mut t = Transform::default();
-    //      Tag(Rotation), Number, Number, Number, Number
+        let mut idx = 1;
-    //      Tag(Scale), Number, Number, Number
+        while idx < tokens.len() {
-
+            match tokens.get(idx) {
-    // return Err(SaveEntityParseError::Transform);
+                Some(Token::Tag(attr)) => {
-
+                    idx += 1;
-    todo!("parse_save_transform");
+                    match attr.as_str() {
+                        "translation" => {
+                            if let Token::Num(x) = tokens[idx] {
+                                t.translation.x = x;
+                                idx += 1;
+                            }
+                            if let Token::Num(y) = tokens[idx] {
+                                t.translation.y = y;
+                                idx += 1;
+                            }
+                            if let Token::Num(z) = tokens[idx] {
+                                t.translation.z = z;
+                                idx += 1;
+                            }
+                            info!("{:?}", t.translation);
+                        }
+                        "scale" => {
+                            if let Token::Num(x) = tokens[idx] {
+                                t.scale.x = x;
+                                idx += 1;
+                            }
+                            if let Token::Num(y) = tokens[idx] {
+                                t.scale.y = y;
+                                idx += 1;
+                            }
+                            if let Token::Num(z) = tokens[idx] {
+                                t.scale.z = z;
+                                idx += 1;
+                            }
+                        }
+                        "rotation" => {
+                            let x = match tokens.get(idx) {
+                                Some(Token::Num(x)) => {
+                                    idx += 1;
+                                    *x
+                                }
+                                _ => 0.0,
+                            };
+                            let y = match tokens.get(idx) {
+                                Some(Token::Num(y)) => {
+                                    idx += 1;
+                                    *y
+                                }
+                                _ => 0.0,
+                            };
+                            let z = match tokens.get(idx) {
+                                Some(Token::Num(z)) => {
+                                    idx += 1;
+                                    *z
+                                }
+                                _ => 0.0,
+                            };
+                            let w = match tokens.get(idx) {
+                                Some(Token::Num(w)) => {
+                                    idx += 1;
+                                    *w
+                                }
+                                _ => 1.0,
+                            };
+                            t.rotation = Quat::from_xyzw(x, y, z, w);
+                        }
+                        _ => idx += 1,
+                    }
+                }
+                _ => idx += 1,
+            }
+        }
+        println!("Parsed transform: {:?}", t);
+        Ok(vec![
+            t.clone_value(),
+            GlobalTransform::default().clone_value(),
+        ])
+    } else {
+        return Err(SaveEntityParseError::Component("Transform".into()));
+    }
 }
 
 #[test]
 fn test_parse_transform() {
-    let line = "transform translation 1.0 2.0 3.0 rotation 0.1 0.2 0.3 1.0 scale 1.1 1.2 1.3";
+    {
-    let tokens = tokenize(line);
+        let line = "transform translation 1.0 2.0 3.0 rotation 0.1 0.2 0.3 1.0 scale 1.1 1.2 1.3";
-    let parsed = parse_save_transform(&tokens).unwrap();
+        let tokens = tokenize(line);
-    let expected = Transform {
+        let parsed = parse_save_transform(&tokens).unwrap();
-        translation: Vec3::new(1.0, 2.0, 3.0),
+        let t = Transform {
-        rotation: Quat::from_xyzw(0.1, 0.2, 0.3, 1.0),
+            translation: Vec3::new(1.0, 2.0, 3.0),
-        scale: Vec3::new(1.1, 1.2, 1.3),
+            rotation: Quat::from_xyzw(0.1, 0.2, 0.3, 1.0),
-    };
+            scale: Vec3::new(1.1, 1.2, 1.3),
-
+        };
-    assert!(expected
+        let gt = GlobalTransform::default();
-        .clone_value()
+        let expected = vec![t.clone_value(), gt.clone_value()];
-        .reflect_partial_eq(parsed.as_reflect())
+
-        .unwrap());
+        parsed.iter().zip(expected).for_each(|(p, e)| {
+            assert!(e.clone_value().reflect_partial_eq(p.as_reflect()).unwrap());
+        });
+    }
+    {
+        let line = "transform translation ... rotation ... scale ...";
+        let tokens = tokenize(line);
+        let parsed = parse_save_transform(&tokens).unwrap();
+        let t = Transform::default();
+        let gt = GlobalTransform::default();
+        let expected = vec![t.clone_value(), gt.clone_value()];
+
+        parsed.iter().zip(expected).for_each(|(p, e)| {
+            assert!(e.clone_value().reflect_partial_eq(p.as_reflect()).unwrap());
+        });
+    }
+    {
+        let line = "transform ...";
+        let tokens = tokenize(line);
+        let parsed = parse_save_transform(&tokens).unwrap();
+        let t = Transform::default();
+        let gt = GlobalTransform::default();
+        let expected = vec![t.clone_value(), gt.clone_value()];
+
+        parsed.iter().zip(expected).for_each(|(p, e)| {
+            assert!(e.clone_value().reflect_partial_eq(p.as_reflect()).unwrap());
+        });
+    }
+    {
+        let line = "transform translation 1.0 ... rotation 2.0 ... scale 3.0 ...";
+        let tokens = tokenize(line);
+        let parsed = parse_save_transform(&tokens).unwrap();
+        let t = Transform {
+            translation: Vec3::new(1.0, 0.0, 0.0),
+            rotation: Quat::from_xyzw(2.0, 0.0, 0.0, 1.0),
+            scale: Vec3::new(3.0, 1.0, 1.0),
+        };
+        let gt = GlobalTransform::default();
+        let expected = vec![t.clone_value(), gt.clone_value()];
+
+        parsed.iter().zip(expected).for_each(|(p, e)| {
+            assert!(e.clone_value().reflect_partial_eq(p.as_reflect()).unwrap());
+        });
+    }
 }
 
 ///
@@ -131,11 +266,11 @@ fn test_parse_transform() {
 ///
 pub(crate) fn parse_save_name(
     tokens: &Vec<Token>,
-) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
+) -> Result<Vec<Box<dyn Reflect>>, SaveEntityParseError> {
     if let Some((Token::Tag(t), &[Token::Str(ref s)])) = tokens.split_first()
         && *t == String::from("name")
     {
-        Ok(Name::new(s.clone()).clone_value())
+        Ok(vec![Name::new(s.clone()).clone_value()])
     } else {
         Err(SaveEntityParseError::Component("Name".into()))
     }
@@ -147,23 +282,21 @@ fn test_parse_name() {
         let line = "name Van";
         let tokens = tokenize(line);
         let parsed = parse_save_name(&tokens).unwrap();
-        let expected = Name::new("Van");
+        let expected = vec![Name::new("Van").clone_value()];
 
-        assert!(expected
+        parsed.iter().zip(expected).for_each(|(p, e)| {
-            .clone_value()
+            assert!(e.clone_value().reflect_partial_eq(p.as_reflect()).unwrap());
-            .reflect_partial_eq(parsed.as_reflect())
+        });
-            .unwrap());
     }
     {
         let line = "name Big Mike";
         let tokens = tokenize(line);
         let parsed = parse_save_name(&tokens).unwrap();
-        let expected = Name::new("Big Mike");
+        let expected = vec![Name::new("Big Mike").clone_value()];
 
-        assert!(expected
+        parsed.iter().zip(expected).for_each(|(p, e)| {
-            .clone_value()
+            assert!(e.clone_value().reflect_partial_eq(p.as_reflect()).unwrap());
-            .reflect_partial_eq(parsed.as_reflect())
+        });
-            .unwrap());
     }
 }
 
@@ -215,7 +348,7 @@ fn test_parse_model() {
         .unwrap());
 }
 
-#[derive(Debug, Default, PartialEq, Reflect, Clone)]
+#[derive(Component, Debug, Default, PartialEq, Reflect, Clone)]
 #[reflect_value(Component, Default, PartialEq)]
 pub(crate) enum SaveCameraRenderTarget {
     #[default]
@@ -223,24 +356,29 @@ pub(crate) enum SaveCameraRenderTarget {
     Window(PathBuf),
 }
 
-impl Component for SaveCameraRenderTarget {
-    const STORAGE_TYPE: StorageType = StorageType::Table;
-
-    fn register_component_hooks(hooks: &mut ComponentHooks) {
-        todo!("Assign Render Target")
-    }
-}
-
 ///
-/// Returns a reflected `SaveCameraRenderTarget
+/// Returns a reflected `Camera3d`
 ///
 pub(crate) fn parse_save_camera(
     tokens: &Vec<Token>,
-) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
+) -> Result<Vec<Box<dyn Reflect>>, SaveEntityParseError> {
-    todo!("parse_save_camera");
+    if tokens[0] == Token::Tag("camera".into()) {
-
+        Ok(vec![
-    // Nothing parsed well
+            Camera::default().clone_value(),
-    // Err(SaveEntityParseError::Camera)
+            CameraRenderGraph::new(Core3d).clone_value(),
+            Projection::default().clone_value(),
+            VisibleEntities::default().clone_value(),
+            Frustum::default().clone_value(),
+            Camera3d::default().clone_value(),
+            Tonemapping::default().clone_value(),
+            DebandDither::default().clone_value(),
+            ColorGrading::default().clone_value(),
+            Exposure::default().clone_value(),
+            CameraMainTextureUsages::default().clone_value(),
+        ])
+    } else {
+        Err(SaveEntityParseError::Component("camera".into()))
+    }
 }
 
 #[test]
@@ -249,38 +387,56 @@ fn test_parse_camera() {
         let line = "camera";
         let tokens = tokenize(line);
         let parsed = parse_save_camera(&tokens).unwrap();
-        let expected = SaveCameraRenderTarget::Default;
+        let expected = vec![
-        assert!(expected
+            Camera::default().clone_value(),
-            .clone_value()
+            CameraRenderGraph::new(Core3d).clone_value(),
-            .reflect_partial_eq(parsed.as_reflect())
+            Projection::default().clone_value(),
-            .unwrap());
+            VisibleEntities::default().clone_value(),
-    }
+            Frustum::default().clone_value(),
-    {
+            Camera3d::default().clone_value(),
-        let line = "camera target window";
+            Tonemapping::default().clone_value(),
-        let tokens = tokenize(line);
+            DebandDither::default().clone_value(),
-        let parsed = parse_save_camera(&tokens).unwrap();
+            ColorGrading::default().clone_value(),
-        let expected = SaveCameraRenderTarget::Default;
+            Exposure::default().clone_value(),
-        assert!(expected
+            CameraMainTextureUsages::default().clone_value(),
-            .clone_value()
+        ];
-            .reflect_partial_eq(parsed.as_reflect())
+        parsed
-            .unwrap());
+            .iter()
-    }
+            .zip(expected)
-    {
+            .for_each(|(p, e)| match e.reflect_partial_eq(p.as_reflect()) {
-        let line = "camera target";
+                Some(r) => assert!(r),
-        let tokens = tokenize(line);
+                None => warn!(
-        let parsed = parse_save_camera(&tokens);
+                    "Type {:?} does not support reflection",
-        assert!(parsed.is_err());
+                    e.get_represented_type_info().unwrap()
-    }
+                ),
-    {
+            });
-        let line = "camera target window \"some.entity\"";
-        let tokens = tokenize(line);
-        let parsed = parse_save_camera(&tokens).unwrap();
-        let expected = SaveCameraRenderTarget::Window("some.entity".into());
-        assert!(expected
-            .clone_value()
-            .reflect_partial_eq(parsed.as_reflect())
-            .unwrap());
     }
+    //    {
+    //        let line = "camera target window";
+    //        let tokens = tokenize(line);
+    //        let parsed = parse_save_camera(&tokens).unwrap();
+    //        let expected = SaveCameraRenderTarget::Default;
+    //        assert!(expected
+    //            .clone_value()
+    //            .reflect_partial_eq(parsed.as_reflect())
+    //            .unwrap());
+    //    }
+    //    {
+    //        let line = "camera target";
+    //        let tokens = tokenize(line);
+    //        let parsed = parse_save_camera(&tokens);
+    //        assert!(parsed.is_err());
+    //    }
+    //    {
+    //        let line = "camera target window \"some.entity\"";
+    //        let tokens = tokenize(line);
+    //        let parsed = parse_save_camera(&tokens).unwrap();
+    //        let expected = SaveCameraRenderTarget::Window("some.entity".into());
+    //        assert!(expected
+    //            .clone_value()
+    //            .reflect_partial_eq(parsed.as_reflect())
+    //            .unwrap());
+    //    }
     {
         let line = "notcamera";
         let tokens = tokenize(line);
@@ -289,6 +445,36 @@ fn test_parse_camera() {
     }
 }
 
+/// encapsulates the spatial 3d bits of an entity
+pub(crate) fn parse_save_visibility(
+    tokens: &Vec<Token>,
+) -> Result<Vec<Box<dyn Reflect>>, SaveEntityParseError> {
+    if tokens[0] == Token::Tag("visible".into()) {
+        Ok(vec![
+            Visibility::default().clone_value(),
+            InheritedVisibility::default().clone_value(),
+            ViewVisibility::default().clone_value(),
+        ])
+    } else {
+        Err(SaveEntityParseError::Component("visibility".into()))
+    }
+}
+
+#[test]
+fn test_parse_visibility() {
+    let line = "visible";
+    let tokens = tokenize(line);
+    let parsed = parse_save_visibility(&tokens).unwrap();
+    let expected = vec![
+        Visibility::default().clone_value(),
+        InheritedVisibility::default().clone_value(),
+        ViewVisibility::default().clone_value(),
+    ];
+    parsed.iter().zip(expected).for_each(|(p, e)| {
+        assert!(e.clone_value().reflect_partial_eq(p.as_reflect()).unwrap());
+    });
+}
+
 /// SaveParent entity which is a reference to which entity this is a child of
 /// A run-time system converts this to a bevy Parent component
 #[derive(PartialEq, Debug, Reflect, Clone)]

src/save.rs

@@ -3,7 +3,7 @@ use std::any::TypeId;
 use crate::prelude::*;
 
 type ParseFn =
-    for<'a> fn(&'a Vec<Token>) -> Result<Box<(dyn Reflect + 'static)>, SaveEntityParseError>;
+    for<'a> fn(&'a Vec<Token>) -> Result<Vec<Box<(dyn Reflect + 'static)>>, SaveEntityParseError>;
 
 /// Menu Plugin; contains parser functions
 pub(crate) struct SavePlugin {
@@ -84,12 +84,14 @@ impl SaveEntity {
                 } else {
                     // Run line against all parsers
                     for f in fns {
-                        if let Ok(c) = f(&tokens) {
+                        if let Ok(p) = f(&tokens) {
-                            // Bundle the Type ID with this entry for auditing purposes
+                            p.iter().for_each(|c| {
-                            let t = c.get_represented_type_info().unwrap().type_id();
+                                // Bundle the Type ID with this entry for auditing purposes
-                            entity.components.push(SaveEntityComponent {
+                                let t = c.get_represented_type_info().unwrap().type_id();
-                                type_id: t,
+                                entity.components.push(SaveEntityComponent {
-                                data: c,
+                                    type_id: t,
+                                    data: c.clone_value(),
+                                });
                             });
                             good = true;
                         }