refactor(engine): remove support for multiple renderer contextsHEADmaster

1 files changed, 143 insertions, 192 deletions

diff --git a/engine/src/renderer/main_render_pass.rs b/engine/src/renderer/main_render_pass.rs
index ec490e4..1868f3d 100644
--- a/engine/src/renderer/main_render_pass.rs
+++ b/engine/src/renderer/main_render_pass.rs
@@ -1,8 +1,4 @@
-use std::any::type_name;
-
 use ecs::Query;
-use ecs::actions::Actions;
-use ecs::pair::{Pair, Wildcard};
 use ecs::query::term::{With, Without};
 use ecs::sole::Single;
 
@@ -13,8 +9,6 @@ use crate::renderer::object::{Id as RendererObjectId, Store as RendererObjectSto
 use crate::renderer::{
     BufferClearMask as RendererBufferClearMask,
     Command as RendererCommand,
-    CommandQueue as RendererCommandQueue,
-    CtxUsedByWindow as RendererCtxUsedByWindow,
     DrawMeshOptions as RendererDrawMeshOptions,
     DrawProperties as RendererDrawProperties,
     DrawPropertiesUpdateFlags as RendererDrawPropertiesUpdateFlags,
@@ -22,7 +16,7 @@ use crate::renderer::{
     PendingShaderBindings,
     RenderPass,
     RenderPasses as RendererRenderPasses,
-    SurfaceSpec as RendererSurfaceSpec,
+    SurfaceSpec,
 };
 use crate::shader::default::ASSET_LABEL as DEFAULT_SHADER_ASSET_LABEL;
 use crate::shader::{
@@ -42,18 +36,12 @@ type RenderableEntity<'a> = (
 
 #[tracing::instrument(skip_all)]
 pub fn add_main_render_passes(
-    renderer_ctx_query: Query<
-        (
-            &RendererObjectStore,
-            &[Pair<RendererCtxUsedByWindow, Wildcard>],
-        ),
-        (With<RendererCommandQueue>,),
-    >,
     renderable_query: Query<RenderableEntity<'_>, (Without<NoDraw>,)>,
+    window_surface_spec_query: Query<(&SurfaceSpec,), (With<Window>,)>,
     assets: Single<Assets>,
     shader_context: Single<ShaderContext>,
     mut render_passes: Single<RendererRenderPasses>,
-    mut actions: Actions,
+    mut object_store: Single<RendererObjectStore>,
 )
 {
     let Some(default_shader_asset) = assets
@@ -63,217 +51,180 @@ pub fn add_main_render_passes(
         return;
     };
 
-    for (renderer_ctx_ent_id, (object_store, used_by_windows)) in
-        renderer_ctx_query.iter_with_euids()
-    {
-        for ctx_used_by_window in used_by_windows {
-            let window_ent_id = ctx_used_by_window.id().target_entity();
+    for (surface_spec,) in &window_surface_spec_query {
+        let render_pass = render_passes.passes.push_front_mut(RenderPass {
+            surface_id: surface_spec.id,
+            commands: Vec::with_capacity(30),
+            draw_properties: RendererDrawProperties::default(),
+        });
 
-            let Some(window_ent) = ctx_used_by_window.get_target_ent() else {
-                tracing::error!("Window entity does not exist");
-                continue;
-            };
+        render_pass
+            .commands
+            .push(RendererCommand::MakeCurrent(surface_spec.id));
 
-            if window_ent.get::<Window>().is_none() {
-                tracing::debug!(
-                    window_entity_id=%window_ent_id,
-                    "Window entity does not have a {} component",
-                    type_name::<Window>()
-                );
+        let default_texture_asset = assets
+            .get_handle_to_loaded::<Texture>(TEXTURE_WHITE_1X1_ASSET_LABEL.clone())
+            .expect("Not possible");
 
-                actions.remove_components(
-                    renderer_ctx_ent_id,
-                    [Pair::builder()
-                        .relation::<RendererCtxUsedByWindow>()
-                        .target_id(window_ent_id)
-                        .build()
-                        .id()],
-                );
+        if !object_store.contains_maybe_pending_with_id(&RendererObjectId::Asset(
+            default_texture_asset.id(),
+        )) {
+            object_store
+                .insert_pending(RendererObjectId::Asset(default_texture_asset.id()));
 
-                continue;
-            };
+            render_pass
+                .commands
+                .push(RendererCommand::CreateTexture(default_texture_asset));
+        }
 
-            let Some(surface_spec) = window_ent.get::<RendererSurfaceSpec>() else {
-                tracing::debug!(
-                    window_entity_id=%window_ent_id,
-                    "Window entity does not have a {} component",
-                    type_name::<RendererSurfaceSpec>()
-                );
-                continue;
-            };
+        render_pass.commands.push(RendererCommand::ClearBuffers(
+            RendererBufferClearMask::COLOR | RendererBufferClearMask::DEPTH,
+        ));
 
-            render_passes.passes.push_front(RenderPass {
-                renderer_ctx_ent_id,
-                surface_id: surface_spec.id,
-                commands: Vec::with_capacity(30),
-                draw_properties: RendererDrawProperties::default(),
-            });
+        for (model, draw_flags, shader, mut pending_shader_bindings) in &renderable_query
+        {
+            let shader_asset = match &shader {
+                Some(shader) => &shader.asset_handle,
+                None => &default_shader_asset,
+            };
 
-            let render_pass = render_passes.passes.front_mut().expect("Not possible");
+            if pending_shader_bindings.as_ref().map_or_else(
+                || true,
+                |pending_shader_bindings| pending_shader_bindings.bindings.is_empty(),
+            ) {
+                continue;
+            }
 
-            render_pass
-                .commands
-                .push(RendererCommand::MakeCurrent(surface_spec.id));
+            let Some(model_spec) = assets.get(&model.spec_asset) else {
+                continue;
+            };
 
-            let default_texture_asset = assets
-                .get_handle_to_loaded::<Texture>(TEXTURE_WHITE_1X1_ASSET_LABEL.clone())
-                .expect("Not possible");
+            let Some(mesh_asset) = &model_spec.mesh_asset else {
+                continue;
+            };
 
-            if !object_store
-                .contains_with_id(&RendererObjectId::Asset(default_texture_asset.id()))
-            {
-                render_pass
-                    .commands
-                    .push(RendererCommand::CreateTexture(default_texture_asset));
+            if assets.get(mesh_asset).is_none() {
+                continue;
             }
 
-            render_pass.commands.push(RendererCommand::ClearBuffers(
-                RendererBufferClearMask::COLOR | RendererBufferClearMask::DEPTH,
-            ));
+            debug_assert!(model_spec.material_names.len() <= 1);
 
-            for (model, draw_flags, shader, mut pending_shader_bindings) in
-                &renderable_query
-            {
-                let shader_asset = match &shader {
-                    Some(shader) => &shader.asset_handle,
-                    None => &default_shader_asset,
-                };
-
-                if pending_shader_bindings.as_ref().map_or_else(
-                    || true,
-                    |pending_shader_bindings| pending_shader_bindings.bindings.is_empty(),
-                ) {
-                    continue;
+            let model_material_asset = match model_spec.find_first_material(&assets) {
+                MaterialSearchResult::Found(model_material_asset) => {
+                    model_material_asset.clone()
+                    // Some(model_material_asset.clone())
                 }
-
-                let Some(model_spec) = assets.get(&model.spec_asset) else {
+                MaterialSearchResult::NotFound | MaterialSearchResult::NoMaterials => {
+                    // MaterialSearchResult::NotFound => {
                     continue;
-                };
+                } // MaterialSearchResult::NoMaterials => None,
+            };
 
-                let Some(mesh_asset) = &model_spec.mesh_asset else {
+            if !object_store.contains_maybe_pending_with_id(&RendererObjectId::Asset(
+                shader_asset.id(),
+            )) {
+                let Some(shader_program) = shader_context.get_program(&shader_asset.id())
+                else {
+                    tracing::error!(
+                        "Shader context doesn't have a program for shader asset {:?}",
+                        assets.get_label(&shader_asset)
+                    );
                     continue;
                 };
 
-                if assets.get(mesh_asset).is_none() {
-                    continue;
-                }
+                object_store.insert_pending(RendererObjectId::Asset(shader_asset.id()));
+
+                render_pass
+                    .commands
+                    .push(RendererCommand::CreateShaderProgram(
+                        RendererObjectId::Asset(shader_asset.id()),
+                        shader_program.clone(),
+                    ));
+            }
 
-                debug_assert!(model_spec.material_names.len() <= 1);
+            render_pass.commands.push(RendererCommand::ActivateShader(
+                RendererObjectId::Asset(shader_asset.id()),
+            ));
 
-                let model_material_asset = match model_spec.find_first_material(&assets) {
-                    MaterialSearchResult::Found(model_material_asset) => {
-                        model_material_asset.clone()
-                        // Some(model_material_asset.clone())
-                    }
-                    MaterialSearchResult::NotFound
-                    | MaterialSearchResult::NoMaterials => {
-                        // MaterialSearchResult::NotFound => {
-                        continue;
-                    } // MaterialSearchResult::NoMaterials => None,
-                };
+            let Some(model_material) = assets.get(&model_material_asset) else {
+                // TODO: Handle this case since it may occur
+                unreachable!();
+            };
 
-                if !object_store
-                    .contains_with_id(&RendererObjectId::Asset(shader_asset.id()))
-                {
-                    let Some(shader_program) =
-                        shader_context.get_program(&shader_asset.id())
-                    else {
-                        tracing::error!(
-                            "Shader context doesn't have a program for shader asset {:?}",
-                            assets.get_label(&shader_asset)
-                        );
-                        continue;
-                    };
+            for texture_asset in [
+                &model_material.ambient_map,
+                &model_material.diffuse_map,
+                &model_material.specular_map,
+            ]
+            .into_iter()
+            .flatten()
+            {
+                if !object_store.contains_maybe_pending_with_id(&RendererObjectId::Asset(
+                    texture_asset.id(),
+                )) {
+                    object_store
+                        .insert_pending(RendererObjectId::Asset(texture_asset.id()));
 
                     render_pass
                         .commands
-                        .push(RendererCommand::CreateShaderProgram(
-                            RendererObjectId::Asset(shader_asset.id()),
-                            shader_program.clone(),
-                        ));
+                        .push(RendererCommand::CreateTexture(texture_asset.clone()));
                 }
+            }
 
-                render_pass.commands.push(RendererCommand::ActivateShader(
-                    RendererObjectId::Asset(shader_asset.id()),
-                ));
-
-                let Some(model_material) = assets.get(&model_material_asset) else {
-                    // TODO: Handle this case since it may occur
-                    unreachable!();
-                };
-
-                for texture_asset in [
-                    &model_material.ambient_map,
-                    &model_material.diffuse_map,
-                    &model_material.specular_map,
-                ]
-                .into_iter()
-                .flatten()
+            if let Some(pending_shader_bindings) = &mut pending_shader_bindings {
+                for (shader_binding_loc, shader_binding_val) in
+                    pending_shader_bindings.bindings.drain(..)
                 {
-                    if !object_store
-                        .contains_with_id(&RendererObjectId::Asset(texture_asset.id()))
-                    {
-                        render_pass
-                            .commands
-                            .push(RendererCommand::CreateTexture(texture_asset.clone()));
-                    }
+                    render_pass.commands.push(RendererCommand::SetShaderBinding(
+                        shader_binding_loc,
+                        shader_binding_val,
+                    ));
                 }
+            }
 
-                if let Some(pending_shader_bindings) = &mut pending_shader_bindings {
-                    for (shader_binding_loc, shader_binding_val) in
-                        pending_shader_bindings.bindings.drain(..)
-                    {
-                        render_pass.commands.push(RendererCommand::SetShaderBinding(
-                            shader_binding_loc,
-                            shader_binding_val,
-                        ));
-                    }
-                }
+            if let Some(draw_flags) = draw_flags.as_deref()
+                && draw_flags.polygon_mode_config != PolygonModeConfig::default()
+            {
+                render_pass
+                    .commands
+                    .push(RendererCommand::UpdateDrawProperties(
+                        RendererDrawProperties {
+                            polygon_mode_config: draw_flags.polygon_mode_config.clone(),
+                            ..Default::default()
+                        },
+                        RendererDrawPropertiesUpdateFlags::POLYGON_MODE_CONFIG,
+                    ));
+            }
 
-                if let Some(draw_flags) = draw_flags.as_deref()
-                    && draw_flags.polygon_mode_config != PolygonModeConfig::default()
-                {
-                    render_pass
-                        .commands
-                        .push(RendererCommand::UpdateDrawProperties(
-                            RendererDrawProperties {
-                                polygon_mode_config: draw_flags
-                                    .polygon_mode_config
-                                    .clone(),
-                                ..Default::default()
-                            },
-                            RendererDrawPropertiesUpdateFlags::POLYGON_MODE_CONFIG,
-                        ));
-                }
+            if !object_store
+                .contains_maybe_pending_with_id(&RendererObjectId::Asset(mesh_asset.id()))
+            {
+                object_store.insert_pending(RendererObjectId::Asset(mesh_asset.id()));
 
-                if !object_store
-                    .contains_with_id(&RendererObjectId::Asset(mesh_asset.id()))
-                {
-                    render_pass.commands.push(RendererCommand::CreateMesh {
-                        obj_id: RendererObjectId::Asset(mesh_asset.id()),
-                        mesh: None,
-                        usage: RendererMeshUsage::Static,
-                    });
-                }
+                render_pass.commands.push(RendererCommand::CreateMesh {
+                    obj_id: RendererObjectId::Asset(mesh_asset.id()),
+                    mesh: None,
+                    usage: RendererMeshUsage::Static,
+                });
+            }
 
-                render_pass.commands.push(RendererCommand::DrawMesh(
-                    RendererObjectId::Asset(mesh_asset.id()),
-                    RendererDrawMeshOptions::default(),
-                ));
+            render_pass.commands.push(RendererCommand::DrawMesh(
+                RendererObjectId::Asset(mesh_asset.id()),
+                RendererDrawMeshOptions::default(),
+            ));
 
-                if let Some(draw_flags) = draw_flags.as_deref()
-                    && draw_flags.polygon_mode_config != PolygonModeConfig::default()
-                {
-                    render_pass
-                        .commands
-                        .push(RendererCommand::UpdateDrawProperties(
-                            RendererDrawProperties {
-                                polygon_mode_config: PolygonModeConfig::default(),
-                                ..Default::default()
-                            },
-                            RendererDrawPropertiesUpdateFlags::POLYGON_MODE_CONFIG,
-                        ));
-                }
+            if let Some(draw_flags) = draw_flags.as_deref()
+                && draw_flags.polygon_mode_config != PolygonModeConfig::default()
+            {
+                render_pass
+                    .commands
+                    .push(RendererCommand::UpdateDrawProperties(
+                        RendererDrawProperties {
+                            polygon_mode_config: PolygonModeConfig::default(),
+                            ..Default::default()
+                        },
+                        RendererDrawPropertiesUpdateFlags::POLYGON_MODE_CONFIG,
+                    ));
             }
         }
     }