feat(engine): pass vertex subsets to shaders

1 files changed, 69 insertions, 16 deletions

diff --git a/engine/src/renderer/opengl.rs b/engine/src/renderer/opengl.rs
index d31835a..2dd5467 100644
--- a/engine/src/renderer/opengl.rs
+++ b/engine/src/renderer/opengl.rs
@@ -91,6 +91,7 @@ use crate::renderer::{
 };
 use crate::shader::cursor::BindingValue as ShaderBindingValue;
 use crate::shader::{
+    Context as ShaderContext,
     Error as ShaderError,
     Program as ShaderProgram,
     Stage as ShaderStage,
@@ -111,7 +112,6 @@ use crate::windowing::window::{
 
 mod glutin_compat;
 mod graphics_mesh;
-mod vertex;
 
 declare_entity!(
     pub POST_RENDER_PHASE,
@@ -137,7 +137,11 @@ struct GraphicsContext
 #[derive(Debug)]
 enum GraphicsContextObject
 {
-    Mesh(GraphicsMesh),
+    Mesh
+    {
+        mesh: GraphicsMesh,
+        compatible_shader_program_obj_id: RendererObjectId,
+    },
 }
 
 #[derive(Debug, Default)]
@@ -265,7 +269,10 @@ fn handle_model_removed(
             };
 
             #[allow(irrefutable_let_patterns)]
-            let GraphicsContextObject::Mesh(mut graphics_mesh) = removed_graphics_ctx_obj
+            let GraphicsContextObject::Mesh {
+                mesh: mut graphics_mesh,
+                compatible_shader_program_obj_id: _,
+            } = removed_graphics_ctx_obj
             else {
                 tracing::error!(
                     model_entity_id=%model_ent_id,
@@ -665,6 +672,7 @@ fn handle_commands(
         &mut RendererCommandQueue,
     )>,
     assets: Single<Assets>,
+    shader_context: Single<ShaderContext>,
 )
 {
     for (mut graphics_ctx, mut renderer_object_store, mut command_queue) in
@@ -680,7 +688,8 @@ fn handle_commands(
 
         let mut opt_curr_gl_ctx: Option<CurrentContextWithFns> = None;
 
-        let mut activated_gl_shader_program: Option<GlShaderProgram> = None;
+        let mut activated_gl_shader_program: Option<(RendererObjectId, GlShaderProgram)> =
+            None;
 
         for command in command_queue.drain() {
             let tracing_span = tracing::info_span!("handle_cmd");
@@ -794,7 +803,8 @@ fn handle_commands(
 
                     gl_shader_program.activate(&curr_gl_ctx);
 
-                    activated_gl_shader_program = Some(gl_shader_program);
+                    activated_gl_shader_program =
+                        Some((shader_program_obj_id, gl_shader_program));
                 }
                 RendererCommand::SetShaderBinding(binding_location, binding_value) => {
                     let Some(curr_gl_ctx) = &opt_curr_gl_ctx else {
@@ -918,18 +928,45 @@ fn handle_commands(
                         continue;
                     }
 
-                    let key = *next_graphics_ctx_object_key;
+                    let Some((RendererObjectId::Asset(curr_shader_program_asset_id), _)) =
+                        &activated_gl_shader_program
+                    else {
+                        tracing::error!("No shader program is activated");
+                        continue;
+                    };
 
-                    let graphics_mesh = match GraphicsMesh::new(&curr_gl_ctx, &mesh) {
-                        Ok(graphics_mesh) => graphics_mesh,
-                        Err(err) => {
-                            tracing::error!("Failed to create mesh: {err}");
-                            continue;
-                        }
+                    let curr_shader_program_metadata = shader_context
+                        .get_program_metadata(curr_shader_program_asset_id)
+                        .expect("Not possible");
+
+                    let Some(vertex_subset) = &curr_shader_program_metadata.vertex_subset
+                    else {
+                        tracing::error!(
+                            "Current shader program does not have a vertex subset"
+                        );
+                        continue;
                     };
 
-                    graphics_ctx_objects
-                        .insert(key, GraphicsContextObject::Mesh(graphics_mesh));
+                    let key = *next_graphics_ctx_object_key;
+
+                    let graphics_mesh =
+                        match GraphicsMesh::new(&curr_gl_ctx, &mesh, &vertex_subset) {
+                            Ok(graphics_mesh) => graphics_mesh,
+                            Err(err) => {
+                                tracing::error!("Failed to create mesh: {err}");
+                                continue;
+                            }
+                        };
+
+                    graphics_ctx_objects.insert(
+                        key,
+                        GraphicsContextObject::Mesh {
+                            mesh: graphics_mesh,
+                            compatible_shader_program_obj_id: RendererObjectId::Asset(
+                                *curr_shader_program_asset_id,
+                            ),
+                        },
+                    );
 
                     renderer_object_store.insert(
                         mesh_object_id,
@@ -970,8 +1007,10 @@ fn handle_commands(
                     };
 
                     #[allow(irrefutable_let_patterns)]
-                    let GraphicsContextObject::Mesh(graphics_mesh) =
-                        mesh_graphics_ctx_obj
+                    let GraphicsContextObject::Mesh {
+                        mesh: graphics_mesh,
+                        compatible_shader_program_obj_id,
+                    } = mesh_graphics_ctx_obj
                     else {
                         tracing::error!(
                             object_id=?mesh_object_id,
@@ -981,6 +1020,20 @@ fn handle_commands(
                         continue;
                     };
 
+                    if Some(compatible_shader_program_obj_id)
+                        != activated_gl_shader_program.as_ref().map(
+                            |(activated_gl_shader_program_obj_id, _)| {
+                                activated_gl_shader_program_obj_id
+                            },
+                        )
+                    {
+                        tracing::error!(concat!(
+                            "Activated shader program is not the ",
+                            "compatible shader program of the mesh"
+                        ));
+                        continue;
+                    }
+
                     if let Err(err) = draw_mesh(&curr_gl_ctx, graphics_mesh) {
                         tracing::error!("Failed to draw mesh: {err}");
                     };