Rework docs to remove most of render from bevy_extract

Author: Zeophlite

crates/bevy_extract/src/extract_component.rs

@@ -14,9 +14,9 @@ use core::marker::PhantomData;
 
 pub use bevy_extract_macros::ExtractComponent;
 
-/// Describes how a component gets extracted for rendering.
+/// Describes how a component gets extracted for processing.
 ///
-/// Therefore the component is transferred from the "app world" into the "render
+/// Therefore the component is transferred from the "app world" into the "sub
 /// world" in the [`ExtractSchedule`] step. This functionality is enabled by
 /// adding [`ExtractComponentPlugin`] with the component type.
 ///
@@ -32,20 +32,20 @@ pub trait ExtractComponent<L: AppLabel, F = ()>: SyncComponent<L, F> {
     type QueryFilter: QueryFilter;
     /// The output from extraction, i.e. [`ExtractComponent::extract_component`].
     ///
-    /// The output components won't be removed automatically from the render world if the implementing component is removed,
+    /// The output components won't be removed automatically from the sub world if the implementing component is removed,
     /// unless you set them in the [`SyncComponent::Target`].
     type Out: Bundle<Effect: NoBundleEffect>;
     // TODO: https://github.com/rust-lang/rust/issues/29661
     // type Out: Bundle<Effect: NoBundleEffect> = Self;
 
-    /// Defines how the component is transferred into the "render world".
+    /// Defines how the component is transferred into the "sub world".
     ///
     /// Returning `None` based on the queried item will remove the [`SyncComponent::Target`] from the entity in
-    /// the render world.
+    /// the sub world.
     fn extract_component(item: QueryItem<'_, '_, Self::QueryData>) -> Option<Self::Out>;
 }
 
-/// This plugin extracts the components into the render world for synced
+/// This plugin extracts the components into the sub world for synced
 /// entities. To do so, it sets up the [`ExtractSchedule`] step for the
 /// specified [`ExtractComponent`].
 ///
