Finish API

Cleverly avoid needing the param to be 'static

This same trick can't work for `StaticSystemParam` fwiw
This is because `StaticSystemParam`'s item needs to exactly
reference the original param, whereas this just stores it

Author: DJMcNab

crates/bevy_render/src/extract_param.rs

@@ -1,82 +1,36 @@
-use std::ops::{Deref, DerefMut};
-
 use crate::MainWorld;
 use bevy_ecs::{
     prelude::*,
     system::{
-        ReadOnlySystemParamFetch, SystemParam, SystemParamFetch, SystemParamItem, SystemParamState,
-        SystemState,
+        ReadOnlySystemParamFetch, SystemParam, SystemParamFetch, SystemParamItem, SystemState,
     },
 };
 
-pub struct ExtractFromMainWorld<'s, P: SystemParam + 'static>(SystemParamItem<'s, 's, P>)
-where
-    P::Fetch: ReadOnlySystemParamFetch;
-
-impl<'s, P: SystemParam + 'static> Deref for ExtractFromMainWorld<'s, P>
-where
-    P::Fetch: ReadOnlySystemParamFetch,
-{
-    type Target = SystemParamItem<'s, 's, P>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl<'s, P: SystemParam + 'static> DerefMut for ExtractFromMainWorld<'s, P>
-where
-    P::Fetch: ReadOnlySystemParamFetch,
-{
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
-}
+pub struct MainWorldState<P: SystemParam>(SystemState<P>);
 
-impl<'s, P: SystemParam + 'static> ExtractFromMainWorld<'s, P>
-where
-    P::Fetch: ReadOnlySystemParamFetch,
-{
-    pub fn into_inner(self) -> SystemParamItem<'s, 's, P> {
-        self.0
+impl<P: SystemParam> FromWorld for MainWorldState<P> {
+    fn from_world(world: &mut World) -> Self {
+        Self(SystemState::new(&mut world.resource_mut::<MainWorld>().0))
     }
 }
 
-impl<'s, P: SystemParam + 'static> SystemParam for ExtractFromMainWorld<'s, P>
+#[derive(SystemParam)]
+pub struct Extract<'w, 's, P: SystemParam + 'static>
 where
     P::Fetch: ReadOnlySystemParamFetch,
 {
-    type Fetch = ExtractFromMainWorldState<P>;
+    state: Local<
+        's,
+        MainWorldState<<<P as SystemParam>::Fetch as SystemParamFetch<'static, 'static>>::Item>,
+    >,
+    world: Res<'w, World>,
 }
 
-unsafe impl<P: SystemParam + 'static> SystemParamState for ExtractFromMainWorldState<P> {
-    fn init(world: &mut World, system_meta: &mut bevy_ecs::system::SystemMeta) -> Self {
-        Self {
-            world: SystemParamState::init(world, system_meta),
-            state: SystemState::new(&mut (*world.resource_mut::<MainWorld>())),
-        }
-    }
-}
-
-pub struct ExtractFromMainWorldState<P: SystemParam + 'static> {
-    world: <Res<'static, MainWorld> as SystemParam>::Fetch,
-    state: SystemState<P>,
-}
-
-impl<'world, 'state, P: SystemParam + 'static> SystemParamFetch<'world, 'state>
-    for ExtractFromMainWorldState<P>
+impl<'w, 's, P: SystemParam + 'static> Extract<'w, 's, P>
 where
     P::Fetch: ReadOnlySystemParamFetch,
 {
-    type Item = ExtractFromMainWorld<'state, P>;
-
-    unsafe fn get_param(
-        state: &'state mut Self,
-        system_meta: &bevy_ecs::system::SystemMeta,
-        world: &'world World,
-        change_tick: u32,
-    ) -> Self::Item {
-        let world = SystemParamFetch::get_param(&mut state.world, system_meta, world, change_tick);
-        ExtractFromMainWorld(state.state.get(&world))
+    pub fn value(&mut self) -> SystemParamItem<'_, '_, P> {
+        self.state.0.get(&self.world)
     }
 }

crates/bevy_render/src/lib.rs

@@ -15,7 +15,8 @@ pub mod renderer;
 pub mod settings;
 pub mod texture;
 pub mod view;
-pub use extract_param::ExtractFromMainWorld;
+
+pub use extract_param::Extract;
 
 pub mod prelude {
     #[doc(hidden)]
@@ -312,7 +313,7 @@ fn extract(app_world: &mut World, render_app: &mut App) {
     // temporarily add the app world to the render world as a resource
     let scratch_world = app_world.remove_resource::<ScratchMainWorld>().unwrap();
     let inserted_world = std::mem::replace(app_world, scratch_world.0);
-    let running_world = &mut render_app.world;
+    let mut running_world = &mut render_app.world;
     running_world.insert_resource(MainWorld(inserted_world));
 
     extract.run(&mut running_world);
@@ -321,5 +322,5 @@ fn extract(app_world: &mut World, render_app: &mut App) {
     // move the app world back, as if nothing happened.
     let inserted_world = running_world.remove_resource::<MainWorld>().unwrap();
     let scratch_world = std::mem::replace(app_world, inserted_world.0);
-    inserted_world.insert_resource(ScratchMainWorld(scratch_world));
+    app_world.insert_resource(ScratchMainWorld(scratch_world));
 }