Add lazy registration support!

Cargo.toml

@@ -28,7 +28,7 @@ bevy_sprite = { version = "0.18.1", default-features = false }
 bevy_pbr = { version = "0.18.1", default-features = false }
 
 # other
-field_path = "0.3"
+field_path = "0.4.1"
 nonempty = { version = "0.12", default-features = false }
 
 [workspace.lints.clippy]

crates/bevy_motiongfx/README.md

@@ -48,9 +48,9 @@ fn build_timeline(
         .id();
 
     // Build the timeline.
-    let mut b = TimelineBuilder::new();
+    let mut b = motiongfx.create_bevy_builder();
     let track = b
-        .act_interp(entity, field!(<Transform>::translation::x), |x| {
+        .act_interp(entity, path!(<Transform>::translation::x), |x| {
             x + 6.0
         })
         .play(1.0)
@@ -82,12 +82,12 @@ fn build_timeline(
     commands.spawn(MeshMaterial3d(material.clone()));
 
     // Build the timeline.
-    let mut b = TimelineBuilder::new();
+    let mut b = motiongfx.create_bevy_builder();
     let track = b
         .act_interp(
           // AssetIds must be type-erased.
           material.untyped().id(),
-          field!(<StandardMaterial>::base_color),
+          path!(<StandardMaterial>::base_color),
           |_| Srgba::RED.into(),
         )
         .play(1.0)
@@ -115,7 +115,7 @@ fn build_timeline(
     mut motiongfx: ResMut<MotionGfxWorld>,
 ) {
     // Build the timeline.
-    let mut b = TimelineBuilder::new();
+    let mut b = motiongfx.create_bevy_builder();
     // Add tracks here...
     let timeline = b.compile();
 

crates/bevy_motiongfx/src/interpolation.rs

@@ -2,34 +2,38 @@ use bevy_math::*;
 use motiongfx::prelude::*;
 use motiongfx::subject::SubjectId;
 
-pub trait ActionInterpTimelineExt {
+pub trait ActionInterpTimelineExt<W> {
     fn act_interp<I, S, T>(
         &mut self,
         target: I,
-        field: Field<S, T>,
+        field_acc: FieldAccessor<S, T>,
         action: impl Action<T>,
     ) -> InterpActionBuilder<'_, T>
     where
+        W: SubjectSource<I, S>,
         I: SubjectId,
         S: 'static,
-        T: Interpolation + ThreadSafe;
+        T: Interpolation + Clone + ThreadSafe;
 }
 
-impl ActionInterpTimelineExt for TimelineBuilder {
+impl<W: 'static> ActionInterpTimelineExt<W>
+    for TimelineBuilder<'_, W>
+{
     /// Add an [`Action`] with interpolation using
     /// [`Interpolation::interp`].
     fn act_interp<I, S, T>(
         &mut self,
         target: I,
-        field: Field<S, T>,
+        field_acc: FieldAccessor<S, T>,
         action: impl Action<T>,
     ) -> InterpActionBuilder<'_, T>
     where
+        W: SubjectSource<I, S>,
         I: SubjectId,
         S: 'static,
-        T: Interpolation + ThreadSafe,
+        T: Interpolation + Clone + ThreadSafe,
     {
-        self.act(target, field, action).with_interp(T::interp)
+        self.act(target, field_acc, action).with_interp(T::interp)
     }
 }
 

crates/bevy_motiongfx/src/lib.rs

@@ -10,7 +10,6 @@ use crate::world::MotionGfxWorldPlugin;
 pub mod controller;
 pub mod interpolation;
 pub mod pipeline;
-pub mod registry;
 pub mod world;
 
 pub mod prelude {
@@ -20,11 +19,7 @@ pub mod prelude {
     pub use crate::interpolation::{
         ActionInterpTimelineExt, Interpolation,
     };
-    pub use crate::pipeline::{
-        PipelineRegistryExt, WorldPipeline, WorldPipelineRegistry,
-    };
-    pub use crate::register_fields;
-    pub use crate::registry::FieldPathRegisterAppExt;
+    pub use crate::pipeline::{BevyTimeline, BevyTimelineBuilder};
     pub use crate::world::{MotionGfxWorld, TimelineId};
 }
 
@@ -48,65 +43,6 @@ impl Plugin for BevyMotionGfxPlugin {
                 .chain(),
         );
         app.add_plugins((MotionGfxWorldPlugin, ControllerPlugin));
-
-        #[cfg(feature = "transform")]
-        {
-            use bevy_transform::components::Transform;
-
-            register_fields!(
-                app.register_component_field(),
-                Transform,
-                (
-                    translation(x, y, z),
-                    scale(x, y, z),
-                    rotation(x, y, z, w),
-                )
-            );
-        }
-
-        #[cfg(feature = "sprite")]
-        {
-            use bevy_sprite::prelude::*;
-
-            register_fields!(
-                app.register_component_field(),
-                Sprite,
-                (
-                    image,
-                    texture_atlas,
-                    color,
-                    flip_x,
-                    flip_y,
-                    custom_size,
-                    rect,
-                    image_mode,
-                )
-            );
-        }
-
-        #[cfg(feature = "pbr")]
-        {
-            use bevy_pbr::prelude::*;
-
-            register_fields!(
-                app.register_asset_field(),
-                StandardMaterial,
-                (
-                    base_color,
-                    emissive,
-                    perceptual_roughness,
-                    metallic,
-                    reflectance,
-                    specular_tint,
-                    diffuse_transmission,
-                    specular_transmission,
-                    thickness,
-                    ior,
-                    attenuation_distance,
-                    attenuation_color,
-                )
-            );
-        }
     }
 }
 

crates/bevy_motiongfx/src/pipeline.rs

@@ -2,124 +2,64 @@ use bevy_ecs::component::Mutable;
 use bevy_ecs::prelude::*;
 use motiongfx::prelude::*;
 
-pub type WorldPipelineRegistry = PipelineRegistry<World>;
-pub type WorldPipeline = Pipeline<World>;
-
-pub fn bake_component_actions<S, T>(world: &World, ctx: BakeCtx)
-where
-    S: Component,
-    T: Clone + ThreadSafe,
-{
-    ctx.bake::<Entity, S, T>(|entity| world.get::<S>(entity));
-}
+/// Newtype wrapper around [`World`] that is local to this crate,
+/// allowing [`SubjectSource`] impls without violating the orphan rule.
+#[repr(transparent)]
+pub struct BevyWorld(pub World);
+
+impl BevyWorld {
+    pub fn from_ref(world: &World) -> &Self {
+        // SAFETY: `BevyWorld` is repr(transparent) over `World`.
+        unsafe { &*(world as *const World as *const Self) }
+    }
 
-pub fn sample_component_actions<S, T>(
-    world: &mut World,
-    ctx: SampleCtx,
-) where
-    S: Component<Mutability = Mutable>,
-    T: Clone + ThreadSafe,
-{
-    ctx.sample::<Entity, S, T>(|entity, target, accessor| {
-        if let Some(mut source) = world.get_mut::<S>(entity) {
-            *accessor.get_mut(&mut source) = target;
-        }
-    });
+    pub fn from_mut(world: &mut World) -> &mut Self {
+        // SAFETY: `BevyWorld` is repr(transparent) over `World`.
+        unsafe { &mut *(world as *mut World as *mut Self) }
+    }
 }
 
-#[cfg(feature = "asset")]
-pub fn bake_asset_actions<S, T>(world: &World, ctx: BakeCtx)
-where
-    S: bevy_asset::Asset,
-    T: Clone + ThreadSafe,
+impl<S: Component<Mutability = Mutable>> SubjectSource<Entity, S>
+    for BevyWorld
 {
-    use bevy_asset::Assets;
-    use bevy_asset::UntypedAssetId;
-
-    let Some(assets) = world.get_resource::<Assets<S>>() else {
-        return;
-    };
+    fn get_source(&self, id: Entity) -> Option<&S> {
+        self.0.get::<S>(id)
+    }
 
-    ctx.bake::<UntypedAssetId, S, T>(|asset_id| {
-        assets.get(asset_id.typed::<S>())
-    });
+    fn apply_source<R>(
+        &mut self,
+        id: Entity,
+        f: impl FnOnce(&mut S) -> R,
+    ) -> Option<R> {
+        self.0.get_mut::<S>(id).map(|mut m| f(m.as_mut()))
+    }
 }
 
 #[cfg(feature = "asset")]
-pub fn sample_asset_actions<S, T>(world: &mut World, ctx: SampleCtx)
-where
-    S: bevy_asset::Asset,
-    T: Clone + ThreadSafe,
+impl<S: bevy_asset::Asset>
+    SubjectSource<bevy_asset::UntypedAssetId, S> for BevyWorld
 {
-    use bevy_asset::Assets;
-    use bevy_asset::UntypedAssetId;
-
-    let Some(mut assets) = world.get_resource_mut::<Assets<S>>()
-    else {
-        return;
-    };
-
-    ctx.sample::<UntypedAssetId, S, T>(
-        |asset_id, target, accessor| {
-            if let Some(source) =
-                assets.get_mut(asset_id.typed::<S>())
-            {
-                *accessor.get_mut(source) = target;
-            }
-        },
-    );
-}
-
-pub trait PipelineRegistryExt {
-    fn register_component<S, T>(&mut self) -> PipelineKey
-    where
-        S: Component<Mutability = Mutable>,
-        T: Clone + ThreadSafe;
-
-    #[cfg(feature = "asset")]
-    fn register_asset<S, T>(&mut self) -> PipelineKey
-    where
-        S: bevy_asset::Asset,
-        T: Clone + ThreadSafe;
-}
-
-impl PipelineRegistryExt for WorldPipelineRegistry {
-    fn register_component<S, T>(&mut self) -> PipelineKey
-    where
-        S: Component<Mutability = Mutable>,
-        T: Clone + ThreadSafe,
-    {
-        let key = PipelineKey::new::<Entity, S, T>();
-
-        self.register_unchecked(
-            key,
-            WorldPipeline::new(
-                bake_component_actions::<S, T>,
-                sample_component_actions::<S, T>,
-            ),
-        );
-
-        key
+    fn get_source(
+        &self,
+        id: bevy_asset::UntypedAssetId,
+    ) -> Option<&S> {
+        self.0
+            .get_resource::<bevy_asset::Assets<S>>()?
+            .get(id.typed::<S>())
     }
 
-    #[cfg(feature = "asset")]
-    fn register_asset<S, T>(&mut self) -> PipelineKey
-    where
-        S: bevy_asset::Asset,
-        T: Clone + ThreadSafe,
-    {
-        use bevy_asset::UntypedAssetId;
-
-        let key = PipelineKey::new::<UntypedAssetId, S, T>();
-
-        self.register_unchecked(
-            key,
-            WorldPipeline::new(
-                bake_asset_actions::<S, T>,
-                sample_asset_actions::<S, T>,
-            ),
-        );
-
-        key
+    fn apply_source<R>(
+        &mut self,
+        id: bevy_asset::UntypedAssetId,
+        f: impl FnOnce(&mut S) -> R,
+    ) -> Option<R> {
+        self.0
+            .get_resource_mut::<bevy_asset::Assets<S>>()?
+            .into_inner()
+            .get_mut(id.typed::<S>())
+            .map(f)
     }
 }
+
+pub type BevyTimeline = Timeline<BevyWorld>;
+pub type BevyTimelineBuilder<'a> = TimelineBuilder<'a, BevyWorld>;