@@ -87,11 +87,11 @@ impl<
     fn build(&self, app: &mut App) {
         app.add_plugins(SyncComponentPlugin::<L, C, F>::default());
 
-        if let Some(render_app) = app.get_sub_app_mut(L::default()) {
+        if let Some(sub_app) = app.get_sub_app_mut(L::default()) {
             if self.only_extract_visible {
-                render_app.add_systems(ExtractSchedule, extract_visible_components::<L, C, F>);
+                sub_app.add_systems(ExtractSchedule, extract_visible_components::<L, C, F>);
             } else {
-                render_app.add_systems(ExtractSchedule, extract_components::<L, C, F>);
+                sub_app.add_systems(ExtractSchedule, extract_components::<L, C, F>);
             }
         }
     }

crates/bevy_extract/src/extract_param.rs

@@ -23,8 +23,8 @@ use core::ops::{Deref, DerefMut};
 /// ## Context
 ///
 /// [`ExtractSchedule`] is used to extract (move) data from the simulation world ([`MainWorld`]) to the
-/// render world. The render world drives rendering each frame (generally to a `Window`).
-/// This design is used to allow performing calculations related to rendering a prior frame at the same
+/// sub world. The sub world drives processing each frame (generally to a `Window`).
+/// This design is used to allow performing calculations related to processing a prior frame at the same
 /// time as the next frame is simulated, which increases throughput (FPS).
 ///
 /// [`Extract`] is used to get data from the main world during [`ExtractSchedule`].

crates/bevy_extract/src/extract_plugin.rs

@@ -18,7 +18,7 @@ use bevy_utils::default;
 pub struct ExtractPlugin<L: AppLabel + Default> {
     /// Function that gets run at the beginning of each extraction.
     ///
-    /// Gets the main world and render world as arguments (in that order).
+    /// Gets the main world and sub world as arguments (in that order).
     pub pre_extract: fn(&mut World, &mut World),
 
     marker: PhantomData<L>,
@@ -54,68 +54,68 @@ impl<L: AppLabel + Default + Copy + Eq> Plugin for ExtractPlugin<L> {
         app.add_plugins(SyncWorldPlugin::<L>::default());
         app.init_resource::<ScratchMainWorld>();
 
-        let mut render_app = SubApp::new();
+        let mut sub_app = SubApp::new();
 
         let mut extract_schedule = Schedule::new(ExtractSchedule);
         // We skip applying any commands during the ExtractSchedule
-        // so commands can be applied on the render thread.
+        // so commands can be applied on the sub thread.
         extract_schedule.set_build_settings(ScheduleBuildSettings {
             auto_insert_apply_deferred: false,
             ..default()
         });
         extract_schedule.set_apply_final_deferred(false);
 
-        render_app
+        sub_app
             .add_schedule((self.base_schedule)())
             .add_schedule(extract_schedule)
             .allow_ambiguous_resource::<MainWorld>()
             .add_systems(
                 self.schedule_label,
                 (
-                    // This set applies the commands from the extract schedule while the render schedule
+                    // This set applies the commands from the extract schedule while the sub schedule
                     // is running in parallel with the main app.
                     apply_extract_commands.in_set(self.extract_set),
                     despawn_temporary_entities::<L>.in_set(self.despawn_set),
                 ),
             );
 
         let pre_extract = self.pre_extract;
-        render_app.set_extract(move |main_world, render_world| {
-            pre_extract(main_world, render_world);
+        sub_app.set_extract(move |main_world, sub_world| {
+            pre_extract(main_world, sub_world);
 
             {
                 #[cfg(feature = "trace")]
                 let _stage_span = bevy_log::info_span!("entity_sync").entered();
-                entity_sync_system::<L>(main_world, render_world);
+                entity_sync_system::<L>(main_world, sub_world);
             }
 
             // run extract schedule
-            extract(main_world, render_world);
+            extract(main_world, sub_world);
         });
 
-        app.insert_sub_app(L::default(), render_app);
+        app.insert_sub_app(L::default(), sub_app);
     }
 }
 
-/// Schedule in which data from the main world is 'extracted' into the render world.
+/// Schedule in which data from the main world is 'extracted' into the sub world.
 ///
 /// This step should be kept as short as possible to increase the "pipelining potential" for
-/// running the next frame while rendering the current frame.
+/// running the next frame while processing the current frame.
 ///
-/// This schedule is run on the render world, but it also has access to the main world.
+/// This schedule is run on the sub world, but it also has access to the main world.
 /// See [`MainWorld`] and [`Extract`](crate::Extract) for details on how to access main world data from this schedule.
 #[derive(ScheduleLabel, PartialEq, Eq, Debug, Clone, Hash, Default)]
 pub struct ExtractSchedule;
 
 /// Applies the commands from the extract schedule. This happens during
-/// the render schedule rather than during extraction to allow the commands to run in parallel with the
-/// main app when pipelined rendering is enabled.
-fn apply_extract_commands(render_world: &mut World) {
-    render_world.resource_scope(|render_world, mut schedules: Mut<Schedules>| {
+/// the sub schedule rather than during extraction to allow the commands to run in parallel with the
+/// main app when pipelined processing is enabled.
+fn apply_extract_commands(sub_world: &mut World) {
+    sub_world.resource_scope(|sub_world, mut schedules: Mut<Schedules>| {
         schedules
             .get_mut(ExtractSchedule)
             .unwrap()
-            .apply_deferred(render_world);
+            .apply_deferred(sub_world);
     });
 }
 /// The simulation [`World`] of the application, stored as a resource.
@@ -131,17 +131,17 @@ pub struct MainWorld(World);
 #[derive(Resource, Default)]
 struct ScratchMainWorld(World);
 
-/// Executes the [`ExtractSchedule`] step of the renderer.
-/// This updates the render world with the extracted ECS data of the current frame.
-pub fn extract(main_world: &mut World, render_world: &mut World) {
-    // temporarily add the app world to the render world as a resource
+/// Executes the [`ExtractSchedule`] step of the processor.
+/// This updates the sub world with the extracted ECS data of the current frame.
+pub fn extract(main_world: &mut World, sub_world: &mut World) {
+    // temporarily add the app world to the sub world as a resource
     let scratch_world = main_world.remove_resource::<ScratchMainWorld>().unwrap();
     let inserted_world = core::mem::replace(main_world, scratch_world.0);
-    render_world.insert_resource(MainWorld(inserted_world));
-    render_world.run_schedule(ExtractSchedule);
+    sub_world.insert_resource(MainWorld(inserted_world));
+    sub_world.run_schedule(ExtractSchedule);
 
     // move the app world back, as if nothing happened.
-    let inserted_world = render_world.remove_resource::<MainWorld>().unwrap();
+    let inserted_world = sub_world.remove_resource::<MainWorld>().unwrap();
     let scratch_world = core::mem::replace(main_world, inserted_world.0);
     main_world.insert_resource(ScratchMainWorld(scratch_world));
 }
@@ -172,7 +172,7 @@ mod test {
     pub struct MySchedule;
 
     impl MySchedule {
-        /// Sets up the base structure of the rendering [`Schedule`].
+        /// Sets up the base structure of the processing [`Schedule`].
         ///
         /// The sets defined in this enum are configured to run in order.
         pub fn base_schedule() -> Schedule {
@@ -232,13 +232,13 @@ mod test {
             commands.spawn((RenderComponent, RenderComponentSeparate));
         });
 
-        let render_app = app.get_sub_app_mut(ExtractApp).unwrap();
+        let sub_app = app.get_sub_app_mut(ExtractApp).unwrap();
 
         // Normally RenderPlugin sets the RenderRecovery schedule as update, but for
         // testing we just use the Render schedule directly.
-        render_app.update_schedule = Some(MySchedule.intern());
+        sub_app.update_schedule = Some(MySchedule.intern());
 
-        render_app.world_mut().add_observer(
+        sub_app.world_mut().add_observer(
             |event: On<Add, (RenderComponent, RenderComponentExtra)>, mut commands: Commands| {
                 // Simulate data that's not extracted
                 commands
@@ -251,8 +251,8 @@ mod test {
 
         // Check that all components have been extracted
         {
-            let render_app = app.get_sub_app_mut(ExtractApp).unwrap();
-            render_app
+            let sub_app = app.get_sub_app_mut(ExtractApp).unwrap();
+            sub_app
                 .world_mut()
                 .run_system_cached(
                     |entity: Single<(
@@ -286,8 +286,8 @@ mod test {
 
         // Check that the extracted components have been removed
         {
-            let render_app = app.get_sub_app_mut(ExtractApp).unwrap();
-            render_app
+            let sub_app = app.get_sub_app_mut(ExtractApp).unwrap();
+            sub_app
                 .world_mut()
                 .run_system_cached(
                     |entity: Single<(

crates/bevy_extract/src/extract_resource.rs

@@ -7,9 +7,9 @@ use bevy_utils::once;
 
 use crate::{Extract, ExtractSchedule};
 
-/// Describes how a resource gets extracted for rendering.
+/// Describes how a resource gets extracted for processing.
 ///
-/// Therefore the resource is transferred from the "main world" into the "render world"
+/// Therefore the resource is transferred from the "main world" into the "sub world"
 /// in the [`ExtractSchedule`] step.
 ///
 /// The marker type `F` is only used as a way to bypass the orphan rules. To
@@ -18,11 +18,11 @@ use crate::{Extract, ExtractSchedule};
 pub trait ExtractResource<L: AppLabel, F = ()>: Resource {
     type Source: Resource;
 
-    /// Defines how the resource is transferred into the "render world".
+    /// Defines how the resource is transferred into the "sub world".
     fn extract_resource(source: &Self::Source) -> Self;
 }
 
-/// This plugin extracts the resources into the "render world".
+/// This plugin extracts the resources into the "sub world".
 ///
 /// Therefore it sets up the[`ExtractSchedule`] step
 /// for the specified [`Resource`].
@@ -47,11 +47,11 @@ impl<
     > Plugin for ExtractResourcePlugin<L, R, F>
 {
     fn build(&self, app: &mut App) {
-        if let Some(render_app) = app.get_sub_app_mut(L::default()) {
-            render_app.add_systems(ExtractSchedule, extract_resource::<L, R, F>);
+        if let Some(sub_app) = app.get_sub_app_mut(L::default()) {
+            sub_app.add_systems(ExtractSchedule, extract_resource::<L, R, F>);
         } else {
             once!(bevy_log::error!(
-                "Render app did not exist when trying to add `extract_resource` for <{}>.",
+                "Sub app did not exist when trying to add `extract_resource` for <{}>.",
                 core::any::type_name::<R>()
             ));
         }
@@ -73,7 +73,7 @@ pub fn extract_resource<L: AppLabel, R: ExtractResource<L, F, Mutability = Mutab
             #[cfg(debug_assertions)]
             if !main_resource.is_added() {
                 once!(bevy_log::warn!(
-                    "Removing resource {} from render world not expected, adding using `Commands`.
+                    "Removing resource {} from sub world not expected, adding using `Commands`.
                 This may decrease performance",
                     core::any::type_name::<R>()
                 ));

crates/bevy_extract/src/sync_component.rs

@@ -11,7 +11,7 @@ use bevy_ecs::{
 
 use crate::sync_world::{EntityRecord, PendingSyncEntity, SyncToSubWorld};
 
-/// Plugin that registers a component for automatic sync to the render world. See [`SyncWorldPlugin`] for more information.
+/// Plugin that registers a component for automatic sync to the sub world. See [`SyncWorldPlugin`] for more information.
 ///
 /// This plugin is automatically added by [`ExtractComponentPlugin`], and only needs to be added for manual extraction implementations.
 ///
@@ -22,7 +22,7 @@ use crate::sync_world::{EntityRecord, PendingSyncEntity, SyncToSubWorld};
 /// # Implementation details
 ///
 /// It adds [`SyncToSubWorld`] 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.
+/// handles cleanup of the component in the sub world when it is removed from an entity.
 ///
 /// [`ExtractComponentPlugin`]: crate::extract_component::ExtractComponentPlugin
 /// [`SyncWorldPlugin`]: crate::sync_world::SyncWorldPlugin
@@ -35,15 +35,15 @@ impl<L: AppLabel, C: SyncComponent<L, F>, F> Default for SyncComponentPlugin<L,
 }
 
 /// Trait that links components from the main world with output components in
-/// the render world. It is used by [`SyncComponentPlugin`].
+/// the sub world. It is used by [`SyncComponentPlugin`].
 ///
 /// 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<L: AppLabel, F = ()>: Component {
-    /// Describes what components should be removed from the render world if the
+    /// Describes what components should be removed from the sub world if the
     /// implementing component is removed.
     type Target: Bundle<Effect: NoBundleEffect>;
     // TODO: https://github.com/rust-lang/rust/issues/29661

crates/bevy_extract/src/sync_world.rs

@@ -16,7 +16,7 @@ use bevy_ecs::{
 use bevy_platform::collections::{HashMap, HashSet};
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 
-/// A plugin that synchronizes entities with [`SyncToSubWorld`] between the main world and the render world.
+/// A plugin that synchronizes entities with [`SyncToSubWorld`] between the main world and the sub world.
 ///
 /// All entities with the [`SyncToSubWorld`] component are kept in sync. It
 /// is automatically added as a required component by [`ExtractComponentPlugin`]
@@ -30,25 +30,25 @@ use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 /// This is called "Pipelined Rendering", see [`PipelinedRenderingPlugin`] for more information.
 ///
 /// [`SyncWorldPlugin`] is the first thing that runs every frame and it maintains an entity-to-entity mapping
-/// between the main world and the render world.
-/// It does so by spawning and despawning entities in the render world, to match spawned and despawned entities in the main world.
+/// between the main world and the sub world.
+/// It does so by spawning and despawning entities in the sub world, to match spawned and despawned entities in the main world.
 /// The link between synced entities is maintained by the [`SubEntity`] and [`MainEntity`] components.
 ///
-/// The [`SubEntity`] contains the corresponding render world entity of a main world entity, while [`MainEntity`] contains
-/// the corresponding main world entity of a render world entity.
+/// The [`SubEntity`] contains the corresponding sub world entity of a main world entity, while [`MainEntity`] contains
+/// the corresponding main world entity of a sub world entity.
 /// For convenience, [`QueryData`](bevy_ecs::query::QueryData) implementations are provided for both components:
 /// adding [`MainEntity`] to a query (without a `&`) will return the corresponding main world [`Entity`],
-/// and adding [`SubEntity`] will return the corresponding render world [`Entity`].
+/// and adding [`SubEntity`] will return the corresponding sub world [`Entity`].
 /// If you have access to the component itself, the underlying entities can be accessed by calling `.id()`.
 ///
 /// Synchronization is necessary preparation for extraction ([`ExtractSchedule`](crate::ExtractSchedule)), which copies over component data from the main
-/// to the render world for these entities.
+/// to the sub world for these entities.
 ///
 /// ```text
 /// |--------------------------------------------------------------------|
 /// |      |         |          Main world update                        |
 /// | sync | extract |---------------------------------------------------|
-/// |      |         |         Render world update                       |
+/// |      |         |         Sub world update                       |
 /// |--------------------------------------------------------------------|
 /// ```
 ///
@@ -62,7 +62,7 @@ use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 /// | ID: 18v1 | PointLight | SubEntity(ID: 5V1) | SyncToSubWorld |
 /// |-------------------------------------------------------------------|
 ///
-/// |----------Render World-----------|
+/// |----------Sub world-----------|
 /// |  Entity  |       Component      |
 /// |---------------------------------|
 /// | ID: 3v1  | MainEntity(ID: 1V1)  |
@@ -71,15 +71,15 @@ use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 ///
 /// ```
 ///
-/// Note that this effectively establishes a link between the main world entity and the render world entity.
+/// Note that this effectively establishes a link between the main world entity and the sub world entity.
 /// Not every entity needs to be synchronized, however; only entities with the [`SyncToSubWorld`] component are synced.
 /// Adding [`SyncToSubWorld`] to a main world component will establish such a link.
-/// Once a synchronized main entity is despawned, its corresponding render entity will be automatically
+/// Once a synchronized main entity is despawned, its corresponding sub entity will be automatically
 /// despawned in the next `sync`.
 ///
 /// The sync step does not copy any of component data between worlds, since its often not necessary to transfer over all
 /// the components of a main world entity.
-/// The render world probably cares about a `Position` component, but not a `Velocity` component.
+/// The sub world probably cares about a `Position` component, but not a `Velocity` component.
 /// The extraction happens in its own step, independently from, and after synchronization.
 ///
 /// Moreover, [`SyncWorldPlugin`] only synchronizes *entities*. [`RenderAsset`]s like meshes and textures are handled