crates/bevy_gltf_blueprints/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bevy_gltf_blueprints"
-version = "0.11.0"
+version = "0.10.0"
 authors = ["Mark 'kaosat-dev' Moissette"]
 description = "Adds the ability to define Blueprints/Prefabs for Bevy inside gltf files and spawn them in Bevy."
 homepage = "https://github.com/kaosat-dev/Blender_bevy_components_workflow"
@@ -14,8 +14,8 @@ license = "MIT OR Apache-2.0"
 workspace = true
 
 [dependencies]
-bevy_gltf_components = { version = "0.6", path = "../bevy_gltf_components" }
+bevy_gltf_components = { version = "0.5", path = "../bevy_gltf_components" }
-bevy = { version = "0.14.0-rc.3", default-features = false, features = ["bevy_asset", "bevy_scene", "bevy_gltf", "bevy_animation", "animation"] }
+bevy = { version = "0.13", default-features = false, features = ["bevy_asset", "bevy_scene", "bevy_gltf", "bevy_animation", "animation"] }
 
 [dev-dependencies]
-bevy = { version = "0.14.0-rc.3", default-features = false, features = ["dynamic_linking"] }
+bevy = { version = "0.13", default-features = false, features = ["dynamic_linking"] }

crates/bevy_gltf_blueprints/src/animation.rs

@@ -73,7 +73,6 @@ pub struct AnimationMarkerReached {
 
 /////////////////////
 
-/* 
 /// triggers events when a given animation marker is reached for INSTANCE animations
 pub fn trigger_instance_animation_markers_events(
     animation_infos: Query<(
@@ -83,15 +82,13 @@ pub fn trigger_instance_animation_markers_events(
         &SceneAnimations,
         &AnimationInfos,
     )>,
-    animation_players: Query<(&AnimationPlayer)>,
+    animation_players: Query<&AnimationPlayer>,
     animation_clips: Res<Assets<AnimationClip>>,
-    animation_graphs: Res<Assets<AnimationGraph>>,
     mut animation_marker_events: EventWriter<AnimationMarkerReached>,
 ) {
     for (entity, markers, link, animations, animation_infos) in animation_infos.iter() {
         let animation_player = animation_players.get(link.0).unwrap();
         let animation_clip = animation_clips.get(animation_player.animation_clip());
-        // animation_player.play(animation)
 
         if animation_clip.is_some() {
             // println!("Entity {:?} markers {:?}", entity, markers);
@@ -218,4 +215,3 @@ pub fn trigger_blueprint_animation_markers_events(
         }
     }
 }
-*/

crates/bevy_gltf_blueprints/src/copy_components.rs

@@ -1,4 +1,4 @@
-use bevy::ecs::world::Command;
+use bevy::ecs::system::Command;
 use bevy::prelude::*;
 use std::any::TypeId;
 

crates/bevy_gltf_blueprints/src/lib.rs

@@ -176,13 +176,12 @@ impl Plugin for BlueprintsPlugin {
                     .chain()
                     .in_set(GltfBlueprintsSet::AfterSpawn),
             )
-            /* .add_systems(
+            .add_systems(
                 Update,
                 (
                     trigger_instance_animation_markers_events,
                     trigger_blueprint_animation_markers_events,
                 ),
-            )*/
+            );
-            ;
     }
 }

crates/bevy_gltf_blueprints/src/materials.rs

@@ -160,10 +160,10 @@ pub(crate) fn materials_inject2(
             let mat_gltf = assets_gltf
                 .get(model_handle.id())
                 .expect("material should have been preloaded");
-            if mat_gltf.named_materials.contains_key(&material_info.name as &str) {
+            if mat_gltf.named_materials.contains_key(&material_info.name) {
                 let material = mat_gltf
                     .named_materials
-                    .get(&material_info.name as &str)
+                    .get(&material_info.name)
                     .expect("this material should have been loaded");
                 blueprints_config
                     .material_library_cache

crates/bevy_gltf_blueprints/src/spawn_from_blueprints.rs

@@ -1,6 +1,6 @@
 use std::path::{Path, PathBuf};
 
-use bevy::{gltf::Gltf, prelude::*, utils::hashbrown::HashMap};
+use bevy::{gltf::Gltf, prelude::*, utils::HashMap};
 
 use crate::{AllAssets, AssetsToLoad, AssetLoadTracker, BluePrintsConfig, BlueprintAnimations, BlueprintAssetsLoaded, BlueprintAssetsNotLoaded};
 
@@ -28,7 +28,7 @@ pub struct SpawnHere;
 pub struct Spawned;
 
 
-#[derive(Component, Debug)]
+#[derive(Component)]
 /// flag component added when a Blueprint instance ist Ready : ie : 
 /// - its assets have loaded
 /// - it has finished spawning
@@ -194,13 +194,8 @@ pub(crate) fn check_for_loaded2(
             println!("loading {}: // load state: {:?}", tracker.name, asset_server.load_state(asset_id));
 
             // FIXME: hack for now
-            let mut failed = false;// asset_server.load_state(asset_id) == bevy::asset::LoadState::Failed(_error);
+            let failed = asset_server.load_state(asset_id) == bevy::asset::LoadState::Failed;
-            match asset_server.load_state(asset_id) {
+
-                bevy::asset::LoadState::Failed(_) => {
-                    failed = true
-                },
-                _ => {}
-            }
             tracker.loaded = loaded || failed;
             if loaded || failed {
                 loaded_amount += 1;
@@ -300,12 +295,6 @@ pub(crate) fn spawn_from_blueprints2(
                 original_children.push(*child);
             }
         }
-
-        let mut named_animations:HashMap<String, Handle<AnimationClip>> = HashMap::new() ;
-        for (key, value) in gltf.named_animations.iter() {
-            named_animations.insert(key.to_string(), value.clone());
-        }
-
         commands.entity(entity).insert((
             SceneBundle {
                 scene: scene.clone(),
@@ -317,7 +306,7 @@ pub(crate) fn spawn_from_blueprints2(
             OriginalChildren(original_children),
             BlueprintAnimations {
                 // these are animations specific to the inside of the blueprint
-                named_animations: named_animations//gltf.named_animations.clone(),
+                named_animations: gltf.named_animations.clone(),
             },
         ));
 

crates/bevy_gltf_blueprints/src/spawn_post_process.rs

@@ -38,7 +38,7 @@ pub(crate) fn spawned_blueprint_post_process(
     for (original, children, original_children, animations, no_inblueprint, name) in
         unprocessed_entities.iter()
     {
-        info!("post processing blueprint for entity {:?}", name);
+        debug!("post processing blueprint for entity {:?}", name);
 
         if children.len() == 0 {
             warn!("timing issue ! no children found, please restart your bevy app (bug being investigated)");
@@ -94,10 +94,9 @@ pub(crate) fn spawned_blueprint_post_process(
 
         commands.entity(original).remove::<SpawnHere>();
         commands.entity(original).remove::<Spawned>();
-        // commands.entity(original).remove::<Handle<Scene>>(); // FIXME: if we delete the handle to the scene, things get despawned ! not what we want
+        commands.entity(original).remove::<Handle<Scene>>();
         //commands.entity(original).remove::<AssetsToLoad>(); // also clear the sub assets tracker to free up handles, perhaps just freeing up the handles and leave the rest would be better ?
         //commands.entity(original).remove::<BlueprintAssetsLoaded>();
         commands.entity(root_entity).despawn_recursive();
-        info!("DONE WITH POST PROCESS");
     }
 }

crates/bevy_gltf_components/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bevy_gltf_components"
-version = "0.6.0"
+version = "0.5.1"
 authors = ["Mark 'kaosat-dev' Moissette"]
 description = "Allows you to define Bevy components direclty inside gltf files and instanciate the components on the Bevy side."
 homepage = "https://github.com/kaosat-dev/Blender_bevy_components_workflow"
@@ -14,9 +14,9 @@ license = "MIT OR Apache-2.0"
 workspace = true
 
 [dependencies]
-bevy = { version = "0.14.0-rc.3", default-features = false, features = ["bevy_asset", "bevy_scene", "bevy_gltf"] }
+bevy = { version = "0.13", default-features = false, features = ["bevy_asset", "bevy_scene", "bevy_gltf"] }
 serde = "1.0.188"
 ron = "0.8.1"
 
 [dev-dependencies]
-bevy = { version = "0.14.0-rc.3", default-features = false, features = ["dynamic_linking"] }
+bevy = { version = "0.13", default-features = false, features = ["dynamic_linking"] }

crates/bevy_gltf_components/src/process_gltfs.rs

@@ -6,7 +6,7 @@ use bevy::{
         reflect::{AppTypeRegistry, ReflectComponent},
         world::World,
     },
-    gltf::{GltfExtras, GltfMaterialExtras, GltfMeshExtras, GltfSceneExtras},
+    gltf::GltfExtras,
     hierarchy::Parent,
     log::debug,
     reflect::{Reflect, TypeRegistration},
@@ -15,48 +15,10 @@ use bevy::{
 
 use crate::{ronstring_to_reflect_component, GltfProcessed};
 
-// , mut entity_components: HashMap<Entity, Vec<(Box<dyn Reflect>, TypeRegistration)>>
-fn find_entity_components(entity: Entity, name: &Name, parent: &Parent, reflect_components: Vec<(Box<dyn Reflect>, TypeRegistration)>, entity_components: &HashMap<Entity, Vec<(Box<dyn Reflect>, TypeRegistration)>>) -> (Entity, Vec<(Box<dyn Reflect>, TypeRegistration)>){
-     // we assign the components specified /xxx_components objects to their parent node
-     let mut target_entity = entity;
-     // if the node contains "components" or ends with "_pa" (ie add to parent), the components will not be added to the entity itself but to its parent
-     // this is mostly used for Blender collections
-     if name.as_str().contains("components") || name.as_str().ends_with("_pa") {
-         debug!("adding components to parent");
-         target_entity = parent.get();
-     }
-     debug!("adding to {:?}", target_entity);
-
-     // if there where already components set to be added to this entity (for example when entity_data was refering to a parent), update the vec of entity_components accordingly
-     // this allows for example blender collection to provide basic ecs data & the instances to override/ define their own values
-     if entity_components.contains_key(&target_entity) {
-         let mut updated_components: Vec<(Box<dyn Reflect>, TypeRegistration)> = Vec::new();
-         let current_components = &entity_components[&target_entity];
-         // first inject the current components
-         for (component, type_registration) in current_components {
-             updated_components.push((component.clone_value(), type_registration.clone()));
-         }
-         // then inject the new components: this also enables overwrite components set in the collection
-         for (component, type_registration) in reflect_components {
-             updated_components.push((component.clone_value(), type_registration));
-         }
-         return (target_entity, updated_components)
-         //entity_components.insert(target_entity, updated_components);
-     } else {
-        return  (target_entity, reflect_components);
-         // entity_components.insert(target_entity, reflect_components);
-     }
-}
-
 /// main function: injects components into each entity in gltf files that have `gltf_extras`, using reflection
 pub fn add_components_from_gltf_extras(world: &mut World) {
     let mut extras =
         world.query_filtered::<(Entity, &Name, &GltfExtras, &Parent), (Added<GltfExtras>, Without<GltfProcessed>)>();
-
-    let mut scene_extras = world.query_filtered::<(Entity, &Name, &GltfSceneExtras, &Parent), (Added<GltfSceneExtras>, Without<GltfProcessed>)>();
-    let mut mesh_extras = world.query_filtered::<(Entity, &Name, &GltfMeshExtras, &Parent), (Added<GltfMeshExtras>, Without<GltfProcessed>)>();
-    let mut material_extras = world.query_filtered::<(Entity, &Name, &GltfMaterialExtras, &Parent), (Added<GltfMaterialExtras>, Without<GltfProcessed>)>();
-
     let mut entity_components: HashMap<Entity, Vec<(Box<dyn Reflect>, TypeRegistration)>> =
         HashMap::new();
 
@@ -72,54 +34,35 @@ pub fn add_components_from_gltf_extras(world: &mut World) {
         let type_registry = type_registry.read();
         let reflect_components = ronstring_to_reflect_component(&extra.value, &type_registry);
 
-        let (target_entity, updated_components) = find_entity_components(entity, name, parent, reflect_components, &entity_components);
+        // we assign the components specified /xxx_components objects to their parent node
-        entity_components.insert(target_entity, updated_components);
+        let mut target_entity = entity;
+        // if the node contains "components" or ends with "_pa" (ie add to parent), the components will not be added to the entity itself but to its parent
+        // this is mostly used for Blender collections
+        if name.as_str().contains("components") || name.as_str().ends_with("_pa") {
+            debug!("adding components to parent");
+            target_entity = parent.get();
+        }
+        debug!("adding to {:?}", target_entity);
+
+        // if there where already components set to be added to this entity (for example when entity_data was refering to a parent), update the vec of entity_components accordingly
+        // this allows for example blender collection to provide basic ecs data & the instances to override/ define their own values
+        if entity_components.contains_key(&target_entity) {
+            let mut updated_components: Vec<(Box<dyn Reflect>, TypeRegistration)> = Vec::new();
+            let current_components = &entity_components[&target_entity];
+            // first inject the current components
+            for (component, type_registration) in current_components {
+                updated_components.push((component.clone_value(), type_registration.clone()));
+            }
+            // then inject the new components: this also enables overwrite components set in the collection
+            for (component, type_registration) in reflect_components {
+                updated_components.push((component.clone_value(), type_registration));
+            }
+            entity_components.insert(target_entity, updated_components);
+        } else {
+            entity_components.insert(target_entity, reflect_components);
+        }
     }
 
-
-    for (entity, name, extra, parent) in scene_extras.iter(world) {
-        debug!(
-            "Name: {}, entity {:?}, parent: {:?}, scene_extras {:?}",
-            name, entity, parent, extra
-        );
-
-        let type_registry: &AppTypeRegistry = world.resource();
-        let type_registry = type_registry.read();
-        let reflect_components = ronstring_to_reflect_component(&extra.value, &type_registry);
-
-        let (target_entity, updated_components) = find_entity_components(entity, name, parent, reflect_components, &entity_components);
-        entity_components.insert(target_entity, updated_components);
-    }
-
-    for (entity, name, extra, parent) in mesh_extras.iter(world) {
-        debug!(
-            "Name: {}, entity {:?}, parent: {:?}, mesh_extras {:?}",
-            name, entity, parent, extra
-        );
-
-        let type_registry: &AppTypeRegistry = world.resource();
-        let type_registry = type_registry.read();
-        let reflect_components = ronstring_to_reflect_component(&extra.value, &type_registry);
-
-        let (target_entity, updated_components) = find_entity_components(entity, name, parent, reflect_components, &entity_components);
-        entity_components.insert(target_entity, updated_components);
-    }
-
-    for (entity, name, extra, parent) in material_extras.iter(world) {
-        debug!(
-            "Name: {}, entity {:?}, parent: {:?}, material_extras {:?}",
-            name, entity, parent, extra
-        );
-
-        let type_registry: &AppTypeRegistry = world.resource();
-        let type_registry = type_registry.read();
-        let reflect_components = ronstring_to_reflect_component(&extra.value, &type_registry);
-
-        let (target_entity, updated_components) = find_entity_components(entity, name, parent, reflect_components, &entity_components);
-        entity_components.insert(target_entity, updated_components);
-    }
-
-
     for (entity, components) in entity_components {
         let type_registry: &AppTypeRegistry = world.resource();
         let type_registry = type_registry.clone();

crates/bevy_gltf_components/src/ronstring_to_reflect_component.rs

@@ -1,5 +1,5 @@
 use bevy::log::{debug, warn};
-use bevy::reflect::serde::ReflectDeserializer;
+use bevy::reflect::serde::UntypedReflectDeserializer;
 use bevy::reflect::{Reflect, TypeRegistration, TypeRegistry};
 use bevy::utils::HashMap;
 use ron::Value;
@@ -68,7 +68,7 @@ fn components_string_to_components(
         debug!("component data ron string {}", ron_string);
         let mut deserializer = ron::Deserializer::from_str(ron_string.as_str())
             .expect("deserialzer should have been generated from string");
-        let reflect_deserializer = ReflectDeserializer::new(type_registry);
+        let reflect_deserializer = UntypedReflectDeserializer::new(type_registry);
         let component = reflect_deserializer
             .deserialize(&mut deserializer)
             .unwrap_or_else(|_| {
@@ -113,7 +113,7 @@ fn bevy_components_string_to_components(
             debug!("component data ron string {}", ron_string);
             let mut deserializer = ron::Deserializer::from_str(ron_string.as_str())
                 .expect("deserialzer should have been generated from string");
-            let reflect_deserializer = ReflectDeserializer::new(type_registry);
+            let reflect_deserializer = UntypedReflectDeserializer::new(type_registry);
             let component = reflect_deserializer
                 .deserialize(&mut deserializer)
                 .unwrap_or_else(|_| {

crates/bevy_gltf_save_load/Cargo.toml

@@ -14,8 +14,8 @@ license = "MIT OR Apache-2.0"
 workspace = true
 
 [dependencies]
-bevy = { version = "0.14.0-rc.3", default-features = false, features = ["bevy_asset", "bevy_scene", "bevy_gltf"] }
+bevy = { version = "0.13", default-features = false, features = ["bevy_asset", "bevy_scene", "bevy_gltf"] }
-bevy_gltf_blueprints = { version = "0.11", path = "../bevy_gltf_blueprints" }
+bevy_gltf_blueprints = { version = "0.10", path = "../bevy_gltf_blueprints" }
 
 [dev-dependencies]
-bevy = { version = "0.14.0-rc.3", default-features = false, features = ["dynamic_linking"] }
+bevy = { version = "0.13", default-features = false, features = ["dynamic_linking"] }

crates/bevy_gltf_save_load/src/saving.rs

@@ -147,7 +147,7 @@ pub(crate) fn save_game(world: &mut World) {
     // dyn_scene.resources.append(&mut dyn_scene_root.resources);
 
     let serialized_scene = dyn_scene
-        .serialize(&world.resource::<AppTypeRegistry>().read())
+        .serialize_ron(world.resource::<AppTypeRegistry>())
         .unwrap();
 
     let save_path = Path::new("assets")

crates/bevy_registry_export/Cargo.toml

@@ -11,11 +11,11 @@ edition = "2021"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
-bevy = { version = "0.14.0-rc.3", default-features = false, features = ["bevy_scene"] }
+bevy = { version = "0.13", default-features = false, features = ["bevy_scene"] }
-bevy_reflect = { version = "0.14.0-rc.3", default-features = false }
+bevy_reflect = { version = "0.13", default-features = false }
-bevy_app = { version = "0.14.0-rc.3", default-features = false, features = ["bevy_reflect"] }
+bevy_app = { version = "0.13", default-features = false, features = ["bevy_reflect"] }
-bevy_ecs = { version = "0.14.0-rc.3", default-features = false, features = ["bevy_reflect"] }
+bevy_ecs = { version = "0.13", default-features = false, features = ["bevy_reflect"] }
 serde_json = "1.0.108"
 
 [dev-dependencies]
-bevy = { version = "0.14.0-rc.3", default-features = false, features = ["dynamic_linking"] }
+bevy = { version = "0.13", default-features = false, features = ["dynamic_linking"] }

crates/blenvy/Cargo.toml

@@ -1,22 +0,0 @@
-[package]
-name = "blenvy"
-version = "0.0.1"
-authors = ["Mark 'kaosat-dev' Moissette"]
-description = "Allows you to define Bevy components direclty inside gltf files and instanciate the components on the Bevy side."
-homepage = "https://github.com/kaosat-dev/Blender_bevy_components_workflow"
-repository = "https://github.com/kaosat-dev/Blender_bevy_components_workflow"
-keywords = ["gamedev", "bevy", "assets", "gltf", "components"]
-categories = ["game-development"]
-edition = "2021"
-license = "MIT OR Apache-2.0"
-
-[lints]
-workspace = true
-
-[dependencies]
-bevy = { version = "0.14.0-rc.3", default-features = false, features = ["bevy_asset", "bevy_scene", "bevy_gltf"] }
-serde = "1.0.188"
-ron = "0.8.1"
-
-[dev-dependencies]
-bevy = { version = "0.14.0-rc.3", default-features = false, features = ["dynamic_linking"] }

crates/blenvy/src/blender_settings.rs

@@ -1,8 +0,0 @@
-use bevy::prelude::*;
-
-mod lighting;
-pub use lighting::*;
-
-pub(crate) fn plugin(app: &mut App) {
-    app.add_plugins(lighting::plugin);
-}

crates/blenvy/src/blender_settings/lighting.rs

@@ -1,97 +0,0 @@
-use bevy::pbr::DirectionalLightShadowMap;
-use bevy::prelude::*;
-
-use crate::GltfComponentsSet;
-
-pub(crate) fn plugin(app: &mut App) {
-    app.register_type::<BlenderBackgroundShader>()
-        .register_type::<BlenderShadowSettings>()
-        .register_type::<BlenderLightShadows>()
-        .add_systems(
-            Update,
-            (process_lights, process_shadowmap, process_background_shader)
-                .after(GltfComponentsSet::Injection),
-        );
-}
-
-#[derive(Component, Reflect, Default, Debug, PartialEq, Clone)]
-#[reflect(Component)]
-#[non_exhaustive]
-/// The properties of a light's shadow , to enable controlling per light shadows from Blender
-pub struct BlenderLightShadows {
-    pub enabled: bool,
-    pub buffer_bias: f32,
-}
-
-/// The background color as described by Blender's [background shader](https://docs.blender.org/manual/en/latest/render/shader_nodes/shader/background.html).
-#[derive(Component, Reflect, Default, Debug, PartialEq, Clone)]
-#[reflect(Component)]
-#[non_exhaustive]
-pub struct BlenderBackgroundShader {
-    pub color: Color,
-    pub strength: f32,
-}
-
-/// The settings used by EEVEE's [shadow rendering](https://docs.blender.org/manual/en/latest/render/eevee/render_settings/shadows.html).
-#[derive(Component, Reflect, Default, Debug, PartialEq, Clone)]
-#[reflect(Component)]
-#[non_exhaustive]
-pub struct BlenderShadowSettings {
-    pub cascade_size: usize,
-}
-
-fn process_lights(
-    mut directional_lights: Query<
-        (&mut DirectionalLight, Option<&BlenderLightShadows>),
-        Added<DirectionalLight>,
-    >,
-    mut spot_lights: Query<(&mut SpotLight, Option<&BlenderLightShadows>), Added<SpotLight>>,
-    mut point_lights: Query<(&mut PointLight, Option<&BlenderLightShadows>), Added<PointLight>>,
-) {
-    for (mut light, blender_light_shadows) in directional_lights.iter_mut() {
-        if let Some(blender_light_shadows) = blender_light_shadows {
-            light.shadows_enabled = blender_light_shadows.enabled;
-        } else {
-            light.shadows_enabled = true;
-        }
-    }
-    for (mut light, blender_light_shadows) in spot_lights.iter_mut() {
-        if let Some(blender_light_shadows) = blender_light_shadows {
-            light.shadows_enabled = blender_light_shadows.enabled;
-        } else {
-            light.shadows_enabled = true;
-        }
-    }
-
-    for (mut light, blender_light_shadows) in point_lights.iter_mut() {
-        if let Some(blender_light_shadows) = blender_light_shadows {
-            light.shadows_enabled = blender_light_shadows.enabled;
-        } else {
-            light.shadows_enabled = true;
-        }
-    }
-}
-
-fn process_shadowmap(
-    shadowmaps: Query<&BlenderShadowSettings, Added<BlenderShadowSettings>>,
-    mut commands: Commands,
-) {
-    for shadowmap in shadowmaps.iter() {
-        commands.insert_resource(DirectionalLightShadowMap {
-            size: shadowmap.cascade_size,
-        });
-    }
-}
-
-fn process_background_shader(
-    background_shaders: Query<&BlenderBackgroundShader, Added<BlenderBackgroundShader>>,
-    mut commands: Commands,
-) {
-    for background_shader in background_shaders.iter() {
-        commands.insert_resource(AmbientLight {
-            color: background_shader.color,
-            // Just a guess, see <https://github.com/bevyengine/bevy/issues/12280>
-            brightness: background_shader.strength * 400.0,
-        });
-    }
-}

crates/blenvy/src/lib.rs

@@ -1,78 +0,0 @@
-pub mod utils;
-pub use utils::*;
-
-pub mod ronstring_to_reflect_component;
-pub use ronstring_to_reflect_component::*;
-
-pub mod process_gltfs;
-pub use process_gltfs::*;
-
-pub mod blender_settings;
-
-use bevy::{
-    ecs::{component::Component, reflect::ReflectComponent, system::Resource},
-    prelude::{App, IntoSystemConfigs, Plugin, SystemSet, Update},
-    reflect::Reflect,
-};
-
-/// A Bevy plugin for extracting components from gltf files and automatically adding them to the relevant entities
-/// It will automatically run every time you load a gltf file
-/// Add this plugin to your Bevy app to get access to this feature
-/// ```
-/// # use bevy::prelude::*;
-/// # use bevy::gltf::*;
-/// # use bevy_gltf_components::ComponentsFromGltfPlugin;
-///
-/// //too barebones of an example to be meaningfull, please see https://github.com/kaosat-dev/Blender_bevy_components_workflow/examples/basic for a real example
-/// fn main() {
-///    App::new()
-///         .add_plugins(DefaultPlugins)
-///         .add_plugin(ComponentsFromGltfPlugin)
-///         .add_system(spawn_level)
-///         .run();
-/// }
-///
-/// fn spawn_level(
-///   asset_server: Res<AssetServer>,
-///   mut commands: bevy::prelude::Commands,
-///   keycode: Res<Input<KeyCode>>,
-
-/// ){
-/// if keycode.just_pressed(KeyCode::Return) {
-///  commands.spawn(SceneBundle {
-///   scene: asset_server.load("basic/models/level1.glb"),
-///   transform: Transform::from_xyz(2.0, 0.0, -5.0),
-/// ..Default::default()
-/// });
-/// }
-///}
-/// ```
-
-/// this is a flag component to tag a processed gltf, to avoid processing things multiple times
-#[derive(Component, Reflect, Default, Debug)]
-#[reflect(Component)]
-pub struct GltfProcessed;
-
-#[derive(SystemSet, Debug, Hash, PartialEq, Eq, Clone)]
-/// systemset to order your systems after the component injection when needed
-pub enum GltfComponentsSet {
-    Injection,
-}
-
-#[derive(Clone, Resource)]
-pub struct GltfComponentsConfig {}
-
-#[derive(Default)]
-pub struct ComponentsFromGltfPlugin {}
-
-impl Plugin for ComponentsFromGltfPlugin {
-    fn build(&self, app: &mut App) {
-        app.add_plugins(blender_settings::plugin)
-            .register_type::<GltfProcessed>()
-            .insert_resource(GltfComponentsConfig {})
-            .add_systems(
-                Update,
-                (add_components_from_gltf_extras).in_set(GltfComponentsSet::Injection),
-            );
-    }
-}

crates/blenvy/src/process_gltfs.rs

@@ -1,130 +0,0 @@
-use bevy::{
-    core::Name,
-    ecs::{
-        entity::Entity,
-        query::{Added, Without},
-        reflect::{AppTypeRegistry, ReflectComponent},
-        world::World,
-    },
-    gltf::{GltfExtras, GltfMaterialExtras, GltfMeshExtras, GltfSceneExtras},
-    hierarchy::Parent,
-    log::debug,
-    reflect::{Reflect, TypeRegistration},
-    utils::HashMap,
-};
-
-use crate::{ronstring_to_reflect_component, GltfProcessed};
-
-fn bla_balb(entity: Entity, name: &Name, parent: &Parent, reflect_components: Vec<(Box<dyn Reflect>, TypeRegistration)>, mut entity_components: HashMap<Entity, Vec<(Box<dyn Reflect>, TypeRegistration)>>){
-     // we assign the components specified /xxx_components objects to their parent node
-     let mut target_entity = entity;
-     // if the node contains "components" or ends with "_pa" (ie add to parent), the components will not be added to the entity itself but to its parent
-     // this is mostly used for Blender collections
-     if name.as_str().contains("components") || name.as_str().ends_with("_pa") {
-         debug!("adding components to parent");
-         target_entity = parent.get();
-     }
-     debug!("adding to {:?}", target_entity);
-
-     // if there where already components set to be added to this entity (for example when entity_data was refering to a parent), update the vec of entity_components accordingly
-     // this allows for example blender collection to provide basic ecs data & the instances to override/ define their own values
-     if entity_components.contains_key(&target_entity) {
-         let mut updated_components: Vec<(Box<dyn Reflect>, TypeRegistration)> = Vec::new();
-         let current_components = &entity_components[&target_entity];
-         // first inject the current components
-         for (component, type_registration) in current_components {
-             updated_components.push((component.clone_value(), type_registration.clone()));
-         }
-         // then inject the new components: this also enables overwrite components set in the collection
-         for (component, type_registration) in reflect_components {
-             updated_components.push((component.clone_value(), type_registration));
-         }
-         entity_components.insert(target_entity, updated_components);
-     } else {
-         entity_components.insert(target_entity, reflect_components);
-     }
-}
-
-/// main function: injects components into each entity in gltf files that have `gltf_extras`, using reflection
-pub fn add_components_from_gltf_extras(world: &mut World) {
-    let mut extras =
-        world.query_filtered::<(Entity, &Name, &GltfExtras, &Parent), (Added<GltfExtras>, Without<GltfProcessed>)>();
-
-    let mut scene_extras = world.query_filtered::<(Entity, &Name, &GltfSceneExtras, &Parent), (Added<GltfSceneExtras>, Without<GltfProcessed>)>();
-    let mut mesh_extras = world.query_filtered::<(Entity, &Name, &GltfMeshExtras, &Parent), (Added<GltfMeshExtras>, Without<GltfProcessed>)>();
-    let mut material_extras = world.query_filtered::<(Entity, &Name, &GltfMaterialExtras, &Parent), (Added<GltfMaterialExtras>, Without<GltfProcessed>)>();
-
-    let mut entity_components: HashMap<Entity, Vec<(Box<dyn Reflect>, TypeRegistration)>> =
-        HashMap::new();
-
-    // let gltf_components_config = world.resource::<GltfComponentsConfig>();
-
-    for (entity, name, extra, parent) in extras.iter(world) {
-        debug!(
-            "Name: {}, entity {:?}, parent: {:?}, extras {:?}",
-            name, entity, parent, extra
-        );
-
-        let type_registry: &AppTypeRegistry = world.resource();
-        let type_registry = type_registry.read();
-        let reflect_components = ronstring_to_reflect_component(&extra.value, &type_registry);
-
-        bla_balb(entity, name, parent, reflect_components, entity_components);
-
-        /*
-        // we assign the components specified /xxx_components objects to their parent node
-        let mut target_entity = entity;
-        // if the node contains "components" or ends with "_pa" (ie add to parent), the components will not be added to the entity itself but to its parent
-        // this is mostly used for Blender collections
-        if name.as_str().contains("components") || name.as_str().ends_with("_pa") {
-            debug!("adding components to parent");
-            target_entity = parent.get();
-        }
-        debug!("adding to {:?}", target_entity);
-
-        // if there where already components set to be added to this entity (for example when entity_data was refering to a parent), update the vec of entity_components accordingly
-        // this allows for example blender collection to provide basic ecs data & the instances to override/ define their own values
-        if entity_components.contains_key(&target_entity) {
-            let mut updated_components: Vec<(Box<dyn Reflect>, TypeRegistration)> = Vec::new();
-            let current_components = &entity_components[&target_entity];
-            // first inject the current components
-            for (component, type_registration) in current_components {
-                updated_components.push((component.clone_value(), type_registration.clone()));
-            }
-            // then inject the new components: this also enables overwrite components set in the collection
-            for (component, type_registration) in reflect_components {
-                updated_components.push((component.clone_value(), type_registration));
-            }
-            entity_components.insert(target_entity, updated_components);
-        } else {
-            entity_components.insert(target_entity, reflect_components);
-        } */
-    }
-
-    for (entity, components) in entity_components {
-        let type_registry: &AppTypeRegistry = world.resource();
-        let type_registry = type_registry.clone();
-        let type_registry = type_registry.read();
-
-        if !components.is_empty() {
-            debug!("--entity {:?}, components {}", entity, components.len());
-        }
-        for (component, type_registration) in components {
-            debug!(
-                "------adding {} {:?}",
-                component.get_represented_type_info().unwrap().type_path(),
-                component
-            );
-
-            {
-                let mut entity_mut = world.entity_mut(entity);
-                type_registration
-                    .data::<ReflectComponent>()
-                    .expect("Unable to reflect component")
-                    .insert(&mut entity_mut, &*component, &type_registry);
-
-                entity_mut.insert(GltfProcessed); //  this is how can we insert any additional components
-            }
-        }
-    }
-}

crates/blenvy/src/ronstring_to_reflect_component.rs

@@ -1,134 +0,0 @@
-use bevy::log::{debug, warn};
-use bevy::reflect::serde::ReflectDeserializer;
-use bevy::reflect::{Reflect, TypeRegistration, TypeRegistry};
-use bevy::utils::HashMap;
-use ron::Value;
-use serde::de::DeserializeSeed;
-
-use super::capitalize_first_letter;
-
-pub fn ronstring_to_reflect_component(
-    ron_string: &str,
-    type_registry: &TypeRegistry,
-) -> Vec<(Box<dyn Reflect>, TypeRegistration)> {
-    let lookup: HashMap<String, Value> = ron::from_str(ron_string).unwrap();
-    let mut components: Vec<(Box<dyn Reflect>, TypeRegistration)> = Vec::new();
-    // println!("ron_string {:?}", ron_string);
-    for (name, value) in lookup.into_iter() {
-        let parsed_value: String = match value.clone() {
-            Value::String(str) => {
-                str
-            }
-            _ => ron::to_string(&value).unwrap().to_string(),
-        };
-
-        if name.as_str() == "bevy_components" {
-            bevy_components_string_to_components(parsed_value, type_registry, &mut components);
-        } else {
-            components_string_to_components(
-                name,
-                value,
-                parsed_value,
-                type_registry,
-                &mut components,
-            );
-        }
-    }
-    components
-}
-
-fn components_string_to_components(
-    name: String,
-    value: Value,
-    parsed_value: String,
-    type_registry: &TypeRegistry,
-    components: &mut Vec<(Box<dyn Reflect>, TypeRegistration)>,
-) {
-    let type_string = name.replace("component: ", "").trim().to_string();
-    let capitalized_type_name = capitalize_first_letter(type_string.as_str());
-
-    if let Some(type_registration) =
-        type_registry.get_with_short_type_path(capitalized_type_name.as_str())
-    {
-        debug!("TYPE INFO {:?}", type_registration.type_info());
-
-        let ron_string = format!(
-            "{{ \"{}\":{} }}",
-            type_registration.type_info().type_path(),
-            parsed_value
-        );
-
-        // usefull to determine what an entity looks like Serialized
-        /*let test_struct = CameraRenderGraph::new("name");
-        let serializer = ReflectSerializer::new(&test_struct, &type_registry);
-        let serialized =
-            ron::ser::to_string_pretty(&serializer, ron::ser::PrettyConfig::default()).unwrap();
-        println!("serialized Component {}", serialized);*/
-
-        debug!("component data ron string {}", ron_string);
-        let mut deserializer = ron::Deserializer::from_str(ron_string.as_str())
-            .expect("deserialzer should have been generated from string");
-        let reflect_deserializer = ReflectDeserializer::new(type_registry);
-        let component = reflect_deserializer
-            .deserialize(&mut deserializer)
-            .unwrap_or_else(|_| {
-                panic!(
-                    "failed to deserialize component {} with value: {:?}",
-                    name, value
-                )
-            });
-
-        debug!("component {:?}", component);
-        debug!("real type {:?}", component.get_represented_type_info());
-        components.push((component, type_registration.clone()));
-        debug!("found type registration for {}", capitalized_type_name);
-    } else {
-        warn!("no type registration for {}", capitalized_type_name);
-    }
-}
-
-fn bevy_components_string_to_components(
-    parsed_value: String,
-    type_registry: &TypeRegistry,
-    components: &mut Vec<(Box<dyn Reflect>, TypeRegistration)>,
-) {
-    let lookup: HashMap<String, Value> = ron::from_str(&parsed_value).unwrap();
-    for (key, value) in lookup.into_iter() {
-        let parsed_value: String = match value.clone() {
-            Value::String(str) => {
-                str
-            }
-            _ => ron::to_string(&value).unwrap().to_string(),
-        };
-
-        if let Some(type_registration) = type_registry.get_with_type_path(key.as_str()) {
-            debug!("TYPE INFO {:?}", type_registration.type_info());
-
-            let ron_string = format!(
-                "{{ \"{}\":{} }}",
-                type_registration.type_info().type_path(),
-                parsed_value
-            );
-
-            debug!("component data ron string {}", ron_string);
-            let mut deserializer = ron::Deserializer::from_str(ron_string.as_str())
-                .expect("deserialzer should have been generated from string");
-            let reflect_deserializer = ReflectDeserializer::new(type_registry);
-            let component = reflect_deserializer
-                .deserialize(&mut deserializer)
-                .unwrap_or_else(|_| {
-                    panic!(
-                        "failed to deserialize component {} with value: {:?}",
-                        key, value
-                    )
-                });
-
-            debug!("component {:?}", component);
-            debug!("real type {:?}", component.get_represented_type_info());
-            components.push((component, type_registration.clone()));
-            debug!("found type registration for {}", key);
-        } else {
-            warn!("no type registration for {}", key);
-        }
-    }
-}

crates/blenvy/src/utils.rs

@@ -1,3 +0,0 @@
-pub fn capitalize_first_letter(s: &str) -> String {
-    s[0..1].to_uppercase() + &s[1..]
-}

testing/bevy_example/Cargo.toml

@@ -5,14 +5,13 @@ edition = "2021"
 license = "MIT OR Apache-2.0"
 
 [dependencies]
-bevy = { version = "0.14.0-rc.3", features = ["dynamic_linking"] }
+bevy = { version = "0.13", features = ["dynamic_linking"] }
 bevy_gltf_blueprints = { path = "../../crates/bevy_gltf_blueprints" }
 bevy_registry_export = { path = "../../crates/bevy_registry_export" }
-# bevy_gltf_worlflow_examples_common_rapier = { path = "../../examples/common_rapier" }
+bevy_gltf_worlflow_examples_common_rapier = { path = "../../examples/common_rapier" }
-#bevy_gltf_worlflow_examples_common = { path = "../../examples/common" }
 
-#evy_rapier3d = { version = "0.25.0", features = ["serde-serialize", "debug-render-3d", "enhanced-determinism"] }
+bevy_rapier3d = { version = "0.25.0", features = ["serde-serialize", "debug-render-3d", "enhanced-determinism"] }
-#bevy_asset_loader = { version = "0.20", features = ["standard_dynamic_assets"] }
+bevy_asset_loader = { version = "0.20", features = ["standard_dynamic_assets"] }
-#bevy_editor_pls = { version = "0.8" }
+bevy_editor_pls = { version = "0.8" }
 rand = "0.8.5"
 json-writer ="0.3"

testing/bevy_example/src/game/animation.rs

@@ -34,7 +34,6 @@ pub fn setup_main_scene_animations(asset_server: Res<AssetServer>, mut commands:
     commands.insert_resource(AnimTest(asset_server.load("levels/World.glb")));
 }
 
-/* 
 #[allow(clippy::type_complexity)]
 pub fn animations(
     added_animation_players: Query<(Entity, &Name, &AnimationPlayer)>,
@@ -226,7 +225,7 @@ pub fn play_animations(
         }
     }
 }
-*/
+
 pub fn react_to_animation_markers(
     mut animation_marker_events: EventReader<AnimationMarkerReached>,
 ) {

testing/bevy_example/src/game/in_game.rs

@@ -1,8 +1,8 @@
 use bevy::prelude::*;
 use bevy_gltf_blueprints::{BluePrintBundle, BlueprintName, BlueprintPath, GameWorldTag};
-use crate::{GameState, InAppRunning};
+use bevy_gltf_worlflow_examples_common_rapier::{GameState, InAppRunning};
 
-//use bevy_rapier3d::prelude::Velocity;
+use bevy_rapier3d::prelude::Velocity;
 use rand::Rng;
 
 pub fn setup_game(
@@ -69,10 +69,10 @@ pub fn spawn_test(
                 // BlueprintName("Health_Pickup".to_string()),
                 // SpawnHere,
                 TransformBundle::from_transform(Transform::from_xyz(x, 2.0, y)),
-                /*Velocity {
+                Velocity {
                     linvel: Vec3::new(vel_x, vel_y, vel_z),
                     angvel: Vec3::new(0.0, 0.0, 0.0),
-                },*/
+                },
             ))
             .id();
         commands.entity(world).add_child(new_entity);

testing/bevy_example/src/game/mod.rs

@@ -1,8 +1,7 @@
-pub mod in_game;
-pub use in_game::*;
-
 pub mod animation;
+pub mod in_game;
 pub use animation::*;
+pub use in_game::*;
 
 use std::{collections::HashMap, fs, time::Duration};
 
@@ -14,14 +13,12 @@ use bevy::{
     prelude::*, render::view::screenshot::ScreenshotManager, time::common_conditions::on_timer,
     window::PrimaryWindow,
 };
-use crate::{AppState, GameState};
+use bevy_gltf_worlflow_examples_common_rapier::{AppState, GameState};
 
 use json_writer::to_json_string;
 
 fn start_game(mut next_app_state: ResMut<NextState<AppState>>) {
-    println!("START GAME");
+    next_app_state.set(AppState::AppLoading);
-    //next_app_state.set(AppState::AppLoading);
-    next_app_state.set(AppState::AppRunning);
 }
 
 // if the export from Blender worked correctly, we should have animations (simplified here by using AnimationPlayerLink)
@@ -124,7 +121,7 @@ fn generate_screenshot(
 }
 
 fn exit_game(mut app_exit_events: ResMut<Events<bevy::app::AppExit>>) {
-    app_exit_events.send(bevy::app::AppExit::Success);
+    app_exit_events.send(bevy::app::AppExit);
 }
 
 pub struct GamePlugin;
@@ -137,18 +134,16 @@ impl Plugin for GamePlugin {
 
             .add_systems(Update, (spawn_test).run_if(in_state(GameState::InGame)))
             .add_systems(Update, validate_export)
-            //.add_systems(OnEnter(AppState::CoreLoading), start_game)
-
             .add_systems(OnEnter(AppState::MenuRunning), start_game)
             .add_systems(OnEnter(AppState::AppRunning), setup_game)
 
             .add_systems(OnEnter(AppState::MenuRunning), setup_main_scene_animations)
-            /* .add_systems(Update, (animations)
+            .add_systems(Update, (animations)
                 .run_if(in_state(AppState::AppRunning))
                 .after(GltfBlueprintsSet::AfterSpawn)
             )
             .add_systems(Update, play_animations)
-            .add_systems(Update, react_to_animation_markers)*/
+            .add_systems(Update, react_to_animation_markers)
 
              /*.add_systems(Update, generate_screenshot.run_if(on_timer(Duration::from_secs_f32(0.2)))) // TODO: run once
             .add_systems(

testing/bevy_example/src/hierarchy_debug.rs

@@ -1,146 +0,0 @@
-use bevy::{gltf::{GltfMaterialExtras, GltfMeshExtras, GltfSceneExtras}, prelude::*};
-use bevy_gltf_blueprints::{AllAssets, BlueprintInstanceReady};
-
-use crate::BasicTest;
-
-#[derive(Component)]
-pub struct HiearchyDebugTag;
-
-pub fn setup_hierarchy_debug(mut commands: Commands, asset_server: Res<AssetServer>){
-     // a place to display the extras on screen
-     commands.spawn((
-        TextBundle::from_section(
-            "",
-            TextStyle {
-                color: LinearRgba { red: 1.0, green:0.0, blue: 0.0, alpha: 1.0}.into(),
-                font_size: 10.,
-                ..default()
-            },
-        )
-        .with_style(Style {
-            position_type: PositionType::Absolute,
-            top: Val::Px(12.0),
-            left: Val::Px(12.0),
-            ..default()
-        }),
-        HiearchyDebugTag,
-    ));
-}
-
-
-pub fn get_descendants(
-    all_children: &Query<&Children>, 
-    all_names:&Query<&Name>, root: &Entity, 
-    nesting: usize, 
-    to_check: &Query<&BasicTest>//&Query<(&BlueprintInstanceReady, &AllAssets)>,
-) 
-    -> String
-{
-
-    let mut hierarchy_display: Vec<String> = vec![];
-    let root_name = all_names.get(*root);
-    let name;
-    if root_name.is_ok() {
-        name = root_name.unwrap().to_string();
-    }else {
-        name = "no_name".to_string()
-    }
-
-    let components_to_check = to_check.get(*root);
-
-    hierarchy_display.push( format!("{}{} ({:?})", " ".repeat(nesting), name, components_to_check) ); // 
-
-
-    if let Ok(children) = all_children.get(*root) {
-
-        for child in children.iter() {
-
-            let child_descendants_display = get_descendants(&all_children, &all_names, &child, nesting + 4, &to_check);
-            hierarchy_display.push(child_descendants_display);
-        }
-    }
-    return hierarchy_display.join("\n");
-}
-
-pub fn draw_hierarchy_debug(
-    root: Query<(Entity, Option<&Name>, &Children), (Without<Parent>)>,
-    all_children: Query<&Children>,
-    all_names:Query<&Name>,
-
-    to_check: Query<&BasicTest>,//Query<(&BlueprintInstanceReady, &AllAssets)>,
-    mut display: Query<&mut Text, With<HiearchyDebugTag>>,
-){
-    let mut hierarchy_display: Vec<String> = vec![];
-
-    for (root_entity, name, children) in root.iter() {
-        // hierarchy_display.push( format!("Hierarchy root{:?}", name) );
-    
-        hierarchy_display.push(get_descendants(&all_children, &all_names, &root_entity, 0, &to_check));
-        // let mut children = all_children.get(root_entity);
-        /*for child in children.iter() {
-            // hierarchy_display
-            let name = all_names.get(*child); //.unwrap_or(&Name::new("no name"));
-            hierarchy_display.push(format!("  {:?}", name))
-        }*/
-        
-        //         
-    }
-    let mut display = display.single_mut();
-    display.sections[0].value = hierarchy_display.join("\n");
-}
-
-
-
-////////:just some testing for gltf extras
-fn check_for_gltf_extras(
-gltf_extras_per_entity: Query<(
-    Entity,
-    Option<&Name>,
-    Option<&GltfSceneExtras>,
-    Option<&GltfExtras>,
-    Option<&GltfMeshExtras>,
-    Option<&GltfMaterialExtras>,
-)>,
-mut display: Query<&mut Text, With<HiearchyDebugTag>>,
-) {
-let mut gltf_extra_infos_lines: Vec<String> = vec![];
-
-for (id, name, scene_extras, extras, mesh_extras, material_extras) in
-    gltf_extras_per_entity.iter()
-{
-    if scene_extras.is_some()
-        //|| extras.is_some()
-        || mesh_extras.is_some()
-        || material_extras.is_some()
-    {
-        let formatted_extras = format!(
-            "Extras per entity {} ('Name: {}'):
-- scene extras:     {:?}
-- mesh extras:      {:?}
-- material extras:  {:?}
-            ",
-            id,
-            name.unwrap_or(&Name::default()),
-            scene_extras,
-            //extras,
-            mesh_extras,
-            material_extras
-        );
-        gltf_extra_infos_lines.push(formatted_extras);
-    }
-    let mut display = display.single_mut();
-    display.sections[0].value = gltf_extra_infos_lines.join("\n");
-}
-}
-
-pub struct HiearchyDebugPlugin;
-impl Plugin for HiearchyDebugPlugin {
-    fn build(&self, app: &mut App) {
-        app
-            .add_systems(Startup, setup_hierarchy_debug)
-            .add_systems(Update, draw_hierarchy_debug)
-            //.add_systems(Update, check_for_gltf_extras)
-
-           ;
-    }
-}

testing/bevy_example/src/main.rs

@@ -1,7 +1,5 @@
 use bevy::prelude::*;
-// use bevy_gltf_worlflow_examples_common::CommonPlugin;
+use bevy_gltf_worlflow_examples_common_rapier::CommonPlugin;
-mod state;
-use state::*;
 
 mod core;
 use crate::core::*;
@@ -13,18 +11,12 @@ mod dupe_components;
 mod test_components;
 use test_components::*;
 
-mod hierarchy_debug;
-use hierarchy_debug::*;
-
 fn main() {
     App::new()
         .add_plugins((
             DefaultPlugins.set(AssetPlugin::default()),
-
-            HiearchyDebugPlugin,
             // our custom plugins
-            // CommonPlugin,
+            CommonPlugin,
-            StatePlugin,
             CorePlugin,           // reusable plugins
             GamePlugin,           // specific to our game
             ComponentsTestPlugin, // Showcases different type of components /structs

testing/bevy_example/src/state.rs

@@ -1,59 +0,0 @@
-use bevy::prelude::*;
-
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, Default, States)]
-pub enum AppState {
-    CoreLoading,
-    #[default]
-    MenuRunning,
-    AppLoading,
-    AppRunning,
-    AppEnding,
-}
-
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, Default, States)]
-pub enum GameState {
-    #[default]
-    None,
-
-    InMenu,
-    InGame,
-
-    InGameOver,
-
-    InSaving,
-    InLoading,
-}
-
-// tag components for all entities within a certain state (for despawning them if needed) , FIXME: seems kinda hack-ish
-#[derive(Component)]
-pub struct InCoreLoading;
-#[derive(Component, Default)]
-pub struct InMenuRunning;
-#[derive(Component)]
-
-pub struct InAppRunning;
-
-// components for tagging in game vs in game menu stuff
-#[derive(Component, Default)]
-pub struct InMainMenu;
-
-#[derive(Component, Default)]
-pub struct InMenu;
-
-#[derive(Component, Default)]
-pub struct InGame;
-
-#[derive(Component, Default)]
-pub struct InGameSaving;
-
-#[derive(Component, Default)]
-pub struct InGameLoading;
-
-pub struct StatePlugin;
-impl Plugin for StatePlugin {
-    fn build(&self, app: &mut App) {
-        app
-            .init_state::<AppState>()
-            .init_state::<GameState>();
-    }
-}

testing/bevy_example/src/test_components.rs

@@ -117,10 +117,6 @@ pub struct VecOfVec3s2(Vec<TupleVec3>);
 #[reflect(Component)]
 pub struct VecOfColors(Vec<Color>);
 
-#[derive(Component, Reflect, Default, Debug)]
-#[reflect(Component)]
-pub struct VecOfUints(Vec<u32>);
-
 #[derive(Component, Reflect, Default, Debug)]
 #[reflect(Component)]
 pub struct AAAAddedCOMPONENT;
@@ -200,18 +196,6 @@ pub struct ComponentAToFilterOut;
 #[reflect(Component)]
 pub struct ComponentBToFilterOut;
 
-#[derive(Component, Reflect, Default, Debug)]
-#[reflect(Component)]
-pub struct ComponentWithFieldsOfIdenticalType{
-    pub first: f32,
-    pub second: f32,
-    pub third: Vec<f32>,
-    pub fourth: Vec<f32>,
-}
-#[derive(Component, Reflect, Default, Debug)]
-#[reflect(Component)]
-pub struct ComponentWithFieldsOfIdenticalType2(f32, f32, f32);
-
 pub struct ComponentsTestPlugin;
 impl Plugin for ComponentsTestPlugin {
     fn build(&self, app: &mut App) {
@@ -243,9 +227,6 @@ impl Plugin for ComponentsTestPlugin {
             .register_type::<Range<f32>>()
             .register_type::<VecOfF32s>()
             .register_type::<Vec<f32>>()
-            .register_type::<u32>()
-            .register_type::<Vec<u32>>()
-            .register_type::<VecOfUints>()
             // .register_type::<AAAAddedCOMPONENT>()
             .register_type::<AComponentWithAnExtremlyExageratedOrMaybeNotButCouldBeNameOrWut>()
             .register_type::<HashMap<String, String>>()
@@ -261,9 +242,6 @@ impl Plugin for ComponentsTestPlugin {
             .register_type::<HashmapTestStringColorFlat>()
             .register_type::<ComponentAToFilterOut>()
             .register_type::<ComponentBToFilterOut>()
-            .register_type::<ComponentWithFieldsOfIdenticalType>()
-            .register_type::<ComponentWithFieldsOfIdenticalType2>()
-
             .add_plugins(MaterialPlugin::<
                 ExtendedMaterial<StandardMaterial, MyExtension>,
             >::default());

tools/blenvy/TODO.md

@@ -95,7 +95,7 @@ Components:
         -> VERY likely due to the int-offset computation for hashes of components
         - now switched to tiger_hash
         - [x] add warning about hash colision (not much we can/ could do if it is the case ?)
-        - [x] double check weird collisions AND/OR reuse existing if applicable
+        - [ ] double check weird collisions AND/OR reuse existing if applicable
 
     - [x] annoying default path for registry, should be relative to the assets path
 
@@ -156,20 +156,15 @@ General issues:
     - [ ] rename project to Blenvy
     - [ ] replace all references to the old 2 add-ons with those to Blenvy
 - [ ] rename repo to "Blenvy"
-- [x] switch to bevy 0.14 rc2
-- [ ] find a solution for the new color handling 
-- [ ] add back lighting_components
-- [ ] check if scene components are being deleted through our scene re-orgs in the spawn post process
 
 
 - [ ] simplify testing example:
-    - [x] remove use of rapier physics (or even the whole common boilerplate ?)
+    - [ ] remove use of rapier physics (or even the whole common boilerplate ?)
     - [ ] remove/replace bevy editor pls with some native ui to display hierarchies
+    - [ ] switch to bevy rc2
+
 
 
-- [ ] simplify examples:
-    - [ ] a full fledged demo (including physics & co)
-    - [ ] other examples without interactions or physics 
 
 
 - [x] overall cleanup

tools/blenvy/add_ons/auto_export/common/generate_temporary_scene_and_export.py

@@ -20,13 +20,23 @@ def generate_temporary_scene_and_export(settings, gltf_export_settings, gltf_out
     temp_root_collection = temp_scene.collection
 
     print("additional_dataAAAAAAAAAAAAAAAH", additional_data)
-    properties_black_list = ['user_assets', 'components_meta']
     if additional_data is not None: # FIXME not a fan of having this here
         for entry in dict(additional_data):
-            # we copy everything over except those on the black list
+            print("entry in additional data", entry)
-            if entry not in properties_black_list:
+            if entry == "local_assets":
-                print("entry in additional data", entry, "value", additional_data[entry], "in", additional_data.name)
+                temp_scene["local_assets"] = additional_data[entry] # this is for bevy 0.14
-                temp_scene[entry] = additional_data[entry]
+                temp_root_collection["local_assets"] = additional_data[entry] # for previous bevy versions, remove when migration done
+                bla = "[(name: \"test_asset\", path: \"audio/fake.mp3\")]"
+                local_assets = additional_data.get(entry, [])
+                local_assets = [entry for entry in local_assets]
+                add_scene_property(temp_scene, 'assets_components', {"LocalAssets":  f"LocalAssets({local_assets})".replace("'", '')}) 
+
+            if entry == entry == "AllAssets":
+                temp_scene["AllAssets"] = additional_data[entry]
+                temp_root_collection["AllAssets"] = additional_data[entry] # for previous bevy versions, remove when migration done
+                all_assets = additional_data.get(entry, [])
+                all_assets = [entry for entry in all_assets]
+                add_scene_property(temp_scene, 'assets_components', {"AllAssets":  f"AllAssets({all_assets})".replace("'", '')}) 
 
     # save active scene
     active_scene = bpy.context.window.scene
@@ -111,13 +121,13 @@ def clear_hollow_scene(temp_scene, original_root_collection):
     def restore_original_names(collection):
         if collection.name.endswith("____bak"):
             collection.name = collection.name.replace("____bak", "")
-        for object in collection.all_objects:
+        for object in collection.objects:
-            """if object.instance_type == 'COLLECTION':
+            if object.instance_type == 'COLLECTION':
+                if object.name.endswith("____bak"):
+                    object.name = object.name.replace("____bak", "")
+            else: 
                 if object.name.endswith("____bak"):
                     object.name = object.name.replace("____bak", "")
-            else: """
-            if object.name.endswith("____bak"):
-                object.name = object.name.replace("____bak", "")
         for child_collection in collection.children:
             restore_original_names(child_collection)
     

tools/blenvy/add_ons/auto_export/levels/bevy_scene_components.py

@@ -5,33 +5,32 @@ from blenvy.core.object_makers import make_empty
 # TODO: replace this with placing scene level custom properties once support for that has been added to bevy_gltf
 def upsert_scene_components(main_scenes):
     for scene in main_scenes:
-        """lighting_components_name = f"lighting_components_{scene.name}"
+        lighting_components_name = f"lighting_components_{scene.name}"
         lighting_components = bpy.data.objects.get(lighting_components_name, None)
         if not lighting_components:
             root_collection = scene.collection
-            lighting_components = make_empty('lighting_components_'+scene.name, [0,0,0], [0,0,0], [0,0,0], root_collection)"""
+            lighting_components = make_empty('lighting_components_'+scene.name, [0,0,0], [0,0,0], [0,0,0], root_collection)
 
-        """if scene.world is not None:
+        if scene.world is not None:
-            lighting_components['BlenderBackgroundShader'] = ambient_color_to_component(scene.world)""" # FIXME add back
+            lighting_components['BlenderBackgroundShader'] = ambient_color_to_component(scene.world)
-        scene['BlenderShadowSettings'] = scene_shadows_to_component(scene)
+        lighting_components['BlenderShadowSettings'] = scene_shadows_to_component(scene)
 
         if scene.eevee.use_bloom:
-            scene['BloomSettings'] = scene_bloom_to_component(scene)
+            lighting_components['BloomSettings'] = scene_bloom_to_component(scene)
-        elif 'BloomSettings' in scene:
+        elif 'BloomSettings' in lighting_components:
-            del scene['BloomSettings']
+            del lighting_components['BloomSettings']
 
         if scene.eevee.use_gtao: 
-            scene['SSAOSettings'] = scene_ao_to_component(scene)
+            lighting_components['SSAOSettings'] = scene_ao_to_component(scene)
-        elif 'SSAOSettings' in scene:
+        elif 'SSAOSettings' in lighting_components:
-            del scene['SSAOSettings']
+            del lighting_components['SSAOSettings']
 
 def remove_scene_components(main_scenes):
-    pass
+    for scene in main_scenes:
-    """for scene in main_scenes:
         lighting_components_name = f"lighting_components_{scene.name}"
         lighting_components = bpy.data.objects.get(lighting_components_name, None)
         if lighting_components:
-            bpy.data.objects.remove(lighting_components, do_unlink=True)"""
+            bpy.data.objects.remove(lighting_components, do_unlink=True)
 
 
 def ambient_color_to_component(world):
@@ -45,7 +44,7 @@ def ambient_color_to_component(world):
    
 
     if color is not None and strength is not None:
-        colorRgba = f"LinearRgba(red: {color[0]}, green: {color[1]}, blue: {color[2]}, alpha: {color[3]})"
+        colorRgba = f"Rgba(red: {color[0]}, green: {color[1]}, blue: {color[2]}, alpha: {color[3]})"
         component = f"( color: {colorRgba}, strength: {strength})"
         return component
     return None

tools/blenvy/add_ons/bevy_components/components/metadata.py

@@ -220,7 +220,7 @@ def upsert_component_in_item(item, long_name, registry):
             if property_group_name in registry.component_propertyGroups:
                 # we have found a matching property_group, so try to inject it
                 # now inject property group
-                setattr(ComponentMetadata, property_group_name, registry.component_propertyGroups[property_group_name]) # FIXME: not ideal as ALL instances of ComponentMetadata get the propGroup, but have not found a way to assign it per instance
+                setattr(ComponentMetadata, property_group_name, registry.component_propertyGroups[property_group_name]) # FIXME: not ideal as all ComponentMetadata get the propGroup, but have not found a way to assign it per instance
                 propertyGroup = getattr(component_meta, property_group_name, None)
         
         # now deal with property groups details

tools/blenvy/add_ons/bevy_components/propGroups/process_component.py

@@ -30,14 +30,13 @@ def process_component(registry, definition, update, extras=None, nesting_long_na
     with_list = False
     with_map = False
 
-    #padding = "  " * (len(nesting_long_names) + 1)
+    padding = "  " * (len(nesting_long_names) + 1)
     #print(f"{padding}process component", long_name, "nesting_long_names",nesting_long_names, "foo", has_properties, has_prefixItems, is_enum, is_list, is_map)
 
     if has_properties:
         __annotations__ = __annotations__ | process_structs.process_structs(registry, definition, properties, update, nesting_long_names)
         with_properties = True
         tupple_or_struct = "struct"
-        #print(f"{padding}struct")
 
     if has_prefixItems:
         __annotations__ = __annotations__ | process_tupples.process_tupples(registry, definition, prefixItems, update, nesting_long_names)
@@ -62,6 +61,7 @@ def process_component(registry, definition, update, extras=None, nesting_long_na
     for a in __annotations__:
         field_names.append(a)
  
+
     extras = extras if extras is not None else {
         "long_name": long_name
     }
@@ -78,16 +78,25 @@ def process_component(registry, definition, update, extras=None, nesting_long_na
         **dict(with_properties = with_properties, with_items= with_items, with_enum= with_enum, with_list= with_list, with_map = with_map, short_name= short_name, long_name=long_name),
         'root_component': root_component
     }
-    
+    #FIXME: YIKES, but have not found another way: 
-    # we need to pass the full hierarchy to disambiguate between components 
+    """ Withouth this ; the following does not work
-    # Withouth this ; the following does not work
-    """ 
     -BasicTest
     - NestingTestLevel2
         -BasicTest => the registration & update callback of this one overwrites the first "basicTest"
+    have not found a cleaner workaround so far
     """
+    property_group_name = registry.generate_propGroup_name(nesting_long_names)
+    (property_group_pointer, property_group_class) = property_group_from_infos(property_group_name, property_group_params)
     # add our component propertyGroup to the registry
-    (property_group_pointer, property_group_class) = registry.register_component_propertyGroup(nesting_long_names, property_group_params)
+    registry.register_component_propertyGroup(property_group_name, property_group_pointer)
 
     return (property_group_pointer, property_group_class)
                 
+def property_group_from_infos(property_group_name, property_group_parameters):
+    # print("creating property group", property_group_name)
+    property_group_class = type(property_group_name, (PropertyGroup,), property_group_parameters)
+    
+    bpy.utils.register_class(property_group_class)
+    property_group_pointer = PointerProperty(type=property_group_class)
+    
+    return (property_group_pointer, property_group_class)

tools/blenvy/add_ons/bevy_components/propGroups/process_structs.py

@@ -33,7 +33,7 @@ def process_structs(registry, definition, properties, update, nesting_long_names
                     __annotations__[property_name] = blender_property
             else:
                 original_long_name = original["long_name"]
-                (sub_component_group, _) = process_component.process_component(registry, original, update, {"nested": True, "long_name": original_long_name}, nesting_long_names+[property_name])
+                (sub_component_group, _) = process_component.process_component(registry, original, update, {"nested": True, "long_name": original_long_name}, nesting_long_names)
                 __annotations__[property_name] = sub_component_group
         # if there are sub fields, add an attribute "sub_fields" possibly a pointer property ? or add a standard field to the type , that is stored under "attributes" and not __annotations (better)
         else:

tools/blenvy/add_ons/bevy_components/propGroups/prop_groups.py

@@ -34,10 +34,12 @@ def generate_propertyGroups_for_components():
 
     type_infos = registry.type_infos
 
-    for root_type_name in type_infos:
+    for component_name in type_infos:
-        definition = type_infos[root_type_name]
+        definition = type_infos[component_name]
-        #print("root property", component_name,f"({is_component})")
+        is_component = definition['isComponent'] if "isComponent" in definition else False
-        process_component(registry, definition, update_calback_helper(definition, update_component, root_type_name), extras=None, nesting_long_names=[])
+        root_property_name = component_name# if is_component else None
+        print("root property", component_name,f"({is_component})")
+        process_component(registry, definition, update_calback_helper(definition, update_component, root_property_name), extras=None, nesting_long_names=[])
         
     # if we had to add any wrapper types on the fly, process them now
     registry.process_custom_types()

tools/blenvy/add_ons/bevy_components/registry/registry.py

@@ -7,8 +7,6 @@ from bpy_types import (PropertyGroup)
 from bpy.props import (StringProperty, BoolProperty, FloatProperty, FloatVectorProperty, IntProperty, IntVectorProperty, EnumProperty, PointerProperty, CollectionProperty)
 from ..components.metadata import ComponentMetadata
 from .hashing.tiger import hash as tiger_hash
-
-
 # helper class to store missing bevy types information
 class MissingBevyType(bpy.types.PropertyGroup):
     long_name: bpy.props.StringProperty(
@@ -16,15 +14,6 @@ class MissingBevyType(bpy.types.PropertyGroup):
     ) # type: ignore
 
 
-def property_group_from_infos(property_group_name, property_group_parameters):
-    # print("creating property group", property_group_name)
-    property_group_class = type(property_group_name, (PropertyGroup,), property_group_parameters)
-    
-    bpy.utils.register_class(property_group_class)
-    property_group_pointer = PointerProperty(type=property_group_class)
-    
-    return (property_group_pointer, property_group_class)
-
 # this is where we store the information for all available components
 class ComponentsRegistry(PropertyGroup):
     registry: bpy.props. StringProperty(
@@ -151,8 +140,6 @@ class ComponentsRegistry(PropertyGroup):
     type_infos = {}
     type_infos_missing = []
     component_propertyGroups = {}
-    component_property_group_classes = []
-
     custom_types_to_add = {}
     invalid_components = []
 
@@ -165,18 +152,8 @@ class ComponentsRegistry(PropertyGroup):
         for propgroup_name in cls.component_propertyGroups.keys():
             try:
                 delattr(ComponentMetadata, propgroup_name)
-                #print("sucess REMOVAL from Metadata")
             except Exception as error:
                 pass
-                #print("failed to unregister")
-
-        for propgroup_class in cls.component_property_group_classes:
-            try:
-                bpy.utils.unregister_class(propgroup_class)
-                #print("sucess UNREGISTER")
-            except Exception as error:
-                pass
-                #print("NEW failed to unregister")
         
         del bpy.types.WindowManager.components_registry
 
@@ -190,10 +167,7 @@ class ComponentsRegistry(PropertyGroup):
         self.missing_types_list.clear()
         self.type_infos.clear()
         self.type_infos_missing.clear()
-
         self.component_propertyGroups.clear()
-        self.component_property_group_classes.clear()
-
         self.custom_types_to_add.clear()
         self.invalid_components.clear()
         # now prepare paths to load data
@@ -214,6 +188,10 @@ class ComponentsRegistry(PropertyGroup):
     def has_type_infos(self):
         return len(self.type_infos.keys()) != 0
 
+    # we keep a list of component propertyGroup around 
+    def register_component_propertyGroup(self, name, propertyGroup):
+        self.component_propertyGroups[name] = propertyGroup
+
     # to be able to give the user more feedback on any missin/unregistered types in their schema file
     def add_missing_typeInfo(self, long_name):
         if not long_name in self.type_infos_missing:
@@ -239,25 +217,18 @@ class ComponentsRegistry(PropertyGroup):
         
     long_names_to_propgroup_names = {}
 
-    # we keep a list of component propertyGroup around 
-    def register_component_propertyGroup(self, nesting, property_group_params):
-        property_group_name = self.generate_propGroup_name(nesting)
-        (property_group_pointer, property_group_class) = property_group_from_infos(property_group_name, property_group_params)
-        self.component_propertyGroups[property_group_name] = property_group_pointer
-        self.component_property_group_classes.append(property_group_class)
-
-        return (property_group_pointer, property_group_class)
-
     # generate propGroup name from nesting level: each longName + nesting is unique
     def generate_propGroup_name(self, nesting):
+        #print("gen propGroup name for", shortName, nesting)
         key = str(nesting)
 
         propGroupHash = tiger_hash(key)
         propGroupName = propGroupHash + "_ui"
 
         # check for collision
-        #padding = "  " * (len(nesting) + 1)
+        padding = "  " * (len(nesting) + 1)
-        #print(f"{padding}--computing hash for", nesting)
+
+        print(f"{padding}--computing hash for", nesting)
         if propGroupName in self.long_names_to_propgroup_names.values(): 
             print("  WARNING !! you have a collision between the hash of multiple component names: collision for", nesting)
 
@@ -268,6 +239,7 @@ class ComponentsRegistry(PropertyGroup):
     def get_propertyGroupName_from_longName(self, longName):
         return self.long_names_to_propgroup_names.get(str([longName]), None)
     
+
     ###########
 
 """