refactor(engine): use OpenGL DSA functions

9 files changed, 263 insertions, 342 deletions

diff --git a/engine/src/opengl/buffer.rs b/engine/src/opengl/buffer.rs
index 1622804..68a75fb 100644
--- a/engine/src/opengl/buffer.rs
+++ b/engine/src/opengl/buffer.rs
@@ -1,62 +1,50 @@
 use std::marker::PhantomData;
 use std::mem::size_of_val;
 
-use crate::opengl::currently_bound::CurrentlyBound;
-
 #[derive(Debug)]
-pub struct Buffer<Item, ModeT: Mode>
+pub struct Buffer<Item>
 {
     buf: gl::types::GLuint,
-    _pd: PhantomData<(Item, ModeT)>,
+    _pd: PhantomData<Item>,
 }
 
-impl<Item, ModeT: Mode> Buffer<Item, ModeT>
+impl<Item> Buffer<Item>
 {
     pub fn new() -> Self
     {
         let mut buffer = gl::types::GLuint::default();
 
         unsafe {
-            gl::GenBuffers(1, &mut buffer);
+            gl::CreateBuffers(1, &mut buffer);
         };
 
         Self { buf: buffer, _pd: PhantomData }
     }
 
-    #[allow(clippy::inline_always)]
-    #[inline(always)]
-    pub fn bind(&self, cb: impl FnOnce(CurrentlyBound<'_, Self>))
-    {
-        unsafe {
-            gl::BindBuffer(ModeT::GL_ENUM, self.buf);
-        }
-
-        // SAFETY: The buffer object is bound above
-        let currently_bound = unsafe { CurrentlyBound::new() };
-
-        cb(currently_bound);
-    }
-
     /// Stores items in the currently bound buffer.
-    pub fn store(_currently_bound: &CurrentlyBound<Self>, items: &[Item], usage: Usage)
+    pub fn store(&mut self, items: &[Item], usage: Usage)
     {
         unsafe {
             #[allow(clippy::cast_possible_wrap)]
-            gl::BufferData(
-                ModeT::GL_ENUM,
+            gl::NamedBufferData(
+                self.buf,
                 size_of_val(items) as gl::types::GLsizeiptr,
                 items.as_ptr().cast(),
                 usage.into_gl(),
             );
         }
     }
+
+    pub fn object(&self) -> gl::types::GLuint
+    {
+        self.buf
+    }
 }
 
-impl<Item, ModeT: Mode> Drop for Buffer<Item, ModeT>
+impl<Item> Drop for Buffer<Item>
 {
     fn drop(&mut self)
     {
-        #[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
         unsafe {
             gl::DeleteBuffers(1, &self.buf);
         }
@@ -89,28 +77,3 @@ impl Usage
         }
     }
 }
-
-/// Buffer mode.
-pub trait Mode
-{
-    #[doc(hidden)]
-    const GL_ENUM: gl::types::GLenum;
-}
-
-/// Array buffer kind.
-#[derive(Debug)]
-pub struct ArrayKind;
-
-impl Mode for ArrayKind
-{
-    const GL_ENUM: gl::types::GLenum = gl::ARRAY_BUFFER;
-}
-
-/// Element array buffer kind.
-#[derive(Debug)]
-pub struct ElementArrayKind;
-
-impl Mode for ElementArrayKind
-{
-    const GL_ENUM: gl::types::GLenum = gl::ELEMENT_ARRAY_BUFFER;
-}
diff --git a/engine/src/opengl/currently_bound.rs b/engine/src/opengl/currently_bound.rs
deleted file mode 100644
index be01841..0000000
--- a/engine/src/opengl/currently_bound.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-use std::marker::PhantomData;
-
-/// A token signifying a OpenGL object is currently bound.
-pub struct CurrentlyBound<'token, Object>
-{
-    _token: PhantomData<&'token Object>,
-}
-
-impl<'token, Object> CurrentlyBound<'token, Object>
-{
-    /// Returns a new `CurrentlyBound`.
-    ///
-    /// # Safety
-    /// A object must actually be currently bound. Otherwise, UB can occur.
-    #[must_use]
-    pub unsafe fn new() -> Self
-    {
-        Self { _token: PhantomData }
-    }
-}
diff --git a/engine/src/opengl/mod.rs b/engine/src/opengl/mod.rs
index 6898c49..edf6372 100644
--- a/engine/src/opengl/mod.rs
+++ b/engine/src/opengl/mod.rs
@@ -4,7 +4,6 @@ use crate::data_types::dimens::Dimens;
 use crate::vector::Vec2;
 
 pub mod buffer;
-pub mod currently_bound;
 pub mod shader;
 pub mod texture;
 pub mod vertex_array;
diff --git a/engine/src/opengl/shader.rs b/engine/src/opengl/shader.rs
index 2312adc..070897e 100644
--- a/engine/src/opengl/shader.rs
+++ b/engine/src/opengl/shader.rs
@@ -2,7 +2,6 @@ use std::ffi::CStr;
 use std::ptr::null_mut;
 
 use crate::matrix::Matrix;
-use crate::opengl::currently_bound::CurrentlyBound;
 use crate::shader::Kind;
 use crate::vector::Vec3;
 
@@ -146,65 +145,56 @@ impl Program
         Ok(())
     }
 
-    pub fn activate<Ret>(&self, cb: impl FnOnce(CurrentlyBound<'_, Self>) -> Ret) -> Ret
+    pub fn activate(&self)
     {
         unsafe {
             gl::UseProgram(self.program);
         }
-
-        // SAFETY: The shader program object is bound above
-        let currently_bound = unsafe { CurrentlyBound::new() };
-
-        cb(currently_bound)
     }
 
-    pub fn set_uniform_matrix_4fv(
-        &self,
-        _: &CurrentlyBound<Self>,
-        name: &CStr,
-        matrix: &Matrix<f32, 4, 4>,
-    )
+    pub fn set_uniform_matrix_4fv(&mut self, name: &CStr, matrix: &Matrix<f32, 4, 4>)
     {
         let uniform_location =
             unsafe { gl::GetUniformLocation(self.program, name.as_ptr().cast()) };
 
         unsafe {
-            gl::UniformMatrix4fv(uniform_location, 1, gl::FALSE, matrix.as_ptr());
+            gl::ProgramUniformMatrix4fv(
+                self.program,
+                uniform_location,
+                1,
+                gl::FALSE,
+                matrix.as_ptr(),
+            );
         }
     }
 
-    pub fn set_uniform_vec_3fv(
-        &self,
-        _: &CurrentlyBound<Self>,
-        name: &CStr,
-        vec: &Vec3<f32>,
-    )
+    pub fn set_uniform_vec_3fv(&mut self, name: &CStr, vec: &Vec3<f32>)
     {
         let uniform_location =
             unsafe { gl::GetUniformLocation(self.program, name.as_ptr().cast()) };
 
         unsafe {
-            gl::Uniform3fv(uniform_location, 1, vec.as_ptr());
+            gl::ProgramUniform3fv(self.program, uniform_location, 1, vec.as_ptr());
         }
     }
 
-    pub fn set_uniform_1fv(&self, _: &CurrentlyBound<Self>, name: &CStr, num: f32)
+    pub fn set_uniform_1fv(&mut self, name: &CStr, num: f32)
     {
         let uniform_location =
             unsafe { gl::GetUniformLocation(self.program, name.as_ptr().cast()) };
 
         unsafe {
-            gl::Uniform1fv(uniform_location, 1, &num);
+            gl::ProgramUniform1fv(self.program, uniform_location, 1, &num);
         }
     }
 
-    pub fn set_uniform_1i(&self, _: &CurrentlyBound<Self>, name: &CStr, num: i32)
+    pub fn set_uniform_1i(&mut self, name: &CStr, num: i32)
     {
         let uniform_location =
             unsafe { gl::GetUniformLocation(self.program, name.as_ptr().cast()) };
 
         unsafe {
-            gl::Uniform1i(uniform_location, num);
+            gl::ProgramUniform1i(self.program, uniform_location, num);
         }
     }
 
diff --git a/engine/src/opengl/texture.rs b/engine/src/opengl/texture.rs
index 5d12729..074ade7 100644
--- a/engine/src/opengl/texture.rs
+++ b/engine/src/opengl/texture.rs
@@ -1,8 +1,5 @@
-use std::ptr::null;
-
-use crate::opengl::currently_bound::CurrentlyBound;
+use crate::data_types::dimens::Dimens;
 use crate::texture::{Id, Properties};
-use crate::vector::Vec2;
 
 #[derive(Debug)]
 pub struct Texture
@@ -17,88 +14,73 @@ impl Texture
         let mut texture = gl::types::GLuint::default();
 
         unsafe {
-            gl::GenTextures(1, &mut texture);
+            gl::CreateTextures(gl::TEXTURE_2D, 1, &mut texture);
         };
 
         Self { texture }
     }
 
-    pub fn bind(&self, cb: impl FnOnce(CurrentlyBound<'_, Self>))
+    pub fn bind(&self)
     {
         unsafe {
             gl::BindTexture(gl::TEXTURE_2D, self.texture);
         }
-
-        // SAFETY: The buffer object is bound above
-        let currently_bound = unsafe { CurrentlyBound::new() };
-
-        cb(currently_bound);
     }
 
     pub fn generate(
-        curr_bound: &CurrentlyBound<Self>,
-        dimens: &Vec2<u32>,
+        &mut self,
+        dimens: Dimens<u32>,
         data: &[u8],
         pixel_data_format: PixelDataFormat,
     )
     {
-        Self::alloc_image(curr_bound, pixel_data_format, dimens, Some(data));
+        self.alloc_image(pixel_data_format, dimens, data);
 
         unsafe {
-            gl::GenerateMipmap(gl::TEXTURE_2D);
+            gl::GenerateTextureMipmap(self.texture);
         }
     }
 
-    pub fn apply_properties(&self, properties: &Properties)
+    pub fn apply_properties(&mut self, properties: &Properties)
     {
-        self.bind(|texture_curr_bound| {
-            Texture::set_wrap(&texture_curr_bound, properties.wrap);
-
-            Texture::set_magnifying_filter(
-                &texture_curr_bound,
-                properties.magnifying_filter,
-            );
-
-            Texture::set_minifying_filter(
-                &texture_curr_bound,
-                properties.minifying_filter,
-            );
-        });
+        self.set_wrap(properties.wrap);
+        self.set_magnifying_filter(properties.magnifying_filter);
+        self.set_minifying_filter(properties.minifying_filter);
     }
 
-    pub fn set_wrap(_: &CurrentlyBound<Self>, wrapping: Wrapping)
+    pub fn set_wrap(&mut self, wrapping: Wrapping)
     {
         let wrapping_gl = wrapping.to_gl();
 
         #[allow(clippy::cast_possible_wrap)]
         unsafe {
-            gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_WRAP_S, wrapping_gl as i32);
-            gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_WRAP_T, wrapping_gl as i32);
+            gl::TextureParameteri(self.texture, gl::TEXTURE_WRAP_S, wrapping_gl as i32);
+            gl::TextureParameteri(self.texture, gl::TEXTURE_WRAP_T, wrapping_gl as i32);
         }
     }
 
-    pub fn set_magnifying_filter(_: &CurrentlyBound<Self>, filtering: Filtering)
+    pub fn set_magnifying_filter(&mut self, filtering: Filtering)
     {
         let filtering_gl = filtering.to_gl();
 
         #[allow(clippy::cast_possible_wrap)]
         unsafe {
-            gl::TexParameteri(
-                gl::TEXTURE_2D,
+            gl::TextureParameteri(
+                self.texture,
                 gl::TEXTURE_MAG_FILTER,
                 filtering_gl as i32,
             );
         }
     }
 
-    pub fn set_minifying_filter(_: &CurrentlyBound<Self>, filtering: Filtering)
+    pub fn set_minifying_filter(&mut self, filtering: Filtering)
     {
         let filtering_gl = filtering.to_gl();
 
         #[allow(clippy::cast_possible_wrap)]
         unsafe {
-            gl::TexParameteri(
-                gl::TEXTURE_2D,
+            gl::TextureParameteri(
+                self.texture,
                 gl::TEXTURE_MIN_FILTER,
                 filtering_gl as i32,
             );
@@ -106,24 +88,33 @@ impl Texture
     }
 
     fn alloc_image(
-        _: &CurrentlyBound<Self>,
+        &mut self,
         pixel_data_format: PixelDataFormat,
-        dimens: &Vec2<u32>,
-        data: Option<&[u8]>,
+        dimens: Dimens<u32>,
+        data: &[u8],
     )
     {
         unsafe {
             #[allow(clippy::cast_possible_wrap)]
-            gl::TexImage2D(
-                gl::TEXTURE_2D,
+            gl::TextureStorage2D(
+                self.texture,
+                1,
+                pixel_data_format.to_sized_internal_format(),
+                dimens.width as i32,
+                dimens.height as i32,
+            );
+
+            #[allow(clippy::cast_possible_wrap)]
+            gl::TextureSubImage2D(
+                self.texture,
+                0,
                 0,
-                pixel_data_format.to_gl() as i32,
-                dimens.x as i32,
-                dimens.y as i32,
                 0,
-                pixel_data_format.to_gl(),
+                dimens.width as i32,
+                dimens.height as i32,
+                pixel_data_format.to_format(),
                 gl::UNSIGNED_BYTE,
-                data.map_or_else(null, |data| data.as_ptr().cast()),
+                data.as_ptr().cast(),
             );
         }
     }
@@ -184,17 +175,25 @@ impl Filtering
 #[derive(Debug, Clone, Copy)]
 pub enum PixelDataFormat
 {
-    Rgb,
-    Rgba,
+    Rgb8,
+    Rgba8,
 }
 
 impl PixelDataFormat
 {
-    fn to_gl(self) -> gl::types::GLenum
+    fn to_sized_internal_format(self) -> gl::types::GLenum
+    {
+        match self {
+            Self::Rgb8 => gl::RGB8,
+            Self::Rgba8 => gl::RGBA8,
+        }
+    }
+
+    fn to_format(self) -> gl::types::GLenum
     {
         match self {
-            Self::Rgb => gl::RGB,
-            Self::Rgba => gl::RGBA,
+            Self::Rgb8 => gl::RGB,
+            Self::Rgba8 => gl::RGBA,
         }
     }
 }
diff --git a/engine/src/opengl/vertex_array.rs b/engine/src/opengl/vertex_array.rs
index 6b6065c..e1e1a15 100644
--- a/engine/src/opengl/vertex_array.rs
+++ b/engine/src/opengl/vertex_array.rs
@@ -1,10 +1,10 @@
 use std::mem::size_of;
 
-use crate::opengl::buffer::{ArrayKind as ArrayBufferKind, Buffer};
-use crate::opengl::currently_bound::CurrentlyBound;
-use crate::vertex::{Attribute, AttributeComponentType, Vertex};
+use crate::opengl::buffer::Buffer;
+use crate::vertex::Vertex;
 
-const VERTEX_STRIDE: usize = size_of::<Vertex>();
+#[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
+const VERTEX_STRIDE: i32 = size_of::<Vertex>() as i32;
 
 #[derive(Debug)]
 pub struct VertexArray
@@ -19,19 +19,14 @@ impl VertexArray
         let mut array = 0;
 
         unsafe {
-            gl::GenVertexArrays(1, &mut array);
+            gl::CreateVertexArrays(1, &mut array);
         }
 
         Self { array }
     }
 
     /// Draws the currently bound vertex array.
-    pub fn draw_arrays(
-        _currently_bound: &CurrentlyBound<Self>,
-        primitive_kind: PrimitiveKind,
-        start_index: u32,
-        cnt: u32,
-    )
+    pub fn draw_arrays(primitive_kind: PrimitiveKind, start_index: u32, cnt: u32)
     {
         unsafe {
             #[allow(clippy::cast_possible_wrap)]
@@ -44,12 +39,7 @@ impl VertexArray
     }
 
     /// Draws the currently bound vertex array.
-    pub fn draw_elements(
-        _currently_bound: &CurrentlyBound<Self>,
-        primitive_kind: PrimitiveKind,
-        offset: u32,
-        cnt: u32,
-    )
+    pub fn draw_elements(primitive_kind: PrimitiveKind, offset: u32, cnt: u32)
     {
         unsafe {
             #[allow(clippy::cast_possible_wrap)]
@@ -62,64 +52,78 @@ impl VertexArray
         }
     }
 
-    pub fn configure_attrs(
-        _currently_bound: &CurrentlyBound<Self>,
-        _vert_buf_curr_bound: &CurrentlyBound<Buffer<Vertex, ArrayBufferKind>>,
-    )
+    pub fn bind_element_buffer(&mut self, element_buffer: &Buffer<u32>)
     {
-        let mut offset = 0;
-
-        for attr in Vertex::attrs() {
-            Self::vertex_attrib_ptr(attr, offset);
-
-            Self::enable_vertex_attrib_array(attr.index);
-
-            offset += attr.component_size * attr.component_cnt as usize;
+        unsafe {
+            gl::VertexArrayElementBuffer(self.array, element_buffer.object());
         }
     }
 
-    #[allow(clippy::inline_always)]
-    #[inline(always)]
-    pub fn bind(&self, cb: impl FnOnce(CurrentlyBound<'_, Self>))
+    pub fn bind_vertex_buffer(
+        &mut self,
+        binding_index: u32,
+        vertex_buffer: &Buffer<Vertex>,
+        offset: isize,
+    )
     {
-        unsafe { gl::BindVertexArray(self.array) }
-
-        // SAFETY: A vertex array object is currently bound
-        let currently_bound = unsafe { CurrentlyBound::new() };
+        unsafe {
+            gl::VertexArrayVertexBuffer(
+                self.array,
+                binding_index,
+                vertex_buffer.object(),
+                offset,
+                VERTEX_STRIDE,
+            );
+        }
+    }
 
-        cb(currently_bound);
+    pub fn enable_attrib(&mut self, attrib_index: u32)
+    {
+        unsafe {
+            gl::EnableVertexArrayAttrib(self.array, attrib_index as gl::types::GLuint);
+        }
     }
 
-    fn vertex_attrib_ptr(vertex_attr: &Attribute, offset: usize)
+    pub fn set_attrib_format(
+        &mut self,
+        attrib_index: u32,
+        data_type: DataType,
+        normalized: bool,
+        offset: u32,
+    )
     {
         unsafe {
-            #[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
-            gl::VertexAttribPointer(
-                vertex_attr.index as gl::types::GLuint,
-                vertex_attr.component_cnt as i32,
-                Self::vertex_attr_type_to_gl(&vertex_attr.component_type),
-                gl::FALSE,
-                VERTEX_STRIDE as gl::types::GLsizei,
-                offset as *const _,
+            #[allow(clippy::cast_possible_wrap)]
+            gl::VertexArrayAttribFormat(
+                self.array,
+                attrib_index,
+                data_type.size() as gl::types::GLint,
+                data_type as u32,
+                if normalized { gl::TRUE } else { gl::FALSE },
+                offset,
             );
         }
     }
 
-    fn enable_vertex_attrib_array(index: usize)
+    /// Associate a vertex attribute and a vertex buffer binding.
+    pub fn set_attrib_vertex_buf_binding(
+        &mut self,
+        attrib_index: u32,
+        vertex_buf_binding_index: u32,
+    )
     {
         unsafe {
-            #[allow(clippy::cast_possible_truncation)]
-            gl::EnableVertexAttribArray(index as gl::types::GLuint);
+            gl::VertexArrayAttribBinding(
+                self.array,
+                attrib_index,
+                vertex_buf_binding_index,
+            );
         }
     }
 
-    fn vertex_attr_type_to_gl(
-        vertex_attr_type: &AttributeComponentType,
-    ) -> gl::types::GLenum
+    pub fn bind(&self)
     {
-        match vertex_attr_type {
-            AttributeComponentType::Float => gl::FLOAT,
-        }
+        unsafe { gl::BindVertexArray(self.array) }
     }
 }
 
@@ -148,3 +152,21 @@ impl PrimitiveKind
         }
     }
 }
+
+#[derive(Debug, Clone, Copy)]
+#[repr(u32)]
+pub enum DataType
+{
+    Float = gl::FLOAT,
+}
+
+impl DataType
+{
+    pub fn size(self) -> u32
+    {
+        #[allow(clippy::cast_possible_truncation)]
+        match self {
+            Self::Float => size_of::<gl::types::GLfloat>() as u32,
+        }
+    }
+}
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,
 }
diff --git a/engine/src/texture.rs b/engine/src/texture.rs
index 5cea9ff..88c57bd 100644
--- a/engine/src/texture.rs
+++ b/engine/src/texture.rs
@@ -7,8 +7,8 @@ use image::io::Reader as ImageReader;
 use image::{DynamicImage, ImageError, Rgb, RgbImage};
 
 use crate::color::Color;
+use crate::data_types::dimens::Dimens;
 use crate::opengl::texture::PixelDataFormat;
-use crate::vector::Vec2;
 
 static NEXT_ID: AtomicU32 = AtomicU32::new(0);
 
@@ -25,7 +25,7 @@ pub struct Texture
     id: Id,
     image: DynamicImage,
     pixel_data_format: PixelDataFormat,
-    dimensions: Vec2<u32>,
+    dimensions: Dimens<u32>,
     properties: Properties,
 }
 
@@ -46,14 +46,17 @@ impl Texture
             .map_err(Error::DecodeImageFailed)?;
 
         let pixel_data_format = match &image {
-            DynamicImage::ImageRgb8(_) => PixelDataFormat::Rgb,
-            DynamicImage::ImageRgba8(_) => PixelDataFormat::Rgba,
+            DynamicImage::ImageRgb8(_) => PixelDataFormat::Rgb8,
+            DynamicImage::ImageRgba8(_) => PixelDataFormat::Rgba8,
             _ => {
                 return Err(Error::UnsupportedImageDataKind);
             }
         };
 
-        let dimensions = Vec2 { x: image.width(), y: image.height() };
+        let dimensions = Dimens {
+            width: image.width(),
+            height: image.height(),
+        };
 
         let id = NEXT_ID.fetch_add(1, Ordering::Relaxed);
 
@@ -67,11 +70,11 @@ impl Texture
     }
 
     #[must_use]
-    pub fn new_from_color(dimensions: &Vec2<u32>, color: &Color<u8>) -> Self
+    pub fn new_from_color(dimensions: &Dimens<u32>, color: &Color<u8>) -> Self
     {
         let image = RgbImage::from_pixel(
-            dimensions.x,
-            dimensions.y,
+            dimensions.width,
+            dimensions.height,
             Rgb([color.red, color.green, color.blue]),
         );
 
@@ -80,8 +83,8 @@ impl Texture
         Self {
             id: Id::new(id),
             image: image.into(),
-            pixel_data_format: PixelDataFormat::Rgb,
-            dimensions: dimensions.clone(),
+            pixel_data_format: PixelDataFormat::Rgb8,
+            dimensions: *dimensions,
             properties: Properties::default(),
         }
     }
@@ -104,7 +107,7 @@ impl Texture
     }
 
     #[must_use]
-    pub fn dimensions(&self) -> &Vec2<u32>
+    pub fn dimensions(&self) -> &Dimens<u32>
     {
         &self.dimensions
     }
diff --git a/engine/src/vertex.rs b/engine/src/vertex.rs
index bb0e890..37a6c51 100644
--- a/engine/src/vertex.rs
+++ b/engine/src/vertex.rs
@@ -82,30 +82,31 @@ impl Vertex
 {
     pub(crate) fn attrs() -> &'static [Attribute]
     {
+        #[allow(clippy::cast_possible_truncation)]
         &[
             Attribute {
                 index: 0,
                 component_type: AttributeComponentType::Float,
                 component_cnt: AttributeComponentCnt::Three,
-                component_size: size_of::<f32>(),
+                component_size: size_of::<f32>() as u32,
             },
             Attribute {
                 index: 1,
                 component_type: AttributeComponentType::Float,
                 component_cnt: AttributeComponentCnt::Three,
-                component_size: size_of::<f32>(),
+                component_size: size_of::<f32>() as u32,
             },
             Attribute {
                 index: 2,
                 component_type: AttributeComponentType::Float,
                 component_cnt: AttributeComponentCnt::Two,
-                component_size: size_of::<f32>(),
+                component_size: size_of::<f32>() as u32,
             },
             Attribute {
                 index: 3,
                 component_type: AttributeComponentType::Float,
                 component_cnt: AttributeComponentCnt::Three,
-                component_size: size_of::<f32>(),
+                component_size: size_of::<f32>() as u32,
             },
         ]
     }
@@ -113,10 +114,10 @@ impl Vertex
 
 pub(crate) struct Attribute
 {
-    pub(crate) index: usize,
+    pub(crate) index: u32,
     pub(crate) component_type: AttributeComponentType,
     pub(crate) component_cnt: AttributeComponentCnt,
-    pub(crate) component_size: usize,
+    pub(crate) component_size: u32,
 }
 
 pub(crate) enum AttributeComponentType