refactor(engine): use OpenGL DSA functions

1 files changed, 85 insertions, 121 deletions

diff --git a/engine/src/renderer/mod.rs b/engine/src/renderer/mod.rs
index 9b4acb4..617c60f 100644
--- a/engine/src/renderer/mod.rs
+++ b/engine/src/renderer/mod.rs
@@ -16,13 +16,7 @@ use crate::lighting::LightSource;
 use crate::material::Material;
 use crate::matrix::Matrix;
 use crate::mesh::Mesh;
-use crate::opengl::buffer::{
-    ArrayKind as ArrayBufferKind,
-    Buffer,
-    ElementArrayKind as ElementArrayBufferKind,
-    Usage as BufferUsage,
-};
-use crate::opengl::currently_bound::CurrentlyBound;
+use crate::opengl::buffer::{Buffer, Usage as BufferUsage};
 #[cfg(feature = "debug")]
 use crate::opengl::debug::{MessageSeverity, MessageSource, MessageType};
 use crate::opengl::shader::{
@@ -35,14 +29,18 @@ use crate::opengl::texture::{
     Texture as GlTexture,
     TextureUnit,
 };
-use crate::opengl::vertex_array::{PrimitiveKind, VertexArray};
+use crate::opengl::vertex_array::{
+    DataType as VertexArrayDataType,
+    PrimitiveKind,
+    VertexArray,
+};
 use crate::opengl::{clear_buffers, enable, BufferClearMask, Capability};
 use crate::projection::new_perspective;
 use crate::shader::Program as ShaderProgram;
 use crate::texture::{Id as TextureId, List as TextureMap, Texture};
 use crate::transform::Transform;
 use crate::vector::{Vec2, Vec3};
-use crate::vertex::Vertex;
+use crate::vertex::{AttributeComponentType, Vertex};
 use crate::window::Window;
 
 #[derive(Debug, Default)]
@@ -124,45 +122,38 @@ fn render(
 
     clear_buffers(BufferClearMask::COLOR | BufferClearMask::DEPTH);
 
-    for (mesh, texture_map, shader_program, material, transform) in &query {
+    for (mesh, texture_list, shader_program, material, transform) in &query {
         let shader_program = gl_shader_programs
             .entry(shader_program.u64_hash())
             .or_insert_with(|| create_gl_shader_program(&shader_program).unwrap());
 
-        shader_program.activate(|shader_program_curr_bound| {
-            apply_transformation_matrices(
-                &transform,
-                shader_program,
-                &camera,
-                window.size().expect("Failed to get window size"),
-                &shader_program_curr_bound,
-            );
+        apply_transformation_matrices(
+            &transform,
+            shader_program,
+            &camera,
+            window.size().expect("Failed to get window size"),
+        );
 
-            apply_light(
-                &material,
-                shader_program,
-                light_source.as_deref(),
-                &camera,
-                &shader_program_curr_bound,
-            );
+        apply_light(&material, shader_program, light_source.as_deref(), &camera);
 
-            for texture in &texture_map.list {
-                let gl_texture = gl_textures
-                    .entry(texture.id())
-                    .or_insert_with(|| create_gl_texture(texture));
+        for texture in &texture_list.list {
+            let gl_texture = gl_textures
+                .entry(texture.id())
+                .or_insert_with(|| create_gl_texture(texture));
 
-                let texture_unit = TextureUnit::from_texture_id(texture.id())
-                    .unwrap_or_else(|| {
-                        panic!("Texture id {} is a invalid texture unit", texture.id());
-                    });
+            let texture_unit =
+                TextureUnit::from_texture_id(texture.id()).unwrap_or_else(|| {
+                    panic!("Texture id {} is a invalid texture unit", texture.id());
+                });
 
-                set_active_texture_unit(texture_unit);
+            set_active_texture_unit(texture_unit);
 
-                gl_texture.bind(|_| {});
-            }
+            gl_texture.bind();
+        }
 
-            draw_mesh(&mesh);
-        });
+        shader_program.activate();
+
+        draw_mesh(&mesh);
     }
 }
 
@@ -201,37 +192,24 @@ fn draw_mesh(mesh: &Mesh)
     // should be rethinked
     let renderable = Renderable::new(mesh.vertices(), mesh.indices());
 
-    renderable.vertex_arr.bind(|vert_arr_curr_bound| {
-        if let Some(index_info) = &renderable.index_info {
-            VertexArray::draw_elements(
-                &vert_arr_curr_bound,
-                PrimitiveKind::Triangles,
-                0,
-                index_info.cnt,
-            );
-        } else {
-            VertexArray::draw_arrays(
-                &vert_arr_curr_bound,
-                PrimitiveKind::Triangles,
-                0,
-                3,
-            );
-        }
-    });
+    renderable.vertex_arr.bind();
+
+    if let Some(index_info) = &renderable.index_info {
+        VertexArray::draw_elements(PrimitiveKind::Triangles, 0, index_info.cnt);
+    } else {
+        VertexArray::draw_arrays(PrimitiveKind::Triangles, 0, 3);
+    }
 }
 
 fn create_gl_texture(texture: &Texture) -> GlTexture
 {
-    let gl_texture = GlTexture::new();
-
-    gl_texture.bind(|texture_curr_bound| {
-        GlTexture::generate(
-            &texture_curr_bound,
-            texture.dimensions(),
-            texture.image().as_bytes(),
-            texture.pixel_data_format(),
-        );
-    });
+    let mut gl_texture = GlTexture::new();
+
+    gl_texture.generate(
+        *texture.dimensions(),
+        texture.image().as_bytes(),
+        texture.pixel_data_format(),
+    );
 
     gl_texture.apply_properties(texture.properties());
 
@@ -272,7 +250,7 @@ struct Renderable
     vertex_arr: VertexArray,
 
     /// Vertex and index buffer has to live as long as the vertex array
-    _vertex_buffer: Buffer<Vertex, ArrayBufferKind>,
+    _vertex_buffer: Buffer<Vertex>,
     index_info: Option<IndexInfo>,
 }
 
@@ -280,31 +258,46 @@ impl Renderable
 {
     fn new(vertices: &[Vertex], indices: Option<&[u32]>) -> Self
     {
-        let vertex_arr = VertexArray::new();
-        let vertex_buffer = Buffer::new();
+        let mut vertex_arr = VertexArray::new();
+        let mut vertex_buffer = Buffer::new();
 
         let mut index_info = None;
 
-        vertex_arr.bind(|vert_arr_curr_bound| {
-            vertex_buffer.bind(|vert_buf_curr_bound| {
-                Buffer::store(&vert_buf_curr_bound, vertices, BufferUsage::Static);
+        vertex_buffer.store(vertices, BufferUsage::Static);
 
-                VertexArray::configure_attrs(&vert_arr_curr_bound, &vert_buf_curr_bound);
-            });
+        vertex_arr.bind_vertex_buffer(0, &vertex_buffer, 0);
 
-            if let Some(indices) = indices {
-                let new_index_buffer = Buffer::new();
+        let mut offset = 0u32;
 
-                new_index_buffer.bind(|index_buf_curr_bound| {
-                    Buffer::store(&index_buf_curr_bound, indices, BufferUsage::Static);
-                });
+        for attrib in Vertex::attrs() {
+            vertex_arr.enable_attrib(attrib.index);
 
-                index_info = Some(IndexInfo {
-                    _buffer: new_index_buffer,
-                    cnt: indices.len().try_into().unwrap(),
-                });
-            }
-        });
+            vertex_arr.set_attrib_format(
+                attrib.index,
+                match attrib.component_type {
+                    AttributeComponentType::Float => VertexArrayDataType::Float,
+                },
+                false,
+                offset,
+            );
+
+            vertex_arr.set_attrib_vertex_buf_binding(attrib.index, 0);
+
+            offset += attrib.component_size * attrib.component_cnt as u32;
+        }
+
+        if let Some(indices) = indices {
+            let mut index_buffer = Buffer::new();
+
+            index_buffer.store(indices, BufferUsage::Static);
+
+            vertex_arr.bind_element_buffer(&index_buffer);
+
+            index_info = Some(IndexInfo {
+                _buffer: index_buffer,
+                cnt: indices.len().try_into().unwrap(),
+            });
+        }
 
         Self {
             vertex_arr,
@@ -316,25 +309,16 @@ impl Renderable
 
 fn apply_transformation_matrices(
     transform: &Transform,
-    gl_shader_program: &GlShaderProgram,
+    gl_shader_program: &mut GlShaderProgram,
     camera: &Camera,
     window_size: Dimens<u32>,
-    shader_program_curr_bound: &CurrentlyBound<GlShaderProgram>,
 )
 {
-    gl_shader_program.set_uniform_matrix_4fv(
-        shader_program_curr_bound,
-        cstr!("model"),
-        &transform.as_matrix(),
-    );
+    gl_shader_program.set_uniform_matrix_4fv(cstr!("model"), &transform.as_matrix());
 
     let view = create_view(camera);
 
-    gl_shader_program.set_uniform_matrix_4fv(
-        shader_program_curr_bound,
-        cstr!("view"),
-        &view,
-    );
+    gl_shader_program.set_uniform_matrix_4fv(cstr!("view"), &view);
 
     #[allow(clippy::cast_precision_loss)]
     let projection = new_perspective(
@@ -344,23 +328,17 @@ fn apply_transformation_matrices(
         0.1,
     );
 
-    gl_shader_program.set_uniform_matrix_4fv(
-        shader_program_curr_bound,
-        cstr!("projection"),
-        &projection,
-    );
+    gl_shader_program.set_uniform_matrix_4fv(cstr!("projection"), &projection);
 }
 
 fn apply_light(
     material: &Material,
-    gl_shader_program: &GlShaderProgram,
+    gl_shader_program: &mut GlShaderProgram,
     light_source: Option<&LightSource>,
     camera: &Camera,
-    shader_program_curr_bound: &CurrentlyBound<GlShaderProgram>,
 )
 {
     gl_shader_program.set_uniform_vec_3fv(
-        shader_program_curr_bound,
         cstr!("light.position"),
         &light_source.map_or_else(Vec3::default, |light_source| {
             light_source.position().clone()
@@ -368,7 +346,6 @@ fn apply_light(
     );
 
     gl_shader_program.set_uniform_vec_3fv(
-        shader_program_curr_bound,
         cstr!("light.ambient"),
         &light_source
             .map_or(Color::WHITE_F32, |light_source| {
@@ -378,7 +355,6 @@ fn apply_light(
     );
 
     gl_shader_program.set_uniform_vec_3fv(
-        shader_program_curr_bound,
         cstr!("light.diffuse"),
         &light_source
             .map_or(Color::WHITE_F32, |light_source| {
@@ -388,7 +364,6 @@ fn apply_light(
     );
 
     gl_shader_program.set_uniform_vec_3fv(
-        shader_program_curr_bound,
         cstr!("light.specular"),
         &light_source
             .map_or(Color::WHITE_F32, |light_source| {
@@ -399,36 +374,25 @@ fn apply_light(
 
     #[allow(clippy::cast_possible_wrap)]
     gl_shader_program.set_uniform_1i(
-        shader_program_curr_bound,
         cstr!("material.ambient"),
         material.ambient_map().into_inner() as i32,
     );
 
     #[allow(clippy::cast_possible_wrap)]
     gl_shader_program.set_uniform_1i(
-        shader_program_curr_bound,
         cstr!("material.diffuse"),
         material.diffuse_map().into_inner() as i32,
     );
 
     #[allow(clippy::cast_possible_wrap)]
     gl_shader_program.set_uniform_1i(
-        shader_program_curr_bound,
         cstr!("material.specular"),
         material.specular_map().into_inner() as i32,
     );
 
-    gl_shader_program.set_uniform_1fv(
-        shader_program_curr_bound,
-        cstr!("material.shininess"),
-        material.shininess(),
-    );
+    gl_shader_program.set_uniform_1fv(cstr!("material.shininess"), material.shininess());
 
-    gl_shader_program.set_uniform_vec_3fv(
-        shader_program_curr_bound,
-        cstr!("view_pos"),
-        &camera.position,
-    );
+    gl_shader_program.set_uniform_vec_3fv(cstr!("view_pos"), &camera.position);
 }
 
 fn create_view(camera: &Camera) -> Matrix<f32, 4, 4>
@@ -486,6 +450,6 @@ fn opengl_debug_message_cb(
 #[derive(Debug)]
 struct IndexInfo
 {
-    _buffer: Buffer<u32, ElementArrayBufferKind>,
+    _buffer: Buffer<u32>,
     cnt: u32,
 }