refactor(engine): remove support for multiple renderer contextsHEADmaster

1 files changed, 34 insertions, 139 deletions

diff --git a/engine/src/renderer.rs b/engine/src/renderer.rs
index 14b8d49..fd48792 100644
--- a/engine/src/renderer.rs
+++ b/engine/src/renderer.rs
@@ -1,16 +1,17 @@
-use std::any::type_name;
 use std::collections::VecDeque;
 use std::sync::atomic::{AtomicU64, Ordering};
 
 use bitflags::bitflags;
 use ecs::actions::Actions;
-use ecs::entity::obtainer::Obtainer as EntityObtainer;
+use ecs::component::local::Local;
 use ecs::event::component::{Changed, Removed};
-use ecs::pair::{ChildOf, Pair, Wildcard};
+use ecs::pair::{ChildOf, Pair};
 use ecs::phase::{POST_UPDATE as POST_UPDATE_PHASE, Phase};
+use ecs::query::term::With;
 use ecs::sole::Single;
+use ecs::system::Into;
+use ecs::system::initializable::Initializable;
 use ecs::system::observer::Observe;
-use ecs::uid::Uid;
 use ecs::{Component, Query, Sole, declare_entity};
 
 use crate::asset::Handle as AssetHandle;
@@ -19,7 +20,7 @@ use crate::data_types::dimens::Dimens;
 use crate::draw_flags::PolygonModeConfig;
 use crate::mesh::Mesh;
 use crate::renderer::blending::Config as BlendingConfig;
-use crate::renderer::object::Id as ObjectId;
+use crate::renderer::object::{Id as ObjectId, Store as ObjectStore};
 use crate::shader::Program as ShaderProgram;
 use crate::shader::cursor::{
     BindingLocation as ShaderBindingLocation,
@@ -90,12 +91,19 @@ impl ecs::extension::Extension for Extension
         collector.add_declared_entity(&POST_RENDER_PHASE);
 
         let _ = collector.add_sole(RenderPasses::default());
+        let _ = collector.add_sole(CommandQueue::default());
+        let _ = collector.add_sole(ObjectStore::default());
 
         let _ = collector.add_sole(self.graphics_props);
 
         collector.add_system(*PRE_RENDER_PHASE, main_render_pass::add_main_render_passes);
 
-        collector.add_system(*RENDER_PHASE, enqueue_commands_from_render_passes);
+        collector.add_system(
+            *RENDER_PHASE,
+            enqueue_commands_from_render_passes
+                .into_system()
+                .initialize((ActiveDrawProperties::default(),)),
+        );
 
         collector.add_observer(handle_window_changed);
         collector.add_observer(handle_window_removed);
@@ -204,7 +212,6 @@ pub struct RenderPasses
 #[derive(Debug)]
 pub struct RenderPass
 {
-    pub renderer_ctx_ent_id: Uid,
     pub surface_id: SurfaceId,
     pub commands: Vec<Command>,
     pub draw_properties: DrawProperties,
@@ -366,16 +373,10 @@ bitflags! {
     }
 }
 
-#[derive(Debug, Default, Clone, Component)]
-pub struct ActiveDrawProperties
-{
-    pub draw_properties: DrawProperties,
-}
-
 /// Renderer command FIFO queue.
 ///
 /// This component is present in renderer context entities.
-#[derive(Debug, Component)]
+#[derive(Debug, Sole)]
 pub struct CommandQueue
 {
     queue: VecDeque<Command>,
@@ -402,53 +403,19 @@ impl Default for CommandQueue
     }
 }
 
