feat(engine): set GPU vertex attrs on DrawMesh command if necessaryHEADmaster

3 files changed, 338 insertions, 202 deletions

diff --git a/engine/src/rendering/backend/opengl.rs b/engine/src/rendering/backend/opengl.rs
index 12aaaf0..0dfe960 100644
--- a/engine/src/rendering/backend/opengl.rs
+++ b/engine/src/rendering/backend/opengl.rs
@@ -47,7 +47,6 @@ use opengl_bindings::shader::{
     Kind as ShaderKind,
     Program as GlShaderProgram,
     Shader as GlShader,
-    // UniformLocation as GlUniformLocation,
 };
 use opengl_bindings::texture::{
     ColorSpace as GlTextureColorSpace,
@@ -101,9 +100,9 @@ use crate::rendering::shader::cursor::{
     BindingValue as ShaderBindingValue,
 };
 use crate::rendering::shader::{
-    Context as ShaderContext,
     Error as ShaderError,
     Program as ShaderProgram,
+    ProgramMetadata as ShaderProgramMetadata,
     Stage as ShaderStage,
 };
 use crate::rendering::{
@@ -173,7 +172,12 @@ enum GraphicsContextObject
     Mesh
     {
         mesh: GraphicsMesh,
-        compatible_shader_program_obj_id: ObjectId,
+        vertex_attrs_updated_for_shader: Option<ObjectId>,
+    },
+    Shader
+    {
+        program: GlShaderProgram,
+        program_metadata: ShaderProgramMetadata,
     },
 }
 
@@ -443,7 +447,6 @@ fn handle_commands(
     mut object_store: Single<ObjectStore>,
     mut command_queue: Single<CommandQueue>,
     assets: Single<Assets>,
-    shader_context: Single<ShaderContext>,
 ) -> Result<(), crate::Error>
 {
     let Ok(graphics_ctx) = graphics_ctx.get_mut() else {
@@ -453,7 +456,6 @@ fn handle_commands(
     let object_store = object_store.get_mut()?;
     let command_queue = command_queue.get_mut()?;
     let assets = assets.get()?;
-    let shader_context = shader_context.get()?;
 
     let GraphicsContext {
         ref gl_context,
@@ -467,7 +469,11 @@ fn handle_commands(
         return Ok(());
     };
 
-    let mut activated_gl_shader_program: Option<(ObjectId, GlShaderProgram)> = None;
+    let mut activated_gl_shader_program: Option<(
+        ObjectId,
+        GlShaderProgram,
+        ShaderProgramMetadata,
+    )> = None;
 
     for command in command_queue.drain() {
         let tracing_span = tracing::info_span!(
@@ -593,35 +599,80 @@ fn handle_commands(
                         }
                     };
 
+                let key = *next_graphics_ctx_object_key;
+
+                graphics_ctx_objects.insert(
+                    key,
+                    GraphicsContextObject::Shader {
+                        program: gl_shader_program,
+                        program_metadata: shader_program.metadata().clone(),
+                    },
+                );
+
                 object_store.insert(
                     shader_program_obj_id,
-                    Object::from_raw(
-                        gl_shader_program.into_raw(),
-                        ObjectKind::ShaderProgram,
-                    ),
+                    Object::from_raw(key, ObjectKind::ShaderProgram),
                 );
+
+                *next_graphics_ctx_object_key += 1;
             }
             Command::ActivateShader(shader_program_obj_id) => {
                 let Some(shader_program_obj) =
-                    object_store.get_shader_program_obj(&shader_program_obj_id)
+                    object_store.get_obj(&shader_program_obj_id)
                 else {
-                    tracing::error!("Shader object does not exist or has a wrong kind");
+                    tracing::error!(
+                        object_id = ?shader_program_obj_id,
+                        "Object does not exist"
+                    );
+
                     continue;
                 };
 
-                let gl_shader_program =
-                    GlShaderProgram::from_raw(shader_program_obj.as_raw());
+                if shader_program_obj.kind() != ObjectKind::ShaderProgram {
+                    tracing::error!(
+                        object_id = ?shader_program_obj_id,
+                        actual_kind = ?shader_program_obj.kind(),
+                        "Invalid object kind: not a shader program"
+                    );
 
-                gl_shader_program.activate(gl_context);
+                    continue;
+                }
+
+                let key = shader_program_obj.as_raw();
 
-                activated_gl_shader_program =
-                    Some((shader_program_obj_id, gl_shader_program));
+                let Some(graphics_ctx_obj) = graphics_ctx_objects.get(&key) else {
+                    tracing::error!(
+                        object_id = ?shader_program_obj_id,
+                        key = key,
+                        "Object not found in graphics context object store"
+                    );
+                    continue;
+                };
+
+                let GraphicsContextObject::Shader { program, program_metadata } =
+                    graphics_ctx_obj
+                else {
+                    tracing::error!(
+                        object_id = ?shader_program_obj_id,
+                        key = key,
+                        "Graphics context object is not a shader"
+                    );
+                    continue;
+                };
+
+                program.activate(gl_context);
+
+                activated_gl_shader_program = Some((
+                    shader_program_obj_id,
+                    program.clone(),
+                    program_metadata.clone(),
+                ));
             }
             Command::SetShaderBinding(ShaderBinding {
                 location: binding_location,
                 value: binding_value,
             }) => {
-                let Some((activated_gl_shader_program_obj_id, _)) =
+                let Some((activated_gl_shader_program_obj_id, _, _)) =
                     &activated_gl_shader_program
                 else {
                     tracing::error!("No shader program is activated");
@@ -786,24 +837,6 @@ fn handle_commands(
                     continue;
                 }
 
-                let Some((ObjectId::Asset(curr_shader_program_asset_id), _)) =
-                    &activated_gl_shader_program
-                else {
-                    tracing::error!("No shader program is activated");
-                    continue;
-                };
-
-                let curr_shader_program_metadata = shader_context
-                    .get_program_metadata(curr_shader_program_asset_id)
-                    .expect("Not possible");
-
-                let Some(vertex_desc) = &curr_shader_program_metadata.vertex_desc else {
-                    tracing::error!(
-                        "Current shader program does not have a vertex description"
-                    );
-                    continue;
-                };
-
                 let key = *next_graphics_ctx_object_key;
 
                 let mesh = match &mesh {
@@ -821,12 +854,8 @@ fn handle_commands(
                     AssetOrValue::Value(mesh) => mesh,
                 };
 
-                let graphics_mesh = match GraphicsMesh::new(
-                    gl_context,
-                    &mesh,
-                    mesh_usage,
-                    &vertex_desc,
-                ) {
+                let graphics_mesh = match GraphicsMesh::new(gl_context, &mesh, mesh_usage)
+                {
                     Ok(graphics_mesh) => graphics_mesh,
                     Err(err) => {
                         tracing::error!("Failed to create mesh: {err}");
@@ -838,9 +867,7 @@ fn handle_commands(
                     key,
                     GraphicsContextObject::Mesh {
                         mesh: graphics_mesh,
-                        compatible_shader_program_obj_id: ObjectId::Asset(
-                            *curr_shader_program_asset_id,
-                        ),
+                        vertex_attrs_updated_for_shader: None,
                     },
                 );
 
@@ -881,7 +908,7 @@ fn handle_commands(
                 #[allow(irrefutable_let_patterns)]
                 let GraphicsContextObject::Mesh {
                     mesh: graphics_mesh,
-                    compatible_shader_program_obj_id: _,
+                    vertex_attrs_updated_for_shader: _,
                 } = mesh_graphics_ctx_obj
                 else {
                     tracing::error!(
@@ -947,7 +974,7 @@ fn handle_commands(
                 };
 
                 let Some(mesh_graphics_ctx_obj) =
-                    graphics_ctx_objects.get(&mesh_graphics_ctx_obj_key)
+                    graphics_ctx_objects.get_mut(&mesh_graphics_ctx_obj_key)
                 else {
                     tracing::error!(
                         object_id=?mesh_object_id,
@@ -957,10 +984,9 @@ fn handle_commands(
                     continue;
                 };
 
-                #[allow(irrefutable_let_patterns)]
                 let GraphicsContextObject::Mesh {
                     mesh: graphics_mesh,
-                    compatible_shader_program_obj_id,
+                    vertex_attrs_updated_for_shader,
                 } = mesh_graphics_ctx_obj
                 else {
                     tracing::error!(
@@ -971,18 +997,36 @@ 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"
-                    ));
+                let Some((shader_program_obj_id, _, shader_program_metadata)) =
+                    &activated_gl_shader_program
+                else {
+                    tracing::error!("No shader program is activated");
                     continue;
+                };
+
+                if vertex_attrs_updated_for_shader.is_none_or(
+                    |vertex_attrs_updated_for_shader| {
+                        vertex_attrs_updated_for_shader != *shader_program_obj_id
+                    },
+                ) {
+                    let Some(shader_program_vertex_desc) =
+                        &shader_program_metadata.vertex_desc
+                    else {
+                        tracing::error!(
+                            "Activated shader program does not have a vertex description"
+                        );
+                        continue;
+                    };
+
+                    if let Err(err) = graphics_mesh.update_vertex_attrs_for_shader(
+                        gl_context,
+                        shader_program_vertex_desc,
+                    ) {
+                        tracing::error!("Cannot draw mesh: {err}");
+                        continue;
+                    }
+
+                    *vertex_attrs_updated_for_shader = Some(*shader_program_obj_id);
                 }
 
                 if let Err(err) = draw_mesh(gl_context, graphics_mesh, &draw_mesh_opts) {
diff --git a/engine/src/rendering/backend/opengl/graphics_mesh.rs b/engine/src/rendering/backend/opengl/graphics_mesh.rs
index 6d5c248..a1c903b 100644
--- a/engine/src/rendering/backend/opengl/graphics_mesh.rs
+++ b/engine/src/rendering/backend/opengl/graphics_mesh.rs
@@ -1,3 +1,5 @@
+use std::hint::cold_path;
+
 use opengl_bindings::buffer::{Buffer as GlBuffer, Usage as GlBufferUsage};
 use opengl_bindings::vertex_array::{
     AttributeFormat as GlVertexArrayAttributeFormat,
@@ -8,15 +10,20 @@ use opengl_bindings::vertex_array::{
 };
 use opengl_bindings::MaybeCurrentContextWithFns as GlCurrentContextWithFns;
 
+use crate::mesh::vertex_buffer::VertexAttrProperties as MeshVertexAttrProperties;
 use crate::mesh::{Mesh, VertexAttrType};
 use crate::rendering::shader::VertexDescription as ShaderVertexDescription;
 use crate::rendering::MeshUsage;
 
+const VERTEX_BUF_BINDING_INDEX: u32 = 0;
+
 #[derive(Debug)]
 pub struct GraphicsMesh
 {
     /// Vertex and index buffer has to live as long as the vertex array
     vertex_buffer: GlBuffer<u8>,
+    vertex_attr_props: Vec<MeshVertexAttrProperties>,
+    last_used_vertex_attr_cnt: u32,
     pub index_buffer: Option<GlBuffer<u32>>,
     pub element_cnt: u32,
     pub vertex_arr: GlVertexArray,
@@ -29,7 +36,6 @@ impl GraphicsMesh
         current_context: &GlCurrentContextWithFns,
         mesh: &Mesh,
         mesh_usage: MeshUsage,
-        vertex_desc: &ShaderVertexDescription,
     ) -> Result<Self, Error>
     {
         let buffer_usage = mesh_usage_to_gl_buffer_usage(mesh_usage);
@@ -41,11 +47,9 @@ impl GraphicsMesh
             .store(current_context, mesh.vertex_buf().as_bytes(), buffer_usage)
             .map_err(Error::StoreVerticesFailed)?;
 
-        let vertex_buf_binding_index = 0;
-
         if let Err(err) = vertex_arr.bind_vertex_buffer(
             current_context,
-            vertex_buf_binding_index,
+            VERTEX_BUF_BINDING_INDEX,
             &vertex_buffer,
             GlVertexArrayVertexBufferSpec {
                 offset: 0,
@@ -69,48 +73,6 @@ impl GraphicsMesh
             }
         }
 
-        for vertex_attr_props in mesh.vertex_buf().vertex_attr_props() {
-            let vertex_field_desc = vertex_desc
-                .fields
-                .iter()
-                .find(|vertex_field_desc| {
-                    *vertex_field_desc.name == vertex_attr_props.name
-                })
-                .unwrap();
-
-            let attrib_index: u32 =
-                vertex_field_desc.varying_input_offset.try_into().unwrap();
-
-            vertex_arr.enable_attrib(current_context, attrib_index);
-
-            vertex_arr.set_attrib_format(
-                current_context,
-                attrib_index,
-                match &vertex_attr_props.ty {
-                    VertexAttrType::Float32 => GlVertexArrayAttributeFormat {
-                        data_type: GlVertexArrayDataType::Float,
-                        count: 1,
-                        normalized: false,
-                        offset: vertex_attr_props.byte_offset.try_into().unwrap(),
-                    },
-                    VertexAttrType::Float32Array { length } => {
-                        GlVertexArrayAttributeFormat {
-                            data_type: GlVertexArrayDataType::Float,
-                            count: (*length).try_into().unwrap(),
-                            normalized: false,
-                            offset: vertex_attr_props.byte_offset.try_into().unwrap(),
-                        }
-                    }
-                },
-            );
-
-            vertex_arr.set_attrib_vertex_buf_binding(
-                current_context,
-                attrib_index,
-                vertex_buf_binding_index,
-            );
-        }
-
         if let Some(indices) = mesh.indices() {
             let index_buffer = GlBuffer::new(current_context);
 
@@ -122,6 +84,8 @@ impl GraphicsMesh
 
             return Ok(Self {
                 vertex_buffer: vertex_buffer,
+                vertex_attr_props: mesh.vertex_buf().vertex_attr_props().to_vec(),
+                last_used_vertex_attr_cnt: 0,
                 index_buffer: Some(index_buffer),
                 element_cnt: indices
                     .len()
@@ -133,6 +97,8 @@ impl GraphicsMesh
 
         Ok(Self {
             vertex_buffer: vertex_buffer,
+            vertex_attr_props: mesh.vertex_buf().vertex_attr_props().to_vec(),
+            last_used_vertex_attr_cnt: 0,
             index_buffer: None,
             element_cnt: mesh
                 .vertex_buf()
@@ -185,6 +151,113 @@ impl GraphicsMesh
         Ok(())
     }
 
+    pub fn update_vertex_attrs_for_shader(
+        &mut self,
+        curr_gl_ctx: &GlCurrentContextWithFns,
+        shader_vertex_desc: &ShaderVertexDescription,
+    ) -> Result<(), VertexAttrsUpdatingError>
+    {
+        let vertex_field_desc_cnt = u32::try_from(shader_vertex_desc.fields.len())
+            .expect("Shader has too many vertex fields. Count does not fit into u32");
+
+        if self.last_used_vertex_attr_cnt > vertex_field_desc_cnt {
+            for index in vertex_field_desc_cnt..self.last_used_vertex_attr_cnt {
+                self.vertex_arr.disable_attrib(curr_gl_ctx, index);
+            }
+        }
+
+        let mut used_vertex_attr_cnt = 0u32;
+
+        let mut last_attr_index: Option<u32> = None;
+
+        for vertex_attr_props in &self.vertex_attr_props {
+            let Some(vertex_field_desc) =
+                shader_vertex_desc.fields.iter().find(|vertex_field_desc| {
+                    *vertex_field_desc.name == vertex_attr_props.name
+                })
+            else {
+                continue;
+            };
+
+            let attrib_index: u32 =
+                vertex_field_desc.varying_input_offset.try_into().unwrap();
+
+            if let Some(last_attr_index) = last_attr_index {
+                if last_attr_index.wrapping_add(1) != attrib_index {
+                    cold_path();
+                    return Err(
+                        VertexAttrsUpdatingError::VertexAttrIndicesNotConsecutive,
+                    );
+                }
+            } else if attrib_index != 0 {
+                cold_path();
+                return Err(VertexAttrsUpdatingError::FirstVertexAttrIndexNotZero {
+                    vertex_attr_name: vertex_attr_props.name.to_string().into_boxed_str(),
+                    unexpected_index: attrib_index,
+                });
+            }
+
+            last_attr_index = Some(attrib_index);
+
+            self.vertex_arr.enable_attrib(curr_gl_ctx, attrib_index);
+
+            self.vertex_arr.set_attrib_format(
+                curr_gl_ctx,
+                attrib_index,
+                match &vertex_attr_props.ty {
+                    VertexAttrType::Float32 => GlVertexArrayAttributeFormat {
+                        data_type: GlVertexArrayDataType::Float,
+                        count: 1,
+                        normalized: false,
+                        offset: vertex_attr_props.byte_offset.try_into().unwrap(),
+                    },
+                    VertexAttrType::Float32Array { length } => {
+                        GlVertexArrayAttributeFormat {
+                            data_type: GlVertexArrayDataType::Float,
+                            count: (*length).try_into().unwrap(),
+                            normalized: false,
+                            offset: vertex_attr_props.byte_offset.try_into().unwrap(),
+                        }
+                    }
+                },
+            );
+
+            self.vertex_arr.set_attrib_vertex_buf_binding(
+                curr_gl_ctx,
+                attrib_index,
+                VERTEX_BUF_BINDING_INDEX,
+            );
+
+            used_vertex_attr_cnt += 1;
+        }
+
+        self.last_used_vertex_attr_cnt = used_vertex_attr_cnt;
+
+        if used_vertex_attr_cnt as usize != shader_vertex_desc.fields.len() {
+            cold_path();
+
+            return Err(VertexAttrsUpdatingError::MissingVertexAttrs(
+                shader_vertex_desc
+                    .fields
+                    .iter()
+                    .filter_map(|vertex_field_desc| {
+                        if self
+                            .vertex_attr_props
+                            .iter()
+                            .any(|prop| prop.name == *vertex_field_desc.name)
+                        {
+                            return None;
+                        }
+
+                        Some(vertex_field_desc.name.clone())
+                    })
+                    .collect(),
+            ));
+        }
+
+        Ok(())
+    }
+
     pub fn destroy(&mut self, curr_gl_ctx: &GlCurrentContextWithFns)
     {
         self.vertex_arr.delete(curr_gl_ctx);
@@ -206,6 +279,26 @@ pub enum Error
     StoreIndicesFailed(#[source] opengl_bindings::buffer::Error),
 }
 
+#[derive(Debug, thiserror::Error)]
+pub enum VertexAttrsUpdatingError
+{
+    #[error("Mesh is missing vertex attribute(s) required by shader: {0:?}")]
+    MissingVertexAttrs(Vec<Box<str>>),
+
+    #[error("Shader's vertex attribute indices are not consecutive")]
+    VertexAttrIndicesNotConsecutive,
+
+    #[error(
+        "Shader's first vertex attribute ({vertex_attr_name}) index is not 0, is {}",
+        unexpected_index
+    )]
+    FirstVertexAttrIndexNotZero
+    {
+        vertex_attr_name: Box<str>,
+        unexpected_index: u32,
+    },
+}
+
 fn mesh_usage_to_gl_buffer_usage(mesh_usage: MeshUsage) -> GlBufferUsage
 {
     match mesh_usage {
diff --git a/engine/src/rendering/shader.rs b/engine/src/rendering/shader.rs
index b508670..3bcf73e 100644
--- a/engine/src/rendering/shader.rs
+++ b/engine/src/rendering/shader.rs
@@ -4,6 +4,7 @@ use std::collections::HashMap;
 use std::fmt::Debug;
 use std::path::Path;
 use std::str::Utf8Error;
+use std::sync::Arc;
 
 use bitflags::{bitflags, bitflags_match};
 use ecs::phase::INIT as INIT_PHASE;
@@ -156,15 +157,24 @@ impl<'a> EntryPointReflection<'a>
 pub struct Program
 {
     inner: SlangComponentType,
+    metadata: ProgramMetadata,
 }
 
 impl Program
 {
-    pub fn link(&self) -> Result<Program, Error>
+    pub fn into_linked(self) -> Result<Program, Error>
     {
         let linked_program = self.inner.link()?;
 
-        Ok(Program { inner: linked_program })
+        Ok(Program {
+            inner: linked_program,
+            metadata: self.metadata,
+        })
+    }
+
+    pub fn metadata(&self) -> &ProgramMetadata
+    {
+        &self.metadata
     }
 
     pub fn get_entry_point_code(&self, entry_point_index: u32) -> Result<Blob, Error>
@@ -791,7 +801,7 @@ pub struct Context
     _global_session: SlangGlobalSession,
     session: SlangSession,
     modules: HashMap<AssetId, Module>,
-    programs: HashMap<AssetId, (Program, ProgramMetadata)>,
+    programs: HashMap<AssetId, Program>,
 }
 
 impl Context
@@ -803,38 +813,70 @@ impl Context
 
     pub fn get_program(&self, asset_id: &AssetId) -> Option<&Program>
     {
-        self.programs.get(asset_id).map(|(program, _)| program)
-    }
-
-    pub fn get_program_metadata(&self, asset_id: &AssetId) -> Option<&ProgramMetadata>
-    {
-        self.programs
-            .get(asset_id)
-            .map(|(_, program_metadata)| program_metadata)
+        self.programs.get(asset_id)
     }
 
     pub fn compose_into_program(
         &self,
-        modules: impl IntoIterator<Item = Module>,
-        entry_points: impl IntoIterator<Item = EntryPoint>,
-    ) -> Result<Program, Error>
+        module: Module,
+        link_entrypoints: EntrypointFlags,
+    ) -> Result<Program, ComposeProgramError>
     {
-        let components =
-            modules
-                .into_iter()
-                .map(|module| SlangComponentType::from(module.inner.clone()))
-                .chain(entry_points.into_iter().map(|entry_point| {
-                    SlangComponentType::from(entry_point.inner.clone())
-                }))
-                .collect::<Vec<_>>();
-
-        let program = self.session.create_composite_component_type(&components)?;
-
-        Ok(Program { inner: program })
+        let entry_points = link_entrypoints
+            .iter()
+            .filter_map(|entrypoint_flag| {
+                let entrypoint_name = bitflags_match!(entrypoint_flag, {
+                    EntrypointFlags::VERTEX => Some("vertex_main"),
+                    EntrypointFlags::FRAGMENT => Some("fragment_main"),
+                    _ => None
+                })?;
+
+                let Some(entry_point) = module.get_entry_point(entrypoint_name) else {
+                    return Some(Err(ComposeProgramError::EntrypointNotFoundError {
+                        entrypoint_name,
+                    }));
+                };
+
+                Some(Ok(entry_point))
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        let components = entry_points
+            .into_iter()
+            .map(|entry_point| SlangComponentType::from(entry_point.inner))
+            .chain([SlangComponentType::from(module.inner)])
+            .collect::<Vec<_>>();
+
+        let program = self
+            .session
+            .create_composite_component_type(&components)
+            .map_err(|err| ComposeProgramError::Other(Error(err)))?;
+
+        let vertex_desc = if link_entrypoints.contains(EntrypointFlags::VERTEX) {
+            // TODO: Do not have hard coded target here
+            let Ok(program_reflection) = program.layout(0) else {
+                unreachable!();
+            };
+
+            let program_reflection = ProgramReflection { inner: program_reflection };
+
+            Some(VertexDescription::new(
+                &program_reflection
+                    .get_entry_point_by_name("vertex_main")
+                    .expect("Not possible"),
+            )?)
+        } else {
+            None
+        };
+
+        Ok(Program {
+            inner: program,
+            metadata: ProgramMetadata { vertex_desc },
+        })
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 #[non_exhaustive]
 pub struct ProgramMetadata
 {
@@ -843,11 +885,11 @@ pub struct ProgramMetadata
     pub vertex_desc: Option<VertexDescription>,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 #[non_exhaustive]
 pub struct VertexDescription
 {
-    pub fields: Box<[VertexFieldDescription]>,
+    pub fields: Arc<[VertexFieldDescription]>,
 }
 
 impl VertexDescription
@@ -916,7 +958,7 @@ impl VertexDescription
             })
             .collect::<Result<Vec<_>, _>>()?;
 
-        Ok(Self { fields: fields.into_boxed_slice() })
+        Ok(Self { fields: fields.into() })
     }
 }
 
@@ -955,6 +997,22 @@ pub enum VertexDescriptionError
 }
 
 #[derive(Debug, thiserror::Error)]
+pub enum ComposeProgramError
+{
+    #[error("Shader module does not have a '{entrypoint_name}' entry point")]
+    EntrypointNotFoundError
+    {
+        entrypoint_name: &'static str
+    },
+
+    #[error("Failed to create vertex description")]
+    VertexDescriptionCreationFailed(#[from] VertexDescriptionError),
+
+    #[error(transparent)]
+    Other(Error),
+}
+
+#[derive(Debug, thiserror::Error)]
 #[error(transparent)]
 pub struct Error(#[from] shader_slang::Error);
 
@@ -1108,44 +1166,17 @@ fn load_modules(
         if !module_source.link_entrypoints.is_empty() {
             assert!(context.programs.get(asset_id).is_none());
 
-            let entry_points = match module_source
-                .link_entrypoints
-                .iter()
-                .filter_map(|entrypoint_flag| {
-                    let entrypoint_name = bitflags_match!(entrypoint_flag, {
-                        EntrypointFlags::VERTEX => Some("vertex_main"),
-                        EntrypointFlags::FRAGMENT => Some("fragment_main"),
-                        _ => None
-                    })?;
-
-                    let Some(entry_point) = module.get_entry_point(entrypoint_name)
-                    else {
-                        return Some(Err(EntrypointNotFoundError { entrypoint_name }));
-                    };
-
-                    Some(Ok(entry_point))
-                })
-                .collect::<Result<Vec<_>, EntrypointNotFoundError>>()
+            let shader_program = match context
+                .compose_into_program(module, module_source.link_entrypoints)
             {
-                Ok(entry_points) => entry_points,
-                Err(EntrypointNotFoundError { entrypoint_name }) => {
-                    tracing::error!(
-                        "Shader module does not have a '{entrypoint_name}' entry point"
-                    );
+                Ok(shader_program) => shader_program,
+                Err(err) => {
+                    tracing::error!("Failed to compose shader into program: {err}");
                     continue;
                 }
             };
 
-            let shader_program =
-                match context.compose_into_program([module], entry_points) {
-                    Ok(shader_program) => shader_program,
-                    Err(err) => {
-                        tracing::error!("Failed to compose shader into program: {err}");
-                        continue;
-                    }
-                };
-
-            let linked_shader_program = match shader_program.link() {
+            let linked_shader_program = match shader_program.into_linked() {
                 Ok(linked_shader_program) => linked_shader_program,
                 Err(err) => {
                     tracing::error!("Failed to link shader: {err}");
@@ -1153,33 +1184,7 @@ fn load_modules(
                 }
             };
 
-            let vertex_desc = if module_source
-                .link_entrypoints
-                .contains(EntrypointFlags::VERTEX)
-            {
-                VertexDescription::new(
-                    &shader_program
-                        .reflection(0)
-                        .expect("Not possible")
-                        .get_entry_point_by_name("vertex_main")
-                        .expect("Not possible"),
-                )
-                .inspect_err(|err| {
-                    tracing::error!(
-                        "Failed to create a vertex description for shader {}: {}",
-                        asset_label,
-                        err
-                    );
-                })
-                .ok()
-            } else {
-                None
-            };
-
-            context.programs.insert(
-                *asset_id,
-                (linked_shader_program, ProgramMetadata { vertex_desc }),
-            );
+            context.programs.insert(*asset_id, linked_shader_program);
         }
     }
 
@@ -1199,9 +1204,3 @@ fn load_module(
 
     Ok(Module { inner: module })
 }
-
-#[derive(Debug)]
-struct EntrypointNotFoundError
-{
-    entrypoint_name: &'static str,
-}