diff --git a/assets/models/level1.glb b/assets/models/level1.glb index d76acaf..1f19a73 100644 Binary files a/assets/models/level1.glb and b/assets/models/level1.glb differ diff --git a/assets/models/test.blend b/assets/models/test.blend index 9263b28..8940900 100644 Binary files a/assets/models/test.blend and b/assets/models/test.blend differ diff --git a/src/core/process_gltf/gltf_to_components.rs b/src/core/process_gltf/gltf_to_components.rs index 11b4094..2489fb0 100644 --- a/src/core/process_gltf/gltf_to_components.rs +++ b/src/core/process_gltf/gltf_to_components.rs @@ -125,20 +125,68 @@ pub fn gltf_extras_to_components( parsed_value = ron::from_str(parsed_value.as_str()).unwrap_or(parsed_value); if let Some(type_registration) = type_registry.get_with_short_name(capitalized_type_name.as_str()) { - debug!("parsed value {}",parsed_value); + // FIXME : in the long run, replace all the text based, clunky unoptimised things with use of type_registration.type_info() + let blabla = type_registry.get_with_name("bevy_render::color::Color").unwrap(); + println!("TYPE INFO {:?}", type_registration.type_info()); + // println!("parsed value {}",parsed_value); if parsed_value == "" { parsed_value = "()".to_string(); } - if parsed_value.starts_with("[") && parsed_value.ends_with("]") { - // FIXME/ horrible, and how about actual vec!s and not vec2/vec3 s? + else if parsed_value.starts_with("[") && parsed_value.ends_with("]") { + // FIXME/ horrible, and how about actual vec!s and not vec2/vec3 s? + // the worst part is, we have the component information, so we SHOULD be able to infer the input struct type + // perhaps use better logic than the unwrap ? we could do parsed:Vec as well, and drop it otherwise ? let parsed: Vec = ron::from_str(&parsed_value).unwrap(); if parsed.len() == 2 { parsed_value = format!("((x:{},y:{}))", parsed[0], parsed[1]); } - if parsed.len() == 3 { + // FIXME god awfull hacks + if parsed.len() == 3 && !key.to_lowercase().contains("color"){ parsed_value = format!("((x:{},y:{},z:{}))", parsed[0], parsed[1], parsed[2]); } - + if parsed.len() == 3 && key.to_lowercase().contains("color"){ + parsed_value = format!("(Rgba(red:{},green:{},blue:{}, alpha: 1.0))", parsed[0], parsed[1], parsed[2]); + } + if parsed.len() == 4 && !key.to_lowercase().contains("color") { + parsed_value = format!("((x:{},y:{},z:{},w:{}))", parsed[0], parsed[1], parsed[2], parsed[3]); + } + if parsed.len() == 4 && key.to_lowercase().contains("color"){ + parsed_value = format!("(Rgba(red:{},green:{},blue:{}, alpha:{}))", parsed[0], parsed[1], parsed[2], parsed[3]); + } + /*match ron::from_str(&parsed_value) { + Err(e) => panic!("{:?}", e), + Ok::, _>(parsed) => { + if parsed.len() == 2 { + parsed_value = format!("((x:{},y:{}))", parsed[0], parsed[1]); + } + if parsed.len() == 3 { + parsed_value = format!("((x:{},y:{},z:{}))", parsed[0], parsed[1], parsed[2]); + } + }, + Ok::(parsed) => { + parsed_value = format!("((x:{},y:{}))", parsed[0], parsed[1]); + } + }*/ + + } + // FIXME: inneficient + else if parsed_value.starts_with("\"") && parsed_value.ends_with("\"") { + parsed_value = format!("({})",parsed_value); + } + else { + // FIXME: inneficient + if let Ok(parsed) = parsed_value.parse::() { + parsed_value = format!("({})",parsed); + } + else if let Ok(parsed) = parsed_value.parse::() { + parsed_value = format!("({})",parsed); + } + else if let Ok(parsed) = parsed_value.parse::() { + parsed_value = format!("({})",parsed); + } + else if let Ok(parsed) = parsed_value.parse::() { + parsed_value = format!("({})",parsed); + } } let ron_string = format!("{{ \"{}\":{} }}", @@ -146,14 +194,15 @@ pub fn gltf_extras_to_components( parsed_value ); - /* - let test_struct = CameraTrackingOffset::default(); + + // usefull to determine what an entity looks like Serialized + /*let test_struct = TuppleTestStr::default(); let serializer = ReflectSerializer::new(&test_struct, &type_registry); let serialized = ron::ser::to_string_pretty(&serializer, ron::ser::PrettyConfig::default()).unwrap(); - println!("serialized player {}", serialized);*/ + println!("serialized Component {}", serialized);*/ - debug!("component data json string {}", ron_string); + debug!("component data ron string {}", ron_string); let mut deserializer = ron::Deserializer::from_str(ron_string.as_str()).unwrap(); let reflect_deserializer = UntypedReflectDeserializer::new(&type_registry); let component = reflect_deserializer.deserialize(&mut deserializer).expect(format!("failed to deserialize component {} with value: {}", key, value).as_str()); diff --git a/src/game.rs b/src/game.rs index 933434a..3366223 100644 --- a/src/game.rs +++ b/src/game.rs @@ -33,6 +33,12 @@ pub struct ShouldBeWithPlayer; /// Demo marker component pub struct Interactible; +#[derive(Component, Reflect, Default, Debug, )] +#[reflect(Component)] +/// Demo marker component +pub struct Pickable; + + fn player_move_demo( keycode: Res>, @@ -87,6 +93,7 @@ impl Plugin for DemoPlugin { fn build(&self, app: &mut App) { app .register_type::() + .register_type::() .register_type::() .register_type::() // little helper utility, to automatically inject components that are dependant on an other component diff --git a/src/main.rs b/src/main.rs index f3a9c1b..701e5d7 100644 --- a/src/main.rs +++ b/src/main.rs @@ -7,7 +7,10 @@ mod core; use crate::core::*; mod game; -use crate::game::*; +use game::*; + +mod test_components; +use test_components::*; #[derive(Component, Reflect, Default, Debug, )] #[reflect(Component)] @@ -43,7 +46,8 @@ fn main(){ RapierDebugRenderPlugin::default(), // our custom plugins CorePlugin, // reusable plugins - DemoPlugin // specific to our game + DemoPlugin, // specific to our game + ComponentsTestPlugin // Showcases different type of components /structs )) .add_state::() diff --git a/src/test_components.rs b/src/test_components.rs new file mode 100644 index 0000000..b18ad1d --- /dev/null +++ b/src/test_components.rs @@ -0,0 +1,84 @@ +use bevy::prelude::*; + + +#[derive(Component, Reflect, Default, Debug, )] +#[reflect(Component)] +struct UnitTest; + +#[derive(Component, Reflect, Default, Debug, Deref, DerefMut)] +#[reflect(Component)] +struct TuppleTestF32(f32); + +#[derive(Component, Reflect, Default, Debug, Deref, DerefMut)] +#[reflect(Component)] +struct TuppleTestU64(u64); + +#[derive(Component, Reflect, Default, Debug, Deref, DerefMut)] +#[reflect(Component)] +pub struct TuppleTestStr(String); + +#[derive(Component, Reflect, Default, Debug, )] +#[reflect(Component)] +struct TuppleTest2(f32, u64, String); + +#[derive(Component, Reflect, Default, Debug, )] +#[reflect(Component)] +struct TuppleTestBool(bool); + +#[derive(Component, Reflect, Default, Debug, )] +#[reflect(Component)] +struct TuppleVec2(Vec2); + +#[derive(Component, Reflect, Default, Debug, )] +#[reflect(Component)] +struct TuppleVec3(Vec3); + +#[derive(Component, Reflect, Default, Debug, )] +#[reflect(Component)] +struct TuppleVec(Vec); + +#[derive(Component, Reflect, Default, Debug, )] +#[reflect(Component)] +struct TuppleTestColor(Color); + +#[derive(Component, Reflect, Default, Debug, )] +#[reflect(Component)] +struct BasicTest{ + a: f32, + b: u64, + c: String +} + +#[derive(Component, Reflect, Default, Debug, )] +#[reflect(Component)] +pub enum EnumTest{ + Metal, + Wood, + Rock, + Cloth, + Squishy, + #[default] + None +} + + +pub struct ComponentsTestPlugin; +impl Plugin for ComponentsTestPlugin { + fn build(&self, app: &mut App) { + app + .register_type::() + .register_type::() + .register_type::() + .register_type::() + .register_type::() + .register_type::() + .register_type::() + .register_type::() + .register_type::() + .register_type::() + + .register_type::() + // .register_type::() + ; + } +}