-#[derive(Debug, Component)]
-pub struct WindowUsingRendererCtx;
-
-#[derive(Debug, Component)]
-pub struct CtxUsedByWindow;
-
 #[tracing::instrument(skip_all)]
 pub fn enqueue_commands_from_render_passes(
-    renderer_ctx_query: Query<(
-        &mut CommandQueue,
-        &[Pair<CtxUsedByWindow, Wildcard>],
-        &mut ActiveDrawProperties,
-    )>,
+    window_surface_spec_query: Query<(&SurfaceSpec,), (With<Window>,)>,
+    mut command_queue: Single<CommandQueue>,
     mut render_passes: Single<RenderPasses>,
-    entity_obtainer: EntityObtainer,
+    mut active_draw_props: Local<ActiveDrawProperties>,
 )
 {
-    let Some((_, _, mut active_draw_props)) = renderer_ctx_query.iter().next() else {
-        return;
-    };
-
     let mut last_render_pass_draw_props = active_draw_props.draw_properties.clone();
 
     for render_pass in render_passes.passes.drain(..) {
-        let Some(renderer_ctx_ent) =
-            entity_obtainer.get_entity(render_pass.renderer_ctx_ent_id)
-        else {
-            tracing::error!(
-                renderer_ctx_entity_id=%render_pass.renderer_ctx_ent_id,
-                "Renderer context entity does not exist"
-            );
-
-            continue;
-        };
-
-        let Some(mut renderer_ctx_command_queue) =
-            renderer_ctx_ent.get_mut::<CommandQueue>()
-        else {
-            tracing::error!(
-                renderer_ctx_entity_id=%render_pass.renderer_ctx_ent_id,
-                "Renderer context entity does not have a command queue component"
-            );
-            continue;
-        };
-
         if render_pass.draw_properties != last_render_pass_draw_props {
-            renderer_ctx_command_queue.push(Command::UpdateDrawProperties(
+            command_queue.push(Command::UpdateDrawProperties(
                 render_pass.draw_properties.clone(),
                 DrawPropertiesUpdateFlags::all(),
             ));
@@ -465,9 +432,7 @@ pub fn enqueue_commands_from_render_passes(
             })
             .last();
 
-        renderer_ctx_command_queue
-            .queue
-            .extend(render_pass.commands);
+        command_queue.queue.extend(render_pass.commands);
 
         if let Some(last_updated_draw_props) = last_updated_draw_props {
             last_render_pass_draw_props = last_updated_draw_props;
@@ -476,35 +441,15 @@ pub fn enqueue_commands_from_render_passes(
 
     active_draw_props.draw_properties = last_render_pass_draw_props;
 
-    drop(active_draw_props);
-
-    for (mut command_queue, used_by_windows, _) in &renderer_ctx_query {
-        for ctx_used_by_window in used_by_windows {
-            let window_ent_id = ctx_used_by_window.id().target_entity();
-
-            let Some(window_ent) = ctx_used_by_window.get_target_ent() else {
-                tracing::error!("Window entity does not exist");
-                continue;
-            };
-
-            let Some(surface_spec) = window_ent.get::<SurfaceSpec>() else {
-                tracing::debug!(
-                    window_entity_id=%window_ent_id,
-                    "Window entity does not have a {} component",
-                    type_name::<SurfaceSpec>()
-                );
-                continue;
-            };
-
-            command_queue.push(Command::SwapBuffers(surface_spec.id));
-        }
+    for (window_surface_spec,) in &window_surface_spec_query {
+        command_queue.push(Command::SwapBuffers(window_surface_spec.id));
     }
 }
 
 #[tracing::instrument(skip_all)]
 fn handle_window_changed(
     observe: Observe<Pair<Changed, Window>>,
-    entity_obtainer: EntityObtainer,
+    mut command_queue: Single<CommandQueue>,
 )
 {
     for evt_match in &observe {
@@ -514,34 +459,6 @@ fn handle_window_changed(
             continue;
         };
 
-        let Some(renderer_ctx_ent_id) = window_ent
-            .get_matching_components(
-                Pair::builder()
-                    .relation::<WindowUsingRendererCtx>()
-                    .target_id(Wildcard::uid())
-                    .build()
-                    .id(),
-            )
-            .next()
-            .map(|comp_ref| comp_ref.id().target_entity())
-        else {
-            continue;
-        };
-
-        let Some(renderer_ctx_ent) = entity_obtainer.get_entity(renderer_ctx_ent_id)
-        else {
-            tracing::error!("Renderer context entity does not exist");
-            continue;
-        };
-
-        let Some(mut command_queue) = renderer_ctx_ent.get_mut::<CommandQueue>() else {
-            tracing::error!(
-                "Renderer context entity does not have a {} component",
-                type_name::<CommandQueue>()
-            );
-            continue;
-        };
-
         command_queue.queue.push_front(Command::SetViewport {
             position: Vec2 { x: 0, y: 0 },
             size: *evt_match.get_changed_comp().inner_size(),
@@ -554,7 +471,11 @@ fn handle_window_changed(
 }
 
 #[tracing::instrument(skip_all)]
-fn handle_window_removed(observe: Observe<Pair<Removed, Window>>, mut actions: Actions)
+fn handle_window_removed(
+    observe: Observe<Pair<Removed, Window>>,
+    mut command_queue: Single<CommandQueue>,
+    mut actions: Actions,
+)
 {
     for evt_match in &observe {
         let window_ent_id = evt_match.id();
@@ -573,41 +494,9 @@ fn handle_window_removed(observe: Observe<Pair<Removed, Window>>, mut actions: A
 
         actions.remove_comps::<(SurfaceSpec,)>(window_ent_id);
 
-        let Some(with_renderer_ctx_pair) = window_ent
-            .get_first_wildcard_pair_match::<WindowUsingRendererCtx, Wildcard>()
-        else {
-            tracing::warn!(
-                "Window entity is missing a ({}, *) pair",
-                type_name::<WindowUsingRendererCtx>()
-            );
-            continue;
-        };
-
-        let Some(renderer_context_ent) = with_renderer_ctx_pair.get_target_ent() else {
-            continue;
-        };
-
-        let Some(mut command_queue) = renderer_context_ent.get_mut::<CommandQueue>()
-        else {
-            continue;
-        };
-
         command_queue
             .queue
             .push_front(Command::RemoveSurface(window_surface_spec.id));
-
-        let renderer_context_ent_id = with_renderer_ctx_pair.id().target_entity();
-
-        actions.remove_components(
-            renderer_context_ent_id,
-            [Pair::builder()
-                .relation::<CtxUsedByWindow>()
-                .target_id(window_ent_id)
-                .build()
-                .id()],
-        );
-
-        actions.remove_components(window_ent_id, [with_renderer_ctx_pair.id()]);
     }
 }
 
@@ -632,3 +521,9 @@ impl<'a> Extend<(ShaderCursor<'a>, ShaderBindingValue)> for PendingShaderBinding
         ))
     }
 }
+
+#[derive(Debug, Default, Clone, Component)]
+struct ActiveDrawProperties
+{
+    pub draw_properties: DrawProperties,
+}