Merge branch 'main' into better-validate-warnings

Author: MiniaczQ

crates/bevy_ecs/src/reflect/component.rs

@@ -60,7 +60,7 @@
 use super::from_reflect_with_fallback;
 use crate::{
     change_detection::Mut,
-    component::Component,
+    component::{Component, ComponentId},
     entity::Entity,
     world::{
         unsafe_world_cell::UnsafeEntityCell, EntityMut, EntityWorldMut, FilteredEntityMut,
@@ -119,6 +119,8 @@ pub struct ReflectComponentFns {
     pub reflect_unchecked_mut: unsafe fn(UnsafeEntityCell<'_>) -> Option<Mut<'_, dyn Reflect>>,
     /// Function pointer implementing [`ReflectComponent::copy()`].
     pub copy: fn(&World, &mut World, Entity, Entity, &TypeRegistry),
+    /// Function pointer implementing [`ReflectComponent::register_component()`].
+    pub register_component: fn(&mut World) -> ComponentId,
 }
 
 impl ReflectComponentFns {
@@ -220,6 +222,11 @@ impl ReflectComponent {
         );
     }
 
+    /// Register the type of this [`Component`] in [`World`], returning its [`ComponentId`].
+    pub fn register_component(&self, world: &mut World) -> ComponentId {
+        (self.0.register_component)(world)
+    }
+
     /// Create a custom implementation of [`ReflectComponent`].
     ///
     /// This is an advanced feature,
@@ -303,6 +310,9 @@ impl<C: Component + Reflect + TypePath> FromType<C> for ReflectComponent {
                 let c = unsafe { entity.get_mut::<C>() };
                 c.map(|c| c.map_unchanged(|value| value as &mut dyn Reflect))
             },
+            register_component: |world: &mut World| -> ComponentId {
+                world.register_component::<C>()
+            },
         })
     }
 }

crates/bevy_ecs/src/reflect/resource.rs

@@ -6,6 +6,7 @@
 
 use crate::{
     change_detection::Mut,
+    component::ComponentId,
     system::Resource,
     world::{unsafe_world_cell::UnsafeWorldCell, World},
 };
@@ -59,6 +60,8 @@ pub struct ReflectResourceFns {
     pub reflect_unchecked_mut: unsafe fn(UnsafeWorldCell<'_>) -> Option<Mut<'_, dyn Reflect>>,
     /// Function pointer implementing [`ReflectResource::copy()`].
     pub copy: fn(&World, &mut World, &TypeRegistry),
+    /// Function pointer implementing [`ReflectResource::register_resource()`].
+    pub register_resource: fn(&mut World) -> ComponentId,
 }
 
 impl ReflectResourceFns {
@@ -145,6 +148,11 @@ impl ReflectResource {
         (self.0.copy)(source_world, destination_world, registry);
     }
 
+    /// Register the type of this [`Resource`] in [`World`], returning the [`ComponentId`]
+    pub fn register_resource(&self, world: &mut World) -> ComponentId {
+        (self.0.register_resource)(world)
+    }
+
     /// Create a custom implementation of [`ReflectResource`].
     ///
     /// This is an advanced feature,
@@ -217,6 +225,10 @@ impl<R: Resource + FromReflect + TypePath> FromType<R> for ReflectResource {
                     from_reflect_with_fallback::<R>(source_resource, destination_world, registry);
                 destination_world.insert_resource(destination_resource);
             },
+
+            register_resource: |world: &mut World| -> ComponentId {
+                world.register_resource::<R>()
+            },
         })
     }
 }

crates/bevy_ecs/src/world/mod.rs

@@ -334,6 +334,25 @@ impl World {
         self.components.component_id::<T>()
     }
 
+    /// Registers a new [`Resource`] type and returns the [`ComponentId`] created for it.
+    ///
+    /// Note that the resource doesn't have a value in world, it's only registered.
+    /// if you want to insert the [`Resource`] in the [`World`], use [`World::init_resource`] or [`World::insert_resource`] instead.
+    pub fn register_resource<R: Resource>(&mut self) -> ComponentId {
+        self.components.register_resource::<R>()
+    }
+
+    /// Returns the [`ComponentId`] of the given [`Resource`] type `T`.
+    ///
+    /// The returned `ComponentId` is specific to the `World` instance
+    /// it was retrieved from and should not be used with another `World` instance.
+    ///
+    /// Returns [`None`] if the `Resource` type has not yet been initialized within
+    /// the `World` using [`World::register_resource`], [`World::init_resource`] or [`World::insert_resource`].
+    pub fn resource_id<T: Resource>(&self) -> Option<ComponentId> {
+        self.components.get_resource_id(TypeId::of::<T>())
+    }
+
     /// Retrieves an [`EntityRef`] that exposes read-only operations for the given `entity`.
     /// This will panic if the `entity` does not exist. Use [`World::get_entity`] if you want
     /// to check for entity existence instead of implicitly panic-ing.

crates/bevy_gltf/src/loader.rs

@@ -4,9 +4,6 @@ use crate::{
 };
 
 use alloc::collections::VecDeque;
-use bevy_animation::prelude::{
-    Keyframes, MorphWeightsKeyframes, RotationKeyframes, ScaleKeyframes, TranslationKeyframes,
-};
 use bevy_asset::{
     io::Reader, AssetLoadError, AssetLoader, Handle, LoadContext, ReadAssetBytesError,
 };
@@ -65,7 +62,7 @@ use std::{
 use thiserror::Error;
 #[cfg(feature = "bevy_animation")]
 use {
-    bevy_animation::{AnimationTarget, AnimationTargetId},
+    bevy_animation::{prelude::*, AnimationTarget, AnimationTargetId},
     smallvec::SmallVec,
 };
 
@@ -277,7 +274,7 @@ async fn load_gltf<'a, 'b, 'c>(
         let mut named_animations = HashMap::default();
         let mut animation_roots = HashSet::default();
         for animation in gltf.animations() {
-            let mut animation_clip = bevy_animation::AnimationClip::default();
+            let mut animation_clip = AnimationClip::default();
             for channel in animation.channels() {
                 let interpolation = match channel.sampler().interpolation() {
                     gltf::animation::Interpolation::Linear => Interpolation::Linear,
@@ -330,7 +327,7 @@ async fn load_gltf<'a, 'b, 'c>(
                     animation_roots.insert(*root_index);
                     animation_clip.add_curve_to_target(
                         AnimationTargetId::from_names(path.iter()),
-                        bevy_animation::VariableCurve {
+                        VariableCurve {
                             keyframe_timestamps,
                             keyframes,
                             interpolation,
@@ -738,7 +735,7 @@ async fn load_gltf<'a, 'b, 'c>(
                 if animation_roots.contains(&node.index()) {
                     world
                         .entity_mut(*node_index_to_entity_map.get(&node.index()).unwrap())
-                        .insert(bevy_animation::AnimationPlayer::default());
+                        .insert(AnimationPlayer::default());
                 }
             }
         }
@@ -2468,7 +2465,7 @@ mod test {
         {
             "inverseBindMatrices": 0,
             "joints": [1, 2]
-        }  
+        }
     ],
     "buffers": [
         {
@@ -2480,15 +2477,15 @@ mod test {
         {
             "buffer": 0,
             "byteLength": 128
-        }  
+        }
     ],
     "accessors": [
         {
             "bufferView" : 0,
             "componentType" : 5126,
             "count" : 2,
             "type" : "MAT4"
-        }  
+        }
     ],
     "scene": 0,
     "scenes": [{ "nodes": [0] }]