From c0898600fd5f0db11b02056fa3dc14414aee47e5 Mon Sep 17 00:00:00 2001
From: HampusM <hampus@hampusmat.com>
Date: Thu, 5 Nov 2026 12:09:21 +0100
Subject: refactor(engine): make dear imgui init create shader program itself

---
 engine/src/ui/dear_imgui.rs | 145 +++++++++++++++++++++-----------------------
 1 file changed, 69 insertions(+), 76 deletions(-)

(limited to 'engine/src')

diff --git a/engine/src/ui/dear_imgui.rs b/engine/src/ui/dear_imgui.rs
index 7822c2f..b8a2b35 100644
--- a/engine/src/ui/dear_imgui.rs
+++ b/engine/src/ui/dear_imgui.rs
@@ -1,7 +1,6 @@
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicU64, Ordering};
-use std::sync::LazyLock;
 
 use dear_imgui_rs::{
     DrawCmd as ImguiDrawCmd,
@@ -21,7 +20,6 @@ use ecs::time::Time;
 use ecs::{Component, Query, Sole};
 use intmap::IntMap;
 
-use crate::asset::{Assets, Handle as AssetHandle, Label as AssetLabel};
 use crate::data_types::dimens::Dimens;
 use crate::input::keyboard::{Key, Keyboard};
 use crate::input::mouse::{Button as MouseButton, Buttons as MouseButtons, Mouse};
@@ -42,7 +40,7 @@ use crate::rendering::blending::{
     Equation as RenderingBlendingEquation,
     Factor as RenderingBlendingFactor,
 };
-use crate::rendering::object::Id as RenderingObjectId;
+use crate::rendering::object::{Id as RenderingObjectId, Store as RenderingObjectStore};
 use crate::rendering::shader::cursor::{
     BindingTextureKind as ShaderBindingTextureKind,
     BindingValue as ShaderBindingValue,
@@ -52,6 +50,7 @@ use crate::rendering::shader::{
     Context as ShaderContext,
     EntrypointFlags as ShaderEntrypointFlags,
     ModuleSource as ShaderModuleSource,
+    Program as ShaderProgram,
 };
 use crate::rendering::{
     AssetOrValue,
@@ -84,11 +83,6 @@ mod reexports
 
 pub use reexports::*;
 
-pub static SHADER_ASSET_LABEL: LazyLock<AssetLabel> = LazyLock::new(|| AssetLabel {
-    path: Path::new("").into(),
-    name: Some("imgui_shader".into()),
-});
-
 /// Dear Imgui context
 #[derive(Sole)]
 pub struct Context
@@ -241,9 +235,9 @@ fn update(
     target_window_query: Query<(&Window, &Surface, With<TargetWindow>)>,
     mut context: Single<Context>,
     time: Single<Time>,
-    mut assets: Single<Assets>,
     mut render_passes: Single<RenderPasses>,
     shader_context: Single<ShaderContext>,
+    mut rendering_object_store: Single<RenderingObjectStore>,
     rendering_backend_properties: Single<RenderingBackendProperties>,
     keyboard: Single<Keyboard>,
     mouse: Single<Mouse>,
@@ -255,9 +249,9 @@ fn update(
         unreachable!();
     };
 
-    let assets = assets.get_mut()?;
     let render_passes = render_passes.get_mut()?;
     let shader_context = shader_context.get()?;
+    let rendering_object_store = rendering_object_store.get_mut()?;
     let keyboard = keyboard.get()?;
     let mouse = mouse.get()?;
     let mouse_buttons = mouse_buttons.get()?;
@@ -274,25 +268,23 @@ fn update(
 
     match curr_state {
         State::NotInitialized => {
-            let Some((shader_asset, mesh_obj_id, mesh)) = initialize_context(
+            let resources = initialize_context(
                 context,
                 &window,
                 window_surface.id,
-                assets,
                 render_passes,
                 shader_context,
-            ) else {
-                *state = State::NotInitialized;
-                return Ok(());
-            };
+                rendering_object_store,
+                rendering_backend_properties,
+            )?;
 
             context.ctx.new_frame();
 
-            *state = State::Ready { shader_asset, mesh_obj_id, mesh };
+            *state = State::Ready { resources };
         }
-        State::Ready { shader_asset, mesh_obj_id, mut mesh } => {
+        State::Ready { mut resources } => {
             if !context.enabled {
-                *state = State::Ready { shader_asset, mesh_obj_id, mesh };
+                *state = State::Ready { resources };
                 return Ok(());
             }
 
@@ -306,17 +298,14 @@ fn update(
             add_drawing_render_pass(
                 context,
                 render_passes,
-                shader_context,
                 rendering_backend_properties,
                 window_surface.id,
-                shader_asset.clone(),
-                mesh_obj_id,
-                &mut mesh,
+                &mut resources,
             )?;
 
             context.ctx.new_frame();
 
-            *state = State::Ready { shader_asset, mesh_obj_id, mesh };
+            *state = State::Ready { resources };
         }
         State::Unreachable => unreachable!(),
     }
@@ -334,41 +323,50 @@ enum State
     NotInitialized,
     Ready
     {
-        shader_asset: AssetHandle<ShaderModuleSource>,
-        mesh_obj_id: RenderingObjectId,
-        mesh: Mesh,
+        resources: InitializedResources,
     },
     Unreachable,
 }
 
+#[derive(Debug)]
+struct InitializedResources
+{
+    shader_obj_id: RenderingObjectId,
+    shader: ShaderProgram,
+    mesh_obj_id: RenderingObjectId,
+    mesh: Mesh,
+}
+
 fn initialize_context(
     context: &mut Context,
     window: &Window,
     window_surface_id: SurfaceId,
-    assets: &mut Assets,
     render_passes: &mut RenderPasses,
     shader_context: &ShaderContext,
-) -> Option<(AssetHandle<ShaderModuleSource>, RenderingObjectId, Mesh)>
+    rendering_object_store: &mut RenderingObjectStore,
+    rendering_backend_properties: &RenderingBackendProperties,
+) -> Result<InitializedResources, crate::Error>
 {
-    let Some(shader_asset) =
-        assets.get_handle_to_loaded::<ShaderModuleSource>(SHADER_ASSET_LABEL.clone())
-    else {
-        assets.store_with_label(
-            SHADER_ASSET_LABEL.clone(),
-            ShaderModuleSource {
-                name: "imgui_shader.slang".into(),
-                file_path: Path::new("@engine/imgui_shader").into(),
-                source: include_str!("../../res/imgui_shader.slang").into(),
-                link_entry_points: ShaderEntrypointFlags::VERTEX
-                    | ShaderEntrypointFlags::FRAGMENT,
-            },
-        );
-
-        // We want to wait with initializing until the shader have been processed by the
-        // shader context
-        return None;
+    let shader_module_source = ShaderModuleSource {
+        name: "imgui_shader.slang".into(),
+        file_path: Path::new("@engine/imgui_shader").into(),
+        source: include_str!("../../res/imgui_shader.slang").into(),
+        link_entry_points: ShaderEntrypointFlags::VERTEX
+            | ShaderEntrypointFlags::FRAGMENT,
     };
 
+    let shader_obj_id = RenderingObjectId::new_sequential();
+
+    let shader = shader_context
+        .compose_program(
+            &[shader_context.load_module(&shader_module_source)?],
+            shader_module_source.link_entry_points,
+            rendering_backend_properties.shader_target_id,
+        )?
+        .into_linked()?;
+
+    rendering_object_store.insert_pending(shader_obj_id);
+
     #[allow(clippy::cast_possible_truncation)]
     let hidpi_factor = window.scale_factor().round() as f32;
 
@@ -392,6 +390,8 @@ fn initialize_context(
 
     let mesh_obj_id = RenderingObjectId::new_sequential();
 
+    rendering_object_store.insert_pending(mesh_obj_id);
+
     let mesh = Mesh::builder()
         .vertices(MeshVertexBuffer::with_capacity(
             &[
@@ -416,14 +416,8 @@ fn initialize_context(
     render_passes.passes.push_back(RenderPass {
         commands: vec![
             RenderingCommand::MakeCurrent(window_surface_id),
-            RenderingCommand::CreateShaderProgram(
-                RenderingObjectId::Asset(shader_asset.id()),
-                shader_context
-                    .get_program(&shader_asset.id())
-                    .expect("Not possible")
-                    .clone(),
-            ),
-            RenderingCommand::ActivateShader(RenderingObjectId::Asset(shader_asset.id())),
+            RenderingCommand::CreateShaderProgram(shader_obj_id, shader.clone()),
+            RenderingCommand::ActivateShader(shader_obj_id),
             RenderingCommand::CreateMesh {
                 obj_id: mesh_obj_id,
                 mesh: AssetOrValue::Value(mesh.clone()),
@@ -433,7 +427,12 @@ fn initialize_context(
         draw_properties: DrawProperties::default(),
     });
 
-    Some((shader_asset, mesh_obj_id, mesh))
+    Ok(InitializedResources {
+        shader_obj_id,
+        shader,
+        mesh_obj_id,
+        mesh,
+    })
 }
 
 fn update_inputs(
@@ -484,12 +483,9 @@ fn update_inputs(
 fn add_drawing_render_pass(
     context: &mut Context,
     render_passes: &mut RenderPasses,
-    shader_context: &ShaderContext,
     rendering_backend_properties: &RenderingBackendProperties,
     window_surface_id: SurfaceId,
-    shader_asset: AssetHandle<ShaderModuleSource>,
-    mesh_obj_id: RenderingObjectId,
-    mesh: &mut Mesh,
+    resources: &mut InitializedResources,
 ) -> Result<(), crate::Error>
 {
     let render_pass = render_passes.passes.push_back_mut(RenderPass {
@@ -508,12 +504,9 @@ fn add_drawing_render_pass(
         },
     });
 
-    let shader_program = shader_context
-        .get_program(&shader_asset.id())
-        .expect("Not possible");
-
     let shader_cursor = ShaderCursor::new(
-        shader_program
+        resources
+            .shader
             .reflection(rendering_backend_properties.shader_target_id)
             .unwrap()
             .global_params_var_layout()
@@ -521,10 +514,10 @@ fn add_drawing_render_pass(
     );
 
     let Context {
-        enabled: _,
         ctx,
         texture_lookup,
         texture_id_lookup,
+        ..
     } = context;
 
     let render_frame = ctx.render();
@@ -688,13 +681,11 @@ fn add_drawing_render_pass(
 
     // let [scale_width, scale_height] = draw_data.framebuffer_scale;
 
-    let shader_object_id = RenderingObjectId::Asset(shader_asset.id());
-
     render_pass.commands.extend([
         RenderingCommand::MakeCurrent(window_surface_id),
-        RenderingCommand::ActivateShader(shader_object_id),
+        RenderingCommand::ActivateShader(resources.shader_obj_id),
         RenderingCommand::SetShaderBinding(
-            shader_object_id,
+            resources.shader_obj_id,
             shader_cursor
                 .field("Uniforms")
                 .field("projection")
@@ -719,10 +710,10 @@ fn add_drawing_render_pass(
     ]);
 
     for draw_list in draw_data.draw_lists() {
-        mesh.vertex_buf_mut().clear();
+        resources.mesh.vertex_buf_mut().clear();
 
         for vertex in draw_list.vtx_buffer() {
-            mesh.vertex_buf_mut().push((
+            resources.mesh.vertex_buf_mut().push((
                 MeshNamedVertexAttr::<[f32; 3]> {
                     label: VertexLabel::Position,
                     value: [vertex.pos[0], vertex.pos[1], 0.0],
@@ -738,11 +729,13 @@ fn add_drawing_render_pass(
             ));
         }
 
-        mesh.set_indices(draw_list.idx_buffer().iter().map(|index| (*index).into()));
+        resources
+            .mesh
+            .set_indices(draw_list.idx_buffer().iter().map(|index| (*index).into()));
 
         render_pass.commands.push(RenderingCommand::UpdateMesh {
-            obj_id: mesh_obj_id,
-            mesh: mesh.clone(),
+            obj_id: resources.mesh_obj_id,
+            mesh: resources.mesh.clone(),
             usage: MeshUsage::Stream,
         });
 
@@ -771,7 +764,7 @@ fn add_drawing_render_pass(
                         DrawPropertiesUpdateFlags::SCISSOR_BOX,
                     ),
                     RenderingCommand::SetShaderBinding(
-                        shader_object_id,
+                        resources.shader_obj_id,
                         shader_cursor.field("main_texture").binding(
                             ShaderBindingValue::Texture(
                                 *texture_object_id,
@@ -780,7 +773,7 @@ fn add_drawing_render_pass(
                         )?,
                     ),
                     RenderingCommand::DrawMesh(
-                        mesh_obj_id,
+                        resources.mesh_obj_id,
                         DrawMeshOptions::builder()
                             .element_offset(cmd_params.idx_offset.try_into().unwrap())
                             .vertex_offset(cmd_params.vtx_offset.try_into().unwrap())
-- 
cgit v1.2.3-18-g5258