Add marker for ExtractResource (#22867)

# Objective

- Followup to #22766
- Step towards #22852

## Solution

- Add marker to `ExtractResouce`
- Pass marker to `SyncComponent`

## Testing

- `cargo run --example animated_mesh`

Author: Zeophlite

crates/bevy_render/src/extract_component.rs

@@ -38,10 +38,10 @@ impl<C: Component> DynamicUniformIndex<C> {
 ///
 /// The Out type is defined in [`SyncComponent`].
 ///
-/// The marker type is only used as a way to bypass the orphan rules. To
+/// The marker type `F` is only used as a way to bypass the orphan rules. To
 /// implement the trait for a foreign type you can use a local type as the
 /// marker, e.g. the type of the plugin that calls [`ExtractComponentPlugin`].
-pub trait ExtractComponent<Marker = ()>: SyncComponent {
+pub trait ExtractComponent<F = ()>: SyncComponent<F> {
     /// ECS [`ReadOnlyQueryData`] to fetch the components to extract.
     type QueryData: ReadOnlyQueryData;
     /// Filters the entities with additional constraints.
@@ -151,6 +151,10 @@ fn prepare_uniform_components<C>(
 ///
 /// It also registers [`SyncComponentPlugin`] to ensure the extracted components
 /// are deleted if the main world components are removed.
+///
+/// The marker type `F` is only used as a way to bypass the orphan rules. To
+/// implement the trait for a foreign type you can use a local type as the
+/// marker, e.g. the type of the plugin that calls [`ExtractComponentPlugin`].
 pub struct ExtractComponentPlugin<C, F = ()> {
     only_extract_visible: bool,
     marker: PhantomData<fn() -> (C, F)>,
@@ -174,22 +178,22 @@ impl<C, F> ExtractComponentPlugin<C, F> {
     }
 }
 
-impl<C: ExtractComponent<Marker>, Marker: 'static> Plugin for ExtractComponentPlugin<C, Marker> {
+impl<C: ExtractComponent<F>, F: 'static + Send + Sync> Plugin for ExtractComponentPlugin<C, F> {
     fn build(&self, app: &mut App) {
-        app.add_plugins(SyncComponentPlugin::<C>::default());
+        app.add_plugins(SyncComponentPlugin::<C, F>::default());
 
         if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
             if self.only_extract_visible {
-                render_app.add_systems(ExtractSchedule, extract_visible_components::<C, Marker>);
+                render_app.add_systems(ExtractSchedule, extract_visible_components::<C, F>);
             } else {
-                render_app.add_systems(ExtractSchedule, extract_components::<C, Marker>);
+                render_app.add_systems(ExtractSchedule, extract_components::<C, F>);
             }
         }
     }
 }
 
 /// This system extracts all components of the corresponding [`ExtractComponent`], for entities that are synced via [`crate::sync_world::SyncToRenderWorld`].
-fn extract_components<C: ExtractComponent<Marker>, Marker>(
+fn extract_components<C: ExtractComponent<F>, F>(
     mut commands: Commands,
     mut previous_len: Local<usize>,
     query: Extract<Query<(RenderEntity, C::QueryData), C::QueryFilter>>,
@@ -207,7 +211,7 @@ fn extract_components<C: ExtractComponent<Marker>, Marker>(
 }
 
 /// This system extracts all components of the corresponding [`ExtractComponent`], for entities that are visible and synced via [`crate::sync_world::SyncToRenderWorld`].
-fn extract_visible_components<C: ExtractComponent<Marker>, Marker>(
+fn extract_visible_components<C: ExtractComponent<F>, F>(
     mut commands: Commands,
     mut previous_len: Local<usize>,
     query: Extract<Query<(RenderEntity, &ViewVisibility, C::QueryData), C::QueryFilter>>,

crates/bevy_render/src/extract_resource.rs

@@ -11,7 +11,11 @@ use crate::{Extract, ExtractSchedule, RenderApp};
 ///
 /// Therefore the resource is transferred from the "main world" into the "render world"
 /// in the [`ExtractSchedule`] step.
-pub trait ExtractResource: Resource {
+///
+/// The marker type `F` is only used as a way to bypass the orphan rules. To
+/// implement the trait for a foreign type you can use a local type as the
+/// marker, e.g. the type of the plugin that calls [`ExtractResourcePlugin`].
+pub trait ExtractResource<F = ()>: Resource {
     type Source: Resource;
 
     /// Defines how the resource is transferred into the "render world".
@@ -22,18 +26,22 @@ pub trait ExtractResource: Resource {
 ///
 /// Therefore it sets up the[`ExtractSchedule`] step
 /// for the specified [`Resource`].
-pub struct ExtractResourcePlugin<R: ExtractResource>(PhantomData<R>);
+///
+/// The marker type `F` is only used as a way to bypass the orphan rules. To
+/// implement the trait for a foreign type you can use a local type as the
+/// marker, e.g. the type of the plugin that calls [`ExtractResourcePlugin`].
+pub struct ExtractResourcePlugin<R: ExtractResource<F>, F = ()>(PhantomData<(R, F)>);
 
-impl<R: ExtractResource> Default for ExtractResourcePlugin<R> {
+impl<R: ExtractResource<F>, F> Default for ExtractResourcePlugin<R, F> {
     fn default() -> Self {
         Self(PhantomData)
     }
 }
 
-impl<R: ExtractResource> Plugin for ExtractResourcePlugin<R> {
+impl<R: ExtractResource<F>, F: 'static + Send + Sync> Plugin for ExtractResourcePlugin<R, F> {
     fn build(&self, app: &mut App) {
         if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
-            render_app.add_systems(ExtractSchedule, extract_resource::<R>);
+            render_app.add_systems(ExtractSchedule, extract_resource::<R, F>);
         } else {
             once!(bevy_log::error!(
                 "Render app did not exist when trying to add `extract_resource` for <{}>.",
@@ -44,7 +52,7 @@ impl<R: ExtractResource> Plugin for ExtractResourcePlugin<R> {
 }
 
 /// This system extracts the resource of the corresponding [`Resource`] type
-pub fn extract_resource<R: ExtractResource>(
+pub fn extract_resource<R: ExtractResource<F>, F>(
     mut commands: Commands,
     main_resource: Extract<Option<Res<R::Source>>>,
     target_resource: Option<ResMut<R>>,

crates/bevy_render/src/sync_component.rs

@@ -12,16 +12,20 @@ use crate::sync_world::{EntityRecord, PendingSyncEntity, SyncToRenderWorld};
 ///
 /// This plugin is automatically added by [`ExtractComponentPlugin`], and only needs to be added for manual extraction implementations.
 ///
+/// The marker type `F` is only used as a way to bypass the orphan rules. To
+/// implement the trait for a foreign type you can use a local type as the
+/// marker, e.g. the type of the plugin that calls [`SyncComponentPlugin`].
+///
 /// # Implementation details
 ///
 /// It adds [`SyncToRenderWorld`] as a required component to make the [`SyncWorldPlugin`] aware of the component, and
 /// handles cleanup of the component in the render world when it is removed from an entity.
 ///
 /// [`ExtractComponentPlugin`]: crate::extract_component::ExtractComponentPlugin
 /// [`SyncWorldPlugin`]: crate::sync_world::SyncWorldPlugin
-pub struct SyncComponentPlugin<C, Marker = ()>(PhantomData<(C, Marker)>);
+pub struct SyncComponentPlugin<C, F = ()>(PhantomData<(C, F)>);
 
-impl<C: SyncComponent<Marker>, Marker> Default for SyncComponentPlugin<C, Marker> {
+impl<C: SyncComponent<F>, F> Default for SyncComponentPlugin<C, F> {
     fn default() -> Self {
         Self(PhantomData)
     }
@@ -33,12 +37,12 @@ impl<C: SyncComponent<Marker>, Marker> Default for SyncComponentPlugin<C, Marker
 /// This trait is a subtrait of [`ExtractComponent`], which uses it to determine
 /// which components to extract.
 ///
-/// The marker type is only used as a way to bypass the orphan rules. To
+/// The marker type `F` is only used as a way to bypass the orphan rules. To
 /// implement the trait for a foreign type you can use a local type as the
 /// marker, e.g. the type of the plugin that calls [`SyncComponentPlugin`].
 ///
 /// [`ExtractComponent`]: crate::extract_component::ExtractComponent
-pub trait SyncComponent<Marker = ()>: Component {
+pub trait SyncComponent<F = ()>: Component {
     /// Describes what components should be removed from the render world if the
     /// implementing component is removed.
     ///
@@ -51,9 +55,7 @@ pub trait SyncComponent<Marker = ()>: Component {
     // type Out: Component = Self;
 }
 
-impl<C: SyncComponent<Marker>, Marker: Send + Sync + 'static> Plugin
-    for SyncComponentPlugin<C, Marker>
-{
+impl<C: SyncComponent<F>, F: Send + Sync + 'static> Plugin for SyncComponentPlugin<C, F> {
     fn build(&self, app: &mut App) {
         app.register_required_components::<C, SyncToRenderWorld>();