Start migration

Author: SarahIhme

Cargo.lock

@@ -3,27 +3,27 @@ members = ["crates/*", "examples/*"]
 resolver = "2"
 
 [workspace.package]
-version = "0.10.0"
+version = "0.11.0"
 license = "MIT OR Apache-2.0"
 readme = "README.md"
 edition = "2024"
 repository = "https://github.com/mbrea-c/bevy_animation_graph"
 
 [workspace.dependencies]
-bevy_animation_graph_proc_macros = { version = "0.10.0", path = "./crates/bevy_animation_graph_proc_macros" }
-bevy_animation_graph = { version = "0.10.0", path = "./crates/bevy_animation_graph" }
-bevy_animation_graph_core = { version = "0.10.0", path = "./crates/bevy_animation_graph_core" }
-bevy_animation_graph_builtin_nodes = { version = "0.10.0", path = "./crates/bevy_animation_graph_builtin_nodes" }
+bevy_animation_graph_proc_macros = { version = "0.11.0", path = "./crates/bevy_animation_graph_proc_macros" }
+bevy_animation_graph = { version = "0.11.0", path = "./crates/bevy_animation_graph" }
+bevy_animation_graph_core = { version = "0.11.0", path = "./crates/bevy_animation_graph_core" }
+bevy_animation_graph_builtin_nodes = { version = "0.11.0", path = "./crates/bevy_animation_graph_builtin_nodes" }
 
-bevy = { version = "0.18" }
-avian3d = { version = "0.5" }
+bevy = { version = "0.19" }
+avian3d = { version = "0.7" }
 
-egui_dock = "0.18"
-egui-notify = { version = "0.21" }
-egui = { version = "0.33" }
-egui_extras = { version = "0.33", features = ["all_loaders"] }
-bevy_egui = { version = "0.39" }
-bevy-inspector-egui = { version = "0.36" }
+egui_dock = "0.19"
+egui-notify = { version = "0.22" }
+egui = { version = "0.34" }
+egui_extras = { version = "0.34", features = ["all_loaders"] }
+bevy_egui = { version = "0.40.0" }
+bevy-inspector-egui = { version = "0.37" }
 
 ron = "0.10.1"
 serde = "1.0"

Cargo.toml

@@ -2,7 +2,7 @@ use bevy::{
     asset::{AssetLoader, AssetPath, Handle, LoadContext, io::Reader},
     platform::collections::HashMap,
     reflect::TypePath,
-    scene::Scene,
+    world_serialization::WorldAsset,
 };
 use serde::{Deserialize, Serialize};
 
@@ -51,7 +51,7 @@ impl AssetLoader for AnimatedSceneLoader {
 
         let animation_graph: Handle<AnimationGraph> = load_context.load(serial.animation_graph);
         let skeleton: Handle<Skeleton> = load_context.load(serial.skeleton);
-        let source: Handle<Scene> = load_context.load(serial.source);
+        let source: Handle<WorldAsset> = load_context.load(serial.source);
         let retargeting: Option<Retargeting> = serial.retargeting.map(|r| Retargeting {
             source_skeleton: load_context.load(r.source_skeleton),
             bone_path_overrides: r.bone_path_overrides,

crates/bevy_animation_graph_core/src/animated_scene/loader.rs

@@ -15,8 +15,8 @@ use bevy::{
     },
     platform::collections::HashMap,
     reflect::Reflect,
-    scene::{Scene, SceneInstanceReady, SceneRoot},
     transform::components::Transform,
+    world_serialization::{WorldAsset, WorldAssetRoot, WorldInstanceReady},
 };
 
 use super::{animation_clip::EntityPath, errors::AssetLoaderError, id::BoneId, skeleton::Skeleton};
@@ -29,8 +29,8 @@ use crate::{
 #[derive(Clone, Asset, Reflect)]
 #[reflect(Asset)]
 pub struct AnimatedScene {
-    pub source: Handle<Scene>,
-    pub processed_scene: Option<Handle<Scene>>,
+    pub source: Handle<WorldAsset>,
+    pub processed_scene: Option<Handle<WorldAsset>>,
     pub animation_graph: Handle<AnimationGraph>,
     pub retargeting: Option<Retargeting>,
     /// Skeleton of the animations we want to play on the source scene.
@@ -84,20 +84,20 @@ impl AnimatedSceneHandle {
 /// Processed animated scenes are "cached".
 pub(crate) fn spawn_animated_scenes(
     mut commands: Commands,
-    unloaded_scenes: Query<(Entity, &AnimatedSceneHandle), Without<SceneRoot>>,
+    unloaded_scenes: Query<(Entity, &AnimatedSceneHandle), Without<WorldAssetRoot>>,
     mut animated_scene_assets: ResMut<Assets<AnimatedScene>>,
-    mut scenes: ResMut<Assets<Scene>>,
+    mut scenes: ResMut<Assets<WorldAsset>>,
     skeletons: Res<Assets<Skeleton>>,
     app_type_registry: Res<AppTypeRegistry>,
 ) {
     for (entity, animscn_handle) in &unloaded_scenes {
-        let Some(animscn) = animated_scene_assets.get_mut(&animscn_handle.handle) else {
+        let Some(mut animscn) = animated_scene_assets.get_mut(&animscn_handle.handle) else {
             continue;
         };
 
         let processed_scene = if let Some(val) = animscn.processed_scene.as_ref() {
             val
-        } else if is_scene_ready_to_process(animscn, &scenes, &skeletons) {
+        } else if is_scene_ready_to_process(&animscn, &scenes, &skeletons) {
             let Some(scene) = scenes
                 .get(&animscn.source)
                 .and_then(|scn| scn.clone_with(&app_type_registry).ok())
@@ -124,14 +124,14 @@ pub(crate) fn spawn_animated_scenes(
 
         commands
             .entity(entity)
-            .insert(SceneRoot(processed_scene.clone()));
+            .insert(WorldAssetRoot(processed_scene.clone()));
     }
 }
 
 /// Checks whether the scene can be processed
 fn is_scene_ready_to_process(
     animscn: &AnimatedScene,
-    scenes: &Assets<Scene>,
+    scenes: &Assets<WorldAsset>,
     skeletons: &Assets<Skeleton>,
 ) -> bool {
     scenes.contains(&animscn.source) && skeletons.contains(&animscn.skeleton)
@@ -142,14 +142,14 @@ fn is_scene_ready_to_process(
 /// It also applies retargeting if necessary.
 #[allow(clippy::result_large_err, clippy::too_many_arguments)]
 fn process_scene_into_animscn(
-    mut scene: Scene,
+    mut scene: WorldAsset,
     skeleton_handle: Handle<Skeleton>,
     ragdoll_handle: Option<Handle<Ragdoll>>,
     ragdoll_bone_map_handle: Option<Handle<RagdollBoneMap>>,
     graph: Handle<AnimationGraph>,
     skeletons: &Assets<Skeleton>,
     retargeting: Option<&Retargeting>,
-) -> Result<Scene, AssetLoaderError> {
+) -> Result<WorldAsset, AssetLoaderError> {
     let mut query = scene
         .world
         .query_filtered::<Entity, With<bevy::animation::AnimationPlayer>>();
@@ -219,7 +219,7 @@ fn apply_bone_path_overrides(
 /// Adds an `AnimatedSceneInstance` pointing to the animation graph player when the scene is
 /// spawned
 pub(crate) fn locate_animated_scene_player(
-    trigger: On<SceneInstanceReady>,
+    trigger: On<WorldInstanceReady>,
     handle_query: Query<&AnimatedSceneHandle>,
     mut player_query: Query<&mut AnimationGraphPlayer>,
     children_query: Query<&Children>,

crates/bevy_animation_graph_core/src/animated_scene/mod.rs

@@ -48,12 +48,8 @@ impl AssetLoader for GraphClipLoader {
                 path,
                 animation_name,
             } => {
-                let gltf_loaded_asset = load_context
-                    .loader()
-                    .immediate()
-                    .with_unknown_type()
-                    .load(path)
-                    .await?;
+                let gltf_loaded_asset =
+                    load_context.load_builder().load_untyped_value(path).await?;
                 let gltf: &Gltf = gltf_loaded_asset.get().unwrap();
 
                 let Some(clip_handle) = gltf
@@ -78,7 +74,7 @@ impl AssetLoader for GraphClipLoader {
             }
         };
 
-        let skeleton = load_context.loader().load(serial.skeleton);
+        let skeleton = load_context.load_builder().load(serial.skeleton);
 
         let clip_mine = GraphClip::from_bevy_clip(
             bevy_clip,

crates/bevy_animation_graph_core/src/animation_clip/loader.rs

@@ -41,11 +41,11 @@ impl ::bevy::reflect::Typed for DynNodeLike {
         static CELL: ::bevy::reflect::utility::NonGenericTypeInfoCell =
             ::bevy::reflect::utility::NonGenericTypeInfoCell::new();
         CELL.get_or_set(|| {
-            ::bevy::reflect::TypeInfo::TupleStruct(::bevy::reflect::TupleStructInfo::new::<Self>(
-                &[
+            ::bevy::reflect::TypeInfo::TupleStruct(
+                ::bevy::reflect::tuple_struct::TupleStructInfo::new::<Self>(&[
                         // ::bevy::reflect::UnnamedField::new::<Box<dyn NodeLike>>(0usize),
-                    ],
-            ))
+                    ]),
+            )
         })
     }
 }
@@ -103,7 +103,7 @@ impl ::bevy::reflect::Reflect for DynNodeLike {
 ::bevy::reflect::__macro_exports::auto_register::inventory::submit! {
     ::bevy::reflect::__macro_exports::auto_register::AutomaticReflectRegistrations(<DynNodeLike as ::bevy::reflect::__macro_exports::auto_register::RegisterForReflection> ::__register)
 }
-impl ::bevy::reflect::TupleStruct for DynNodeLike {
+impl ::bevy::reflect::tuple_struct::TupleStruct for DynNodeLike {
     fn field(&self, index: usize) -> Option<&dyn ::bevy::reflect::PartialReflect> {
         match index {
             0usize => Some(self.0.as_partial_reflect()),
@@ -121,8 +121,8 @@ impl ::bevy::reflect::TupleStruct for DynNodeLike {
         1usize
     }
     #[inline]
-    fn iter_fields(&'_ self) -> ::bevy::reflect::TupleStructFieldIter<'_> {
-        ::bevy::reflect::TupleStructFieldIter::new(self)
+    fn iter_fields(&'_ self) -> ::bevy::reflect::tuple_struct::TupleStructFieldIter<'_> {
+        ::bevy::reflect::tuple_struct::TupleStructFieldIter::new(self)
     }
 }
 impl ::bevy::reflect::PartialReflect for DynNodeLike {
@@ -139,10 +139,10 @@ impl ::bevy::reflect::PartialReflect for DynNodeLike {
             ::bevy::reflect::PartialReflect::reflect_ref(value)
         {
             for (i, value) in ::core::iter::Iterator::enumerate(
-                ::bevy::reflect::TupleStruct::iter_fields(struct_value),
+                ::bevy::reflect::tuple_struct::TupleStruct::iter_fields(struct_value),
             ) {
                 if let ::core::option::Option::Some(v) =
-                    ::bevy::reflect::TupleStruct::field_mut(self, i)
+                    ::bevy::reflect::tuple_struct::TupleStruct::field_mut(self, i)
                 {
                     ::bevy::reflect::PartialReflect::try_apply(v, value)?;
                 }
@@ -201,7 +201,7 @@ impl ::bevy::reflect::PartialReflect for DynNodeLike {
         self
     }
     fn reflect_partial_eq(&self, value: &dyn ::bevy::reflect::PartialReflect) -> Option<bool> {
-        (::bevy::reflect::tuple_struct_partial_eq)(self, value)
+        (::bevy::reflect::tuple_struct::tuple_struct_partial_eq)(self, value)
     }
     #[inline]
     fn reflect_clone(

crates/bevy_animation_graph_core/src/animation_node/dyn_node_like/mod.rs

@@ -78,9 +78,8 @@ impl ReflectDeserializerProcessor for HandleDeserializeProcessor<'_, '_> {
         let asset_path = deserializer.deserialize_str(AssetPathVisitor)?;
         let untyped_handle = self
             .load_context
-            .loader()
-            .with_dynamic_type(asset_type_id)
-            .load(asset_path);
+            .load_builder()
+            .load_erased(asset_type_id, asset_path);
         let typed_handle = handle_info.typed(untyped_handle);
         Ok(Ok(typed_handle.into_partial_reflect()))
     }

crates/bevy_animation_graph_core/src/animation_node/dyn_node_like/serial.rs

@@ -46,7 +46,7 @@ impl ::bevy::reflect::Typed for NodeStateBox {
         static CELL: ::bevy::reflect::utility::NonGenericTypeInfoCell =
             ::bevy::reflect::utility::NonGenericTypeInfoCell::new();
         CELL.get_or_set(|| {
-            ::bevy::reflect::TypeInfo::Struct(::bevy::reflect::StructInfo::new::<Self>(&[
+            ::bevy::reflect::TypeInfo::Struct(::bevy::reflect::structs::StructInfo::new::<Self>(&[
                 ::bevy::reflect::NamedField::new::<String>("value"),
             ]))
         })
@@ -116,7 +116,7 @@ impl ::bevy::reflect::Reflect for NodeStateBox {
 ::bevy::reflect::__macro_exports::auto_register::inventory::submit! {
     ::bevy::reflect::__macro_exports::auto_register::AutomaticReflectRegistrations(<NodeStateBox as ::bevy::reflect::__macro_exports::auto_register::RegisterForReflection> ::__register)
 }
-impl ::bevy::reflect::Struct for NodeStateBox {
+impl ::bevy::reflect::structs::Struct for NodeStateBox {
     fn field(&self, name: &str) -> ::core::option::Option<&dyn ::bevy::reflect::PartialReflect> {
         match name {
             "value" => ::core::option::Option::Some(self.value.as_reflect()),
@@ -159,11 +159,12 @@ impl ::bevy::reflect::Struct for NodeStateBox {
     fn field_len(&self) -> usize {
         1usize
     }
-    fn iter_fields(&'_ self) -> ::bevy::reflect::FieldIter<'_> {
-        ::bevy::reflect::FieldIter::new(self)
+    fn iter_fields(&'_ self) -> ::bevy::reflect::structs::FieldIter<'_> {
+        ::bevy::reflect::structs::FieldIter::new(self)
     }
-    fn to_dynamic_struct(&self) -> ::bevy::reflect::DynamicStruct {
-        let mut dynamic: ::bevy::reflect::DynamicStruct = ::core::default::Default::default();
+    fn to_dynamic_struct(&self) -> ::bevy::reflect::structs::DynamicStruct {
+        let mut dynamic: ::bevy::reflect::structs::DynamicStruct =
+            ::core::default::Default::default();
         dynamic.set_represented_type(::bevy::reflect::PartialReflect::get_represented_type_info(
             self,
         ));
@@ -173,6 +174,13 @@ impl ::bevy::reflect::Struct for NodeStateBox {
         );
         dynamic
     }
+
+    fn index_of_name(&self, name: &str) -> Option<usize> {
+        match name {
+            "value" => ::core::option::Option::Some(0usize),
+            _ => ::core::option::Option::None,
+        }
+    }
 }
 impl ::bevy::reflect::PartialReflect for NodeStateBox {
     #[inline]
@@ -189,12 +197,9 @@ impl ::bevy::reflect::PartialReflect for NodeStateBox {
         if let ::bevy::reflect::ReflectRef::Struct(struct_value) =
             ::bevy::reflect::PartialReflect::reflect_ref(value)
         {
-            for (i, value) in ::core::iter::Iterator::enumerate(
-                ::bevy::reflect::Struct::iter_fields(struct_value),
-            ) {
-                let name = ::bevy::reflect::Struct::name_at(struct_value, i).unwrap();
+            for (name, value) in ::bevy::reflect::structs::Struct::iter_fields(struct_value) {
                 if let ::core::option::Option::Some(v) =
-                    ::bevy::reflect::Struct::field_mut(self, name)
+                    ::bevy::reflect::structs::Struct::field_mut(self, name)
                 {
                     ::bevy::reflect::PartialReflect::try_apply(v, value)?;
                 }
@@ -261,7 +266,7 @@ impl ::bevy::reflect::PartialReflect for NodeStateBox {
         &self,
         value: &dyn ::bevy::reflect::PartialReflect,
     ) -> ::core::option::Option<bool> {
-        (::bevy::reflect::struct_partial_eq)(self, value)
+        (::bevy::reflect::structs::struct_partial_eq)(self, value)
     }
     #[inline]
     fn reflect_clone(

crates/bevy_animation_graph_core/src/context/node_state_box.rs

@@ -201,7 +201,7 @@ impl AnimationGraphCorePlugin {
     fn register_component_hooks(&self, app: &mut App) {
         app.world_mut()
             .register_component_hooks::<AnimationGraphPlayer>()
-            .on_replace(|mut world, context| {
+            .on_discard(|mut world, context| {
                 if let Some(spawned_ragdoll) = world
                     .entity(context.entity)
                     .get::<AnimationGraphPlayer>()

crates/bevy_animation_graph_core/src/plugin.rs

@@ -1,4 +1,6 @@
 #[cfg(feature = "physics_avian")]
+use avian3d::dynamics::joints::AngularMotor;
+#[cfg(feature = "physics_avian")]
 use bevy::{ecs::system::Commands, math::Isometry3d};
 use bevy::{
     ecs::{entity::Entity, event::EntityEvent},
@@ -220,6 +222,7 @@ pub fn spawn_ragdoll_avian(
                             min: limit.min,
                             max: limit.max,
                         }),
+                        motor: AngularMotor::default(),
                         point_compliance: revolute_joint.point_compliance,
                         align_compliance: revolute_joint.align_compliance,
                         limit_compliance: revolute_joint.limit_compliance,