games
/
acts-of-gods
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Parsing transform from tokens

Browse Source
attempt/001
Elijah Voigt 1 year ago
parent f9acf9e2ff
commit 3f3d7ef001
8 changed files with 294 additions and 96 deletions
Show Stats Download Patch File Download Diff File

2
assets/scenes/00.scene
Unescape Escape View File

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

3
assets/scenes/00/a.entity
Unescape Escape View File

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

2
assets/scenes/00/camera.entity
Unescape Escape View File

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

3
assets/scenes/00/light.entity
Unescape Escape View File

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

3
assets/scenes/00/van.entity
Unescape Escape View File

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

7
src/main.rs
Unescape Escape View File

@ -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();
}

336
src/parser.rs
Unescape Escape View File

@ -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> {
// Tag(Transform),
// Tag(Translation), Number, Number, Number
// Tag(Rotation), Number, Number, Number, Number
// Tag(Scale), Number, Number, Number
// return Err(SaveEntityParseError::Transform);
todo!("parse_save_transform");
) -> Result<Vec<Box<dyn Reflect>>, SaveEntityParseError> {
if tokens[0] == Token::Tag("transform".into()) {
let mut t = Transform::default();
let mut idx = 1;
while idx < tokens.len() {
match tokens.get(idx) {
Some(Token::Tag(attr)) => {
idx += 1;
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 parsed = parse_save_transform(&tokens).unwrap();
let expected = Transform {
let t = Transform {
translation: Vec3::new(1.0, 2.0, 3.0),
rotation: Quat::from_xyzw(0.1, 0.2, 0.3, 1.0),
scale: Vec3::new(1.1, 1.2, 1.3),
};
let gt = GlobalTransform::default();
let expected = vec![t.clone_value(), gt.clone_value()];
assert!(expected
.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
.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 = "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
.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());
});
}
}
@ -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> {
todo!("parse_save_camera");
// Nothing parsed well
// Err(SaveEntityParseError::Camera)
) -> Result<Vec<Box<dyn Reflect>>, SaveEntityParseError> {
if tokens[0] == Token::Tag("camera".into()) {
Ok(vec![
Camera::default().clone_value(),
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,44 +387,92 @@ fn test_parse_camera() {
let line = "camera";
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 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 expected = vec![
Camera::default().clone_value(),
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(),
];
parsed
.iter()
.zip(expected)
.for_each(|(p, e)| match e.reflect_partial_eq(p.as_reflect()) {
Some(r) => assert!(r),
None => warn!(
"Type {:?} does not support reflection",
e.get_represented_type_info().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 = "camera target";
let line = "notcamera";
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());
}
/// 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()))
}
{
let line = "notcamera";
}
#[test]
fn test_parse_visibility() {
let line = "visible";
let tokens = tokenize(line);
let parsed = parse_save_camera(&tokens);
assert!(parsed.is_err());
}
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

8
src/save.rs
Unescape Escape View File

@ -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) {
p.iter().for_each(|c| {
// Bundle the Type ID with this entry for auditing purposes
let t = c.get_represented_type_info().unwrap().type_id();
entity.components.push(SaveEntityComponent {
type_id: t,
data: c,
data: c.clone_value(),
});
});
good = true;
}

Write Preview
Loading…
Cancel
Save