feat(engine): use slang for shadersHEADmaster

1 files changed, 224 insertions, 545 deletions

diff --git a/engine/src/renderer/opengl.rs b/engine/src/renderer/opengl.rs
index 4bd67a4..c72a344 100644
--- a/engine/src/renderer/opengl.rs
+++ b/engine/src/renderer/opengl.rs
@@ -1,16 +1,14 @@
 //! OpenGL renderer.
 
 use std::any::type_name;
+use std::borrow::Cow;
 use std::collections::HashMap;
-use std::ffi::CString;
-use std::io::{Error as IoError, ErrorKind as IoErrorKind};
-use std::path::Path;
 
 use ecs::actions::Actions;
 use ecs::entity::obtainer::Obtainer as EntityObtainer;
 use ecs::event::component::{Changed, Removed};
 use ecs::pair::{ChildOf, Pair, Wildcard};
-use ecs::phase::Phase;
+use ecs::phase::{Phase, START as START_PHASE};
 use ecs::query::term::Without;
 use ecs::sole::Single;
 use ecs::system::observer::Observe;
@@ -44,6 +42,7 @@ use opengl_bindings::shader::{
     Kind as ShaderKind,
     Program as GlShaderProgram,
     Shader as GlShader,
+    // UniformLocation as GlUniformLocation,
 };
 use opengl_bindings::texture::{
     Filtering as GlTextureFiltering,
@@ -59,21 +58,13 @@ use opengl_bindings::vertex_array::{
 };
 use opengl_bindings::{ContextWithFns, CurrentContextWithFns};
 use safer_ffi::layout::ReprC;
+use zerocopy::{Immutable, IntoBytes};
 
 use crate::asset::{Assets, Id as AssetId};
-use crate::camera::Camera;
-use crate::color::Color;
 use crate::data_types::dimens::Dimens;
 use crate::image::{ColorType as ImageColorType, Image};
-use crate::lighting::{DirectionalLight, GlobalLight, PointLight};
-use crate::material::{Flags as MaterialFlags, Material};
 use crate::matrix::Matrix;
 use crate::model::Model;
-use crate::opengl::glsl::{
-    PreprocessingError as GlslPreprocessingError,
-    preprocess as glsl_preprocess,
-};
-use crate::projection::{ClipVolume, Projection};
 use crate::renderer::object::{
     Id as RendererObjectId,
     Kind as RendererObjectKind,
@@ -91,17 +82,23 @@ use crate::renderer::{
     CommandQueue as RendererCommandQueue,
     CtxUsedByWindow as RendererCtxUsedByWindow,
     GraphicsProperties,
+    PRE_RENDER_PHASE,
     RENDER_PHASE,
     SurfaceId,
     SurfaceSpec,
     WindowUsingRendererCtx,
 };
+use crate::shader::cursor::BindingValue as ShaderBindingValue;
+use crate::shader::{
+    Error as ShaderError,
+    Program as ShaderProgram,
+    Stage as ShaderStage,
+};
 use crate::texture::{
     Filtering as TextureFiltering,
     Properties as TextureProperties,
     Wrapping as TextureWrapping,
 };
-use crate::transform::WorldPosition;
 use crate::vector::{Vec2, Vec3};
 use crate::windowing::Context as WindowingContext;
 use crate::windowing::window::{
@@ -115,12 +112,6 @@ mod glutin_compat;
 mod graphics_mesh;
 mod vertex;
 
-const AMBIENT_MAP_TEXTURE_UNIT: u32 = 0;
-const DIFFUSE_MAP_TEXTURE_UNIT: u32 = 1;
-const SPECULAR_MAP_TEXTURE_UNIT: u32 = 2;
-
-const DEFAULT_TEXTURE_OBJECT_ID: RendererObjectId = RendererObjectId::Other(0xaa);
-
 declare_entity!(
     pub POST_RENDER_PHASE,
     (Phase, Pair::builder().relation::<ChildOf>().target_id(*RENDER_PHASE).build())
@@ -136,9 +127,9 @@ struct WindowGlConfig
 struct GraphicsContext
 {
     gl_context: ContextWithFns,
-    shader_program: Option<GlShaderProgram>,
     graphics_mesh_store: GraphicsMeshStore,
     surfaces: HashMap<SurfaceId, GlutinSurface<GlutinWindowSurface>>,
+    uniform_buffer_objs: HashMap<u32, opengl_bindings::buffer::Buffer<u8>>,
 }
 
 #[derive(Debug, Default)]
@@ -155,9 +146,12 @@ impl ecs::extension::Extension for Extension
 {
     fn collect(self, mut collector: ecs::extension::Collector<'_>)
     {
+        collector.add_declared_entity(&PRE_RENDER_PHASE);
         collector.add_declared_entity(&RENDER_PHASE);
         collector.add_declared_entity(&POST_RENDER_PHASE);
 
+        collector.add_system(*START_PHASE, super::init);
+
         collector.add_system(*RENDER_PHASE, super::enqueue_commands);
         collector.add_system(*RENDER_PHASE, handle_commands);
 
@@ -617,9 +611,9 @@ fn init_window_graphics(
         let renderer_ctx_ent_id = actions.spawn((
             GraphicsContext {
                 gl_context,
-                shader_program: None,
                 graphics_mesh_store: GraphicsMeshStore::default(),
                 surfaces: HashMap::from([(surface_id, surface)]),
+                uniform_buffer_objs: HashMap::new(),
             },
             RendererObjectStore::default(),
             RendererCommandQueue::default(),
@@ -657,17 +651,17 @@ fn handle_commands(
     {
         let GraphicsContext {
             ref gl_context,
-            ref mut shader_program,
             ref mut graphics_mesh_store,
             ref surfaces,
+            ref mut uniform_buffer_objs,
         } = *graphics_ctx;
 
         let mut opt_curr_gl_ctx: Option<CurrentContextWithFns> = None;
 
-        let mut opt_curr_camera: Option<(Camera, WorldPosition)> = None;
+        let mut activated_gl_shader_program: Option<GlShaderProgram> = None;
 
         for command in command_queue.drain() {
-            let tracing_span = tracing::info_span!("handle_cmd", command = ?command);
+            let tracing_span = tracing::info_span!("handle_cmd");
             let _tracing_span_enter = tracing_span.enter();
 
             match command {
@@ -724,89 +718,148 @@ fn handle_commands(
                         tracing::error!("Failed to swap buffers: {err}");
                     }
                 }
-                RendererCommand::UseShader => {
+                RendererCommand::CreateShaderProgram(
+                    shader_program_obj_id,
+                    shader_program,
+                ) => {
                     let Some(curr_gl_ctx) = &opt_curr_gl_ctx else {
                         tracing::error!("No GL context is current");
                         continue;
                     };
 
-                    let _shader_program = shader_program.get_or_insert_with(|| {
-                        create_default_shader_program(&curr_gl_ctx).unwrap()
-                    });
-                }
-                RendererCommand::ActivateShader => {
-                    let Some(curr_gl_ctx) = &opt_curr_gl_ctx else {
-                        tracing::error!("No GL context is current");
+                    if renderer_object_store.contains_with_id(&shader_program_obj_id) {
+                        tracing::error!(
+                            object_id=?shader_program_obj_id,
+                            "Object store already contains a object with this ID"
+                        );
                         continue;
-                    };
+                    }
 
-                    let Some(shader_program) = shader_program else {
-                        tracing::error!("Shader does not exist");
-                        continue;
-                    };
+                    let gl_shader_program =
+                        match create_shader_program(&curr_gl_ctx, &shader_program) {
+                            Ok(gl_shader_program) => gl_shader_program,
+                            Err(err) => {
+                                tracing::error!("Failed to create shader program: {err}");
+                                continue;
+                            }
+                        };
 
-                    shader_program.activate(&curr_gl_ctx);
-                }
-                RendererCommand::UseCamera(camera, camera_world_pos) => {
-                    opt_curr_camera = Some((camera, camera_world_pos));
+                    renderer_object_store.insert(
+                        shader_program_obj_id,
+                        RendererObject::from_raw(
+                            gl_shader_program.into_raw(),
+                            RendererObjectKind::ShaderProgram,
+                        ),
+                    );
                 }
-                RendererCommand::ApplyTransform { transform, window_size } => {
+                RendererCommand::ActivateShader(shader_program_obj_id) => {
                     let Some(curr_gl_ctx) = &opt_curr_gl_ctx else {
                         tracing::error!("No GL context is current");
                         continue;
                     };
 
-                    let Some(shader_program) = shader_program else {
-                        tracing::error!("Shader does not exist");
+                    let Some(shader_program_obj) = renderer_object_store
+                        .get_shader_program_obj(&shader_program_obj_id)
+                    else {
+                        tracing::error!(
+                            "Shader object does not exist or has a wrong kind"
+                        );
                         continue;
                     };
 
-                    let Some((camera, camera_world_pos)) = &opt_curr_camera else {
-                        tracing::error!("No current camera");
-                        continue;
-                    };
+                    let gl_shader_program =
+                        GlShaderProgram::from_raw(shader_program_obj.as_raw());
 
-                    apply_transformation_matrices(
-                        &curr_gl_ctx,
-                        Transformation {
-                            position: transform.position,
-                            scale: transform.scale,
-                        },
-                        shader_program,
-                        &camera,
-                        &camera_world_pos,
-                        &window_size,
-                    );
+                    gl_shader_program.activate(&curr_gl_ctx);
+
+                    activated_gl_shader_program = Some(gl_shader_program);
                 }
-                RendererCommand::SetShaderDirectionalLights(directional_lights) => {
+                RendererCommand::SetShaderBinding(binding_location, binding_value) => {
                     let Some(curr_gl_ctx) = &opt_curr_gl_ctx else {
                         tracing::error!("No GL context is current");
                         continue;
                     };
 
-                    let Some(shader_program) = shader_program else {
-                        tracing::error!("Shader does not exist");
+                    if activated_gl_shader_program.is_none() {
+                        tracing::error!("No shader program is activated");
                         continue;
-                    };
+                    }
 
-                    set_shader_directional_lights(
-                        curr_gl_ctx,
-                        shader_program,
-                        &directional_lights,
-                    );
-                }
-                RendererCommand::SetShaderPointLights(point_lights) => {
-                    let Some(curr_gl_ctx) = &opt_curr_gl_ctx else {
-                        tracing::error!("No GL context is current");
-                        continue;
-                    };
+                    if let ShaderBindingValue::Texture(texture_asset) = &binding_value {
+                        let Some(texture_obj) = renderer_object_store.get_texture_obj(
+                            &RendererObjectId::Asset(texture_asset.id()),
+                        ) else {
+                            tracing::error!(
+                                "Texture {:?} does not exist in renderer object store",
+                                assets.get_label(texture_asset)
+                            );
+                            continue;
+                        };
+
+                        let gl_texture = GlTexture::from_raw(texture_obj.as_raw());
+
+                        gl_texture.bind_to_texture_unit(
+                            curr_gl_ctx,
+                            binding_location.binding_index,
+                        );
+
+                        // gl_shader_program.set_uniform_at_location(
+                        //     curr_gl_ctx,
+                        //     GlUniformLocation::from_number(
+                        //         binding_location.binding_index as i32,
+                        //     ),
+                        //     &binding_location.binding_index,
+                        // );
 
-                    let Some(shader_program) = shader_program else {
-                        tracing::error!("Shader does not exist");
                         continue;
-                    };
+                    }
 
-                    set_shader_point_lights(curr_gl_ctx, shader_program, &point_lights);
+                    let binding_index = binding_location.binding_index;
+
+                    let uniform_buffer =
+                        uniform_buffer_objs.entry(binding_index).or_insert_with(|| {
+                            let uniform_buf =
+                                opengl_bindings::buffer::Buffer::<u8>::new(curr_gl_ctx);
+
+                            uniform_buf
+                                .init(
+                                    curr_gl_ctx,
+                                    binding_location.binding_size,
+                                    opengl_bindings::buffer::Usage::Dynamic,
+                                )
+                                .unwrap();
+
+                            uniform_buf.bind_to_indexed_target(
+                                curr_gl_ctx,
+                                opengl_bindings::buffer::BindingTarget::UniformBuffer,
+                                binding_index as u32,
+                            );
+
+                            uniform_buf
+                        });
+
+                    let fvec3_value;
+
+                    uniform_buffer
+                        .store_at_byte_offset(
+                            curr_gl_ctx,
+                            binding_location.byte_offset,
+                            match binding_value {
+                                ShaderBindingValue::Uint(ref value) => value.as_bytes(),
+                                ShaderBindingValue::Int(ref value) => value.as_bytes(),
+                                ShaderBindingValue::Float(ref value) => value.as_bytes(),
+                                ShaderBindingValue::FVec3(value) => {
+                                    fvec3_value = CF32Vec3::from(value);
+
+                                    fvec3_value.as_bytes()
+                                }
+                                ShaderBindingValue::FMat4x4(ref value) => {
+                                    value.items().as_bytes()
+                                }
+                                ShaderBindingValue::Texture(_) => unreachable!(),
+                            },
+                        )
+                        .unwrap();
                 }
                 RendererCommand::CreateTexture(texture) => {
                     let Some(curr_gl_ctx) = &opt_curr_gl_ctx else {
@@ -815,6 +868,7 @@ fn handle_commands(
                     };
 
                     let Some(texture_image) = assets.get(&texture.asset_handle) else {
+                        tracing::error!("Texture asset is not loaded",);
                         continue;
                     };
 
@@ -828,58 +882,14 @@ fn handle_commands(
                         tracing::error!("Failed to create texture object: {err}");
                     }
                 }
-                RendererCommand::UseMaterial {
-                    material_asset,
-                    material_flags,
-                    global_light,
-                } => {
-                    let Some(curr_gl_ctx) = &opt_curr_gl_ctx else {
-                        tracing::error!("No GL context is current");
-                        continue;
-                    };
-
-                    let Some(shader_program) = shader_program else {
-                        tracing::error!("Shader does not exist");
-                        continue;
-                    };
-
-                    let Some((_, camera_world_pos)) = &opt_curr_camera else {
-                        tracing::error!("No current camera");
-                        continue;
-                    };
-
-                    let material = match material_asset.as_ref() {
-                        Some(material_asset) => {
-                            let Some(material) = assets.get(&material_asset) else {
-                                continue;
-                            };
-
-                            material
-                        }
-                        None => &Material::default(),
-                    };
-
-                    set_shader_material(
-                        curr_gl_ctx,
-                        material,
-                        &material_flags,
-                        &global_light,
-                        shader_program,
-                        camera_world_pos,
-                    );
-
-                    bind_material_textures(
-                        curr_gl_ctx,
-                        material,
-                        &mut renderer_object_store,
-                    );
-                }
                 RendererCommand::DrawMesh { mesh_asset } => {
                     let Some(curr_gl_ctx) = &opt_curr_gl_ctx else {
                         tracing::error!("No GL context is current");
                         continue;
                     };
 
+                    // tracing::warn!("ARGH! Drawing mesh");
+
                     let graphics_mesh =
                         match graphics_mesh_store.graphics_meshes.get(&mesh_asset.id()) {
                             Some(graphics_mesh) => graphics_mesh,
@@ -930,21 +940,6 @@ fn handle_commands(
     }
 }
 
-fn create_default_texture(current_context: &CurrentContextWithFns<'_>) -> GlTexture
-{
-    match create_gl_texture(
-        current_context,
-        &Image::from_color(Dimens { width: 1, height: 1 }, Color::WHITE_U8),
-        &TextureProperties::default(),
-    ) {
-        Ok(gl_texture) => gl_texture,
-        Err(
-            GlTextureGenerateError::SizeWidthValueTooLarge { value: _, max_value: _ }
-            | GlTextureGenerateError::SizeHeightValueTooLarge { value: _, max_value: _ },
-        ) => unreachable!(),
-    }
-}
-
 #[tracing::instrument(skip_all)]
 fn create_texture_object(
     curr_gl_ctx: &CurrentContextWithFns<'_>,
@@ -975,53 +970,6 @@ fn create_texture_object(
     Ok(())
 }
 
-fn bind_material_textures(
-    current_context: &CurrentContextWithFns<'_>,
-    material: &Material,
-    renderer_object_store: &mut RendererObjectStore,
-)
-{
-    let material_texture_maps = [
-        (&material.ambient_map, AMBIENT_MAP_TEXTURE_UNIT),
-        (&material.diffuse_map, DIFFUSE_MAP_TEXTURE_UNIT),
-        (&material.specular_map, SPECULAR_MAP_TEXTURE_UNIT),
-    ];
-
-    for (texture, texture_unit) in material_texture_maps {
-        let Some(texture) = texture else {
-            let default_texture_obj = renderer_object_store
-                .entry(DEFAULT_TEXTURE_OBJECT_ID)
-                .or_insert_with(|| {
-                    RendererObject::from_raw(
-                        create_default_texture(current_context).into_raw(),
-                        RendererObjectKind::Texture,
-                    )
-                });
-
-            let gl_texture = GlTexture::from_raw(default_texture_obj.as_raw());
-
-            gl_texture.bind_to_texture_unit(current_context, texture_unit);
-
-            continue;
-        };
-
-        let texture_object_id = RendererObjectId::Asset(texture.asset_handle.id());
-
-        let Some(texture_obj) = renderer_object_store.get_texture_obj(&texture_object_id)
-        else {
-            tracing::error!(
-                texture_object_id=?texture_object_id,
-                "Texture object does not exist"
-            );
-            continue;
-        };
-
-        let gl_texture = GlTexture::from_raw(texture_obj.as_raw());
-
-        gl_texture.bind_to_texture_unit(current_context, texture_unit);
-    }
-}
-
 fn set_viewport(
     current_context: &CurrentContextWithFns<'_>,
     position: Vec2<u32>,
@@ -1104,21 +1052,60 @@ fn create_gl_texture(
     Ok(gl_texture)
 }
 
-const VERTEX_GLSL_SHADER_SRC: &str = include_str!("opengl/glsl/vertex.glsl");
-const FRAGMENT_GLSL_SHADER_SRC: &str = include_str!("opengl/glsl/fragment.glsl");
-
-const VERTEX_DATA_GLSL_SHADER_SRC: &str = include_str!("opengl/glsl/vertex_data.glsl");
-const LIGHT_GLSL_SHADER_SRC: &str = include_str!("opengl/glsl/light.glsl");
-
-fn create_default_shader_program(
+fn create_shader_program(
     current_context: &CurrentContextWithFns<'_>,
+    shader_program: &ShaderProgram,
 ) -> Result<GlShaderProgram, CreateShaderError>
 {
+    let shader_program_reflection = shader_program.reflection(0).expect("Not possible");
+
+    let (vs_entry_point_index, vs_entry_point_reflection) = shader_program_reflection
+        .entry_points()
+        .enumerate()
+        .find(|(_, entry_point)| entry_point.stage() == ShaderStage::Vertex)
+        .ok_or_else(|| {
+            CreateShaderError::NoShaderStageEntrypointFound(ShaderStage::Vertex)
+        })?;
+
+    let vertex_shader_entry_point_code = shader_program
+        .get_entry_point_code(vs_entry_point_index.try_into().expect(
+            "Vertex shader entry point index does not fit in 32-bit unsigned int",
+        ))
+        .map_err(|err| CreateShaderError::GetShaderEntryPointCodeFailed {
+            err,
+            stage: ShaderStage::Vertex,
+            entrypoint: vs_entry_point_reflection
+                .name()
+                .map(|name| name.to_string().into())
+                .unwrap_or("(none)".into()),
+        })?;
+
+    let (fs_entry_point_index, fs_entry_point_reflection) = shader_program_reflection
+        .entry_points()
+        .enumerate()
+        .find(|(_, entry_point)| entry_point.stage() == ShaderStage::Fragment)
+        .ok_or_else(|| {
+            CreateShaderError::NoShaderStageEntrypointFound(ShaderStage::Fragment)
+        })?;
+
+    let fragment_shader_entry_point_code = shader_program
+        .get_entry_point_code(fs_entry_point_index.try_into().expect(
+            "Fragment shader entry point index does not fit in 32-bit unsigned int",
+        ))
+        .map_err(|err| CreateShaderError::GetShaderEntryPointCodeFailed {
+            err,
+            stage: ShaderStage::Fragment,
+            entrypoint: fs_entry_point_reflection
+                .name()
+                .map(|name| name.to_string().into())
+                .unwrap_or("(none)".into()),
+        })?;
+
     let vertex_shader = GlShader::new(current_context, ShaderKind::Vertex);
 
     vertex_shader.set_source(
         current_context,
-        &*glsl_preprocess(VERTEX_GLSL_SHADER_SRC, &get_glsl_shader_content)?,
+        &vertex_shader_entry_point_code.as_str().unwrap(),
     )?;
 
     vertex_shader.compile(current_context)?;
@@ -1127,7 +1114,7 @@ fn create_default_shader_program(
 
     fragment_shader.set_source(
         current_context,
-        &*glsl_preprocess(FRAGMENT_GLSL_SHADER_SRC, &get_glsl_shader_content)?,
+        &fragment_shader_entry_point_code.as_str().unwrap(),
     )?;
 
     fragment_shader.compile(current_context)?;
@@ -1145,340 +1132,22 @@ fn create_default_shader_program(
 #[derive(Debug, thiserror::Error)]
 enum CreateShaderError
 {
-    #[error(transparent)]
-    ShaderError(#[from] GlShaderError),
-
-    #[error(transparent)]
-    PreprocessingError(#[from] GlslPreprocessingError),
-}
-
-fn get_glsl_shader_content(path: &Path) -> Result<Vec<u8>, std::io::Error>
-{
-    if path == Path::new("vertex_data.glsl") {
-        return Ok(VERTEX_DATA_GLSL_SHADER_SRC.as_bytes().to_vec());
-    }
-
-    if path == Path::new("light.glsl") {
-        return Ok(LIGHT_GLSL_SHADER_SRC.as_bytes().to_vec());
-    }
-
-    Err(IoError::new(
-        IoErrorKind::NotFound,
-        format!("Content for shader file {} not found", path.display()),
-    ))
-}
-
-fn apply_transformation_matrices(
-    current_context: &CurrentContextWithFns<'_>,
-    transformation: Transformation,
-    gl_shader_program: &mut GlShaderProgram,
-    camera: &Camera,
-    camera_world_pos: &WorldPosition,
-    window_size: &Dimens<u32>,
-)
-{
-    gl_shader_program.set_uniform(
-        current_context,
-        c"model",
-        &opengl_bindings::data_types::Matrix {
-            items: create_transformation_matrix(transformation).items,
-        },
-    );
-
-    let view_matrix = create_view_matrix(camera, &camera_world_pos.position);
-
-    gl_shader_program.set_uniform(
-        current_context,
-        c"view",
-        &opengl_bindings::data_types::Matrix { items: view_matrix.items },
-    );
-
-    #[allow(clippy::cast_precision_loss)]
-    let proj_matrix = match &camera.projection {
-        Projection::Perspective(perspective_proj) => perspective_proj.to_matrix_rh(
-            window_size.width as f32 / window_size.height as f32,
-            ClipVolume::NegOneToOne,
-        ),
-        Projection::Orthographic(orthographic_proj) => orthographic_proj
-            .to_matrix_rh(&camera_world_pos.position, ClipVolume::NegOneToOne),
-    };
-
-    gl_shader_program.set_uniform(
-        current_context,
-        c"projection",
-        &opengl_bindings::data_types::Matrix { items: proj_matrix.items },
-    );
-}
-
-fn set_shader_directional_lights(
-    curr_gl_ctx: &CurrentContextWithFns<'_>,
-    gl_shader_program: &mut GlShaderProgram,
-    directional_lights: &[DirectionalLight],
-)
-{
-    debug_assert!(
-        directional_lights.len() < 64,
-        "Shader cannot handle more than 64 directional lights"
-    );
-
-    for (dir_light_index, dir_light) in directional_lights.iter().enumerate() {
-        let direction: opengl_bindings::data_types::Vec3<_> = dir_light.direction.into();
-
-        gl_shader_program.set_uniform(
-            curr_gl_ctx,
-            &create_light_uniform_name(
-                "directional_lights",
-                dir_light_index,
-                "direction",
-            ),
-            &direction,
-        );
-
-        set_light_phong_uniforms(
-            curr_gl_ctx,
-            gl_shader_program,
-            "directional_lights",
-            dir_light_index,
-            dir_light,
-        );
-    }
-
-    // There probably won't be more than 2147483648 directional lights
-    #[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
-    gl_shader_program.set_uniform(
-        curr_gl_ctx,
-        c"directional_light_cnt",
-        &(directional_lights.len() as i32),
-    );
-}
-
-fn set_shader_point_lights(
-    curr_gl_ctx: &CurrentContextWithFns<'_>,
-    gl_shader_program: &mut GlShaderProgram,
-    point_lights: &[(PointLight, WorldPosition)],
-)
-{
-    debug_assert!(
-        point_lights.len() < 64,
-        "Shader cannot handle more than 64 point lights"
-    );
-
-    for (point_light_index, (point_light, point_light_world_pos)) in
-        point_lights.iter().enumerate()
-    {
-        let pos: opengl_bindings::data_types::Vec3<_> =
-            (point_light_world_pos.position + point_light.local_position).into();
-
-        gl_shader_program.set_uniform(
-            curr_gl_ctx,
-            &create_light_uniform_name("point_lights", point_light_index, "position"),
-            &pos,
-        );
-
-        set_light_phong_uniforms(
-            curr_gl_ctx,
-            gl_shader_program,
-            "point_lights",
-            point_light_index,
-            &*point_light,
-        );
-
-        set_light_attenuation_uniforms(
-            curr_gl_ctx,
-            gl_shader_program,
-            "point_lights",
-            point_light_index,
-            &*point_light,
-        );
-    }
-
-    // There probably won't be more than 2147483648 point lights
-    #[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
-    gl_shader_program.set_uniform(
-        curr_gl_ctx,
-        c"point_light_cnt",
-        &(point_lights.len() as i32),
-    );
-}
-
-fn set_shader_material(
-    curr_gl_ctx: &CurrentContextWithFns<'_>,
-    material: &Material,
-    material_flags: &MaterialFlags,
-    global_light: &GlobalLight,
-    gl_shader_program: &mut GlShaderProgram,
-    camera_world_pos: &WorldPosition,
-)
-{
-    let ambient: opengl_bindings::data_types::Vec3<_> =
-        Vec3::from(if material_flags.use_ambient_color {
-            material.ambient.clone()
-        } else {
-            global_light.ambient.clone()
-        })
-        .into();
-
-    gl_shader_program.set_uniform(curr_gl_ctx, c"material.ambient", &ambient);
-
-    let diffuse: opengl_bindings::data_types::Vec3<_> =
-        Vec3::from(material.diffuse.clone()).into();
-
-    gl_shader_program.set_uniform(curr_gl_ctx, c"material.diffuse", &diffuse);
-
-    let specular: opengl_bindings::data_types::Vec3<_> =
-        Vec3::from(material.specular.clone()).into();
-
-    #[allow(clippy::cast_possible_wrap)]
-    gl_shader_program.set_uniform(curr_gl_ctx, c"material.specular", &specular);
-
-    #[allow(clippy::cast_possible_wrap)]
-    gl_shader_program.set_uniform(
-        curr_gl_ctx,
-        c"material.ambient_map",
-        &(AMBIENT_MAP_TEXTURE_UNIT as i32),
-    );
-
-    #[allow(clippy::cast_possible_wrap)]
-    gl_shader_program.set_uniform(
-        curr_gl_ctx,
-        c"material.diffuse_map",
-        &(DIFFUSE_MAP_TEXTURE_UNIT as i32),
-    );
-
-    #[allow(clippy::cast_possible_wrap)]
-    gl_shader_program.set_uniform(
-        curr_gl_ctx,
-        c"material.specular_map",
-        &(SPECULAR_MAP_TEXTURE_UNIT as i32),
-    );
-
-    gl_shader_program.set_uniform(
-        curr_gl_ctx,
-        c"material.shininess",
-        &material.shininess,
-    );
-
-    let view_pos: opengl_bindings::data_types::Vec3<_> = camera_world_pos.position.into();
-
-    gl_shader_program.set_uniform(curr_gl_ctx, c"view_pos", &view_pos);
-}
-
-fn set_light_attenuation_uniforms(
-    current_context: &CurrentContextWithFns<'_>,
-    gl_shader_program: &mut GlShaderProgram,
-    light_array: &str,
-    light_index: usize,
-    light: &PointLight,
-)
-{
-    gl_shader_program.set_uniform(
-        current_context,
-        &create_light_uniform_name(
-            light_array,
-            light_index,
-            "attenuation_props.constant",
-        ),
-        &light.attenuation_params.constant,
-    );
-
-    gl_shader_program.set_uniform(
-        current_context,
-        &create_light_uniform_name(light_array, light_index, "attenuation_props.linear"),
-        &light.attenuation_params.linear,
-    );
-
-    gl_shader_program.set_uniform(
-        current_context,
-        &create_light_uniform_name(
-            light_array,
-            light_index,
-            "attenuation_props.quadratic",
-        ),
-        &light.attenuation_params.quadratic,
-    );
-}
-
-fn set_light_phong_uniforms(
-    current_context: &CurrentContextWithFns<'_>,
-    gl_shader_program: &mut GlShaderProgram,
-    light_array: &str,
-    light_index: usize,
-    light: &impl Light,
-)
-{
-    gl_shader_program.set_uniform(
-        current_context,
-        &create_light_uniform_name(light_array, light_index, "phong.diffuse"),
-        &opengl_bindings::data_types::Vec3 {
-            x: light.diffuse().red,
-            y: light.diffuse().green,
-            z: light.diffuse().blue,
-        },
-    );
-
-    gl_shader_program.set_uniform(
-        current_context,
-        &create_light_uniform_name(light_array, light_index, "phong.specular"),
-        &opengl_bindings::data_types::Vec3 {
-            x: light.specular().red,
-            y: light.specular().green,
-            z: light.specular().blue,
-        },
-    );
-}
-
-trait Light
-{
-    fn diffuse(&self) -> &Color<f32>;
-    fn specular(&self) -> &Color<f32>;
-}
-
-impl Light for PointLight
-{
-    fn diffuse(&self) -> &Color<f32>
-    {
-        &self.diffuse
-    }
-
-    fn specular(&self) -> &Color<f32>
-    {
-        &self.specular
-    }
-}
-
-impl Light for DirectionalLight
-{
-    fn diffuse(&self) -> &Color<f32>
-    {
-        &self.diffuse
-    }
-
-    fn specular(&self) -> &Color<f32>
+    #[error(
+        "Failed to get code of shader program entry point {entrypoint} of stage {stage:?}"
+    )]
+    GetShaderEntryPointCodeFailed
     {
-        &self.specular
-    }
-}
-
-fn create_light_uniform_name(
-    light_array: &str,
-    light_index: usize,
-    light_field: &str,
-) -> CString
-{
-    unsafe {
-        CString::from_vec_with_nul_unchecked(
-            format!("{light_array}[{light_index}].{light_field}\0").into(),
-        )
-    }
-}
-
-fn create_view_matrix(camera: &Camera, camera_pos: &Vec3<f32>) -> Matrix<f32, 4, 4>
-{
-    let mut view = Matrix::new();
+        #[source]
+        err: ShaderError,
+        stage: ShaderStage,
+        entrypoint: Cow<'static, str>,
+    },
 
-    view.look_at(&camera_pos, &camera.target, &camera.global_up);
+    #[error("No entrypoint was found for shader stage {0:?}")]
+    NoShaderStageEntrypointFound(ShaderStage),
 
-    view
+    #[error(transparent)]
+    ShaderError(#[from] GlShaderError),
 }
 
 #[tracing::instrument(skip_all)]
@@ -1524,23 +1193,6 @@ fn opengl_debug_message_cb(
     };
 }
 
-#[derive(Debug)]
-struct Transformation
-{
-    position: Vec3<f32>,
-    scale: Vec3<f32>,
-}
-
-fn create_transformation_matrix(transformation: Transformation) -> Matrix<f32, 4, 4>
-{
-    let mut matrix = Matrix::new_identity();
-
-    matrix.translate(&transformation.position);
-    matrix.scale(&transformation.scale);
-
-    matrix
-}
-
 #[inline]
 fn texture_wrapping_to_gl(texture_wrapping: TextureWrapping) -> GlTextureWrapping
 {
@@ -1569,7 +1221,8 @@ impl<Value: ReprC + Copy> From<Vec2<Value>> for opengl_bindings::data_types::Vec
     }
 }
 
-impl<Value: ReprC + Copy> From<Vec3<Value>> for opengl_bindings::data_types::Vec3<Value>
+impl<Value: ReprC + IntoBytes + Copy> From<Vec3<Value>>
+    for opengl_bindings::data_types::Vec3<Value>
 {
     fn from(vec3: Vec3<Value>) -> Self
     {
@@ -1577,6 +1230,15 @@ impl<Value: ReprC + Copy> From<Vec3<Value>> for opengl_bindings::data_types::Vec
     }
 }
 
+impl<Value: ReprC + Copy> From<Matrix<Value, 4, 4>>
+    for opengl_bindings::data_types::Matrix<Value, 4, 4>
+{
+    fn from(matrix: Matrix<Value, 4, 4>) -> Self
+    {
+        Self { items: matrix.items }
+    }
+}
+
 impl<Value: Copy> From<Dimens<Value>> for opengl_bindings::data_types::Dimens<Value>
 {
     fn from(dimens: Dimens<Value>) -> Self
@@ -1611,3 +1273,20 @@ impl From<crate::draw_flags::PolygonModeFace> for opengl_bindings::misc::Polygon
         }
     }
 }
+
+#[derive(Debug, IntoBytes, Immutable)]
+#[repr(C)]
+pub struct CF32Vec3
+{
+    x: f32,
+    y: f32,
+    z: f32,
+}
+
+impl From<Vec3<f32>> for CF32Vec3
+{
+    fn from(src: Vec3<f32>) -> Self
+    {
+        Self { x: src.x, y: src.y, z: src.z }
+    }
+}