refactor(engine): use winit instead of glfw

7 files changed, 0 insertions, 1000 deletions

diff --git a/engine/src/opengl/buffer.rs b/engine/src/opengl/buffer.rs
deleted file mode 100644
index eded553..0000000
--- a/engine/src/opengl/buffer.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-use std::marker::PhantomData;
-use std::mem::size_of_val;
-use std::ptr::null;
-
-#[derive(Debug)]
-pub struct Buffer<Item>
-{
-    buf: gl::types::GLuint,
-    _pd: PhantomData<Item>,
-}
-
-impl<Item> Buffer<Item>
-{
-    pub fn new() -> Self
-    {
-        let mut buffer = gl::types::GLuint::default();
-
-        unsafe {
-            gl::CreateBuffers(1, &mut buffer);
-        };
-
-        Self { buf: buffer, _pd: PhantomData }
-    }
-
-    /// Stores items in the currently bound buffer.
-    pub fn store(&mut self, items: &[Item], usage: Usage)
-    {
-        unsafe {
-            #[allow(clippy::cast_possible_wrap)]
-            gl::NamedBufferData(
-                self.buf,
-                size_of_val(items) as gl::types::GLsizeiptr,
-                items.as_ptr().cast(),
-                usage.into_gl(),
-            );
-        }
-    }
-
-    pub fn store_mapped<Value>(
-        &mut self,
-        values: &[Value],
-        usage: Usage,
-        mut map_func: impl FnMut(&Value) -> Item,
-    )
-    {
-        unsafe {
-            #[allow(clippy::cast_possible_wrap)]
-            gl::NamedBufferData(
-                self.buf,
-                (size_of::<Item>() * values.len()) as gl::types::GLsizeiptr,
-                null(),
-                usage.into_gl(),
-            );
-        }
-
-        for (index, value) in values.iter().enumerate() {
-            let item = map_func(value);
-
-            unsafe {
-                gl::NamedBufferSubData(
-                    self.buf,
-                    (index * size_of::<Item>()) as gl::types::GLintptr,
-                    size_of::<Item>() as gl::types::GLsizeiptr,
-                    (&raw const item).cast(),
-                );
-            }
-        }
-    }
-
-    pub fn object(&self) -> gl::types::GLuint
-    {
-        self.buf
-    }
-}
-
-/// Buffer usage.
-#[derive(Debug)]
-#[allow(dead_code)]
-pub enum Usage
-{
-    /// The buffer data is set only once and used by the GPU at most a few times.
-    Stream,
-
-    /// The buffer data is set only once and used many times.
-    Static,
-
-    /// The buffer data is changed a lot and used many times.
-    Dynamic,
-}
-
-impl Usage
-{
-    fn into_gl(self) -> gl::types::GLenum
-    {
-        match self {
-            Self::Stream => gl::STREAM_DRAW,
-            Self::Static => gl::STATIC_DRAW,
-            Self::Dynamic => gl::DYNAMIC_DRAW,
-        }
-    }
-}
diff --git a/engine/src/opengl/debug.rs b/engine/src/opengl/debug.rs
deleted file mode 100644
index 203590a..0000000
--- a/engine/src/opengl/debug.rs
+++ /dev/null
@@ -1,145 +0,0 @@
-use std::ffi::c_void;
-use std::io::{stderr, Write};
-use std::panic::catch_unwind;
-use std::ptr::null_mut;
-use std::sync::Mutex;
-
-use crate::opengl::util::gl_enum;
-
-pub type MessageCallback = fn(
-    source: MessageSource,
-    ty: MessageType,
-    id: u32,
-    severity: MessageSeverity,
-    message: &str,
-);
-
-pub fn enable_debug_output()
-{
-    unsafe {
-        gl::Enable(gl::DEBUG_OUTPUT);
-        gl::Enable(gl::DEBUG_OUTPUT_SYNCHRONOUS);
-    }
-}
-
-pub fn set_debug_message_callback(cb: MessageCallback)
-{
-    *DEBUG_MESSAGE_CB.lock().unwrap() = Some(cb);
-
-    unsafe {
-        gl::DebugMessageCallback(Some(debug_message_cb), null_mut());
-    }
-}
-
-pub fn set_debug_message_control(
-    source: Option<MessageSource>,
-    ty: Option<MessageType>,
-    severity: Option<MessageSeverity>,
-    ids: &[u32],
-    ids_action: MessageIdsAction,
-)
-{
-    // Ids shouldn't realistically be large enough to cause a panic here
-    let ids_len: i32 = ids.len().try_into().unwrap();
-
-    unsafe {
-        gl::DebugMessageControl(
-            source.map_or(gl::DONT_CARE, |source| source as u32),
-            ty.map_or(gl::DONT_CARE, |ty| ty as u32),
-            severity.map_or(gl::DONT_CARE, |severity| severity as u32),
-            ids_len,
-            ids.as_ptr(),
-            ids_action as u8,
-        );
-    }
-}
-
-#[derive(Debug, Clone, Copy)]
-#[allow(dead_code)]
-pub enum MessageIdsAction
-{
-    Enable = 1,
-    Disable = 0,
-}
-
-gl_enum! {
-pub enum MessageSource
-{
-    Api = gl::DEBUG_SOURCE_API,
-    WindowSystem = gl::DEBUG_SOURCE_WINDOW_SYSTEM,
-    ShaderCompiler = gl::DEBUG_SOURCE_SHADER_COMPILER,
-    ThirdParty = gl::DEBUG_SOURCE_THIRD_PARTY,
-    Application = gl::DEBUG_SOURCE_APPLICATION,
-    Other = gl::DEBUG_SOURCE_OTHER,
-}
-}
-
-gl_enum! {
-pub enum MessageType
-{
-    DeprecatedBehavior = gl::DEBUG_TYPE_DEPRECATED_BEHAVIOR,
-    Error = gl::DEBUG_TYPE_ERROR,
-    Marker = gl::DEBUG_TYPE_MARKER,
-    Other = gl::DEBUG_TYPE_OTHER,
-    Performance = gl::DEBUG_TYPE_PERFORMANCE,
-    PopGroup = gl::DEBUG_TYPE_POP_GROUP,
-    PushGroup = gl::DEBUG_TYPE_PUSH_GROUP,
-    Portability = gl::DEBUG_TYPE_PORTABILITY,
-    UndefinedBehavior = gl::DEBUG_TYPE_UNDEFINED_BEHAVIOR,
-}
-}
-
-gl_enum! {
-pub enum MessageSeverity
-{
-    High = gl::DEBUG_SEVERITY_HIGH,
-    Medium = gl::DEBUG_SEVERITY_MEDIUM,
-    Low = gl::DEBUG_SEVERITY_LOW,
-    Notification = gl::DEBUG_SEVERITY_NOTIFICATION,
-}
-}
-
-static DEBUG_MESSAGE_CB: Mutex<Option<MessageCallback>> = Mutex::new(None);
-
-extern "system" fn debug_message_cb(
-    source: gl::types::GLenum,
-    ty: gl::types::GLenum,
-    id: gl::types::GLuint,
-    severity: gl::types::GLenum,
-    message_length: gl::types::GLsizei,
-    message: *const gl::types::GLchar,
-    _user_param: *mut c_void,
-)
-{
-    // Unwinds are catched because unwinding from Rust code into foreign code is UB.
-    let res = catch_unwind(|| {
-        let cb_lock = DEBUG_MESSAGE_CB.lock().unwrap();
-
-        if let Some(cb) = *cb_lock {
-            let msg_source = MessageSource::from_gl(source).unwrap();
-            let msg_type = MessageType::from_gl(ty).unwrap();
-            let msg_severity = MessageSeverity::from_gl(severity).unwrap();
-
-            let msg_length = usize::try_from(message_length).unwrap();
-
-            // SAFETY: The received message should be a valid ASCII string
-            let message = unsafe {
-                std::str::from_utf8_unchecked(std::slice::from_raw_parts(
-                    message.cast(),
-                    msg_length,
-                ))
-            };
-
-            cb(msg_source, msg_type, id, msg_severity, message);
-        }
-    });
-
-    if res.is_err() {
-        // eprintln is not used since it can panic and unwinds are unwanted because
-        // unwinding from Rust code into foreign code is UB.
-        stderr()
-            .write_all(b"ERROR: Panic in debug message callback")
-            .ok();
-        println!();
-    }
-}
diff --git a/engine/src/opengl/mod.rs b/engine/src/opengl/mod.rs
index 53e0120..2208ac6 100644
--- a/engine/src/opengl/mod.rs
+++ b/engine/src/opengl/mod.rs
@@ -1,128 +1 @@
-use bitflags::bitflags;
-use gl::types::GLint;
-
-use crate::data_types::dimens::Dimens;
-use crate::vector::Vec2;
-
-pub mod buffer;
 pub mod glsl;
-pub mod shader;
-pub mod texture;
-pub mod vertex_array;
-
-mod util;
-
-pub mod debug;
-
-pub fn set_viewport(position: Vec2<u32>, size: Dimens<u32>)
-{
-    unsafe {
-        #[allow(clippy::cast_possible_wrap)]
-        gl::Viewport(
-            position.x as i32,
-            position.y as i32,
-            size.width as i32,
-            size.height as i32,
-        );
-    }
-}
-
-pub fn clear_buffers(mask: BufferClearMask)
-{
-    unsafe {
-        gl::Clear(mask.bits());
-    }
-}
-
-pub fn set_polygon_mode(face: impl Into<PolygonModeFace>, mode: impl Into<PolygonMode>)
-{
-    unsafe {
-        gl::PolygonMode(face.into() as u32, mode.into() as u32);
-    }
-}
-
-pub fn enable(capacity: Capability)
-{
-    unsafe {
-        gl::Enable(capacity as u32);
-    }
-}
-
-pub fn get_context_flags() -> ContextFlags
-{
-    let mut context_flags: GLint = 0;
-
-    unsafe {
-        gl::GetIntegerv(gl::CONTEXT_FLAGS as u32, &mut context_flags);
-    }
-
-    ContextFlags::from_bits_truncate(context_flags as u32)
-}
-
-bitflags! {
-    #[derive(Debug, Clone, Copy)]
-    pub struct BufferClearMask: u32 {
-        const COLOR = gl::COLOR_BUFFER_BIT;
-        const DEPTH = gl::DEPTH_BUFFER_BIT;
-        const STENCIL = gl::STENCIL_BUFFER_BIT;
-    }
-}
-
-#[derive(Debug)]
-#[repr(u32)]
-pub enum Capability
-{
-    DepthTest = gl::DEPTH_TEST,
-    MultiSample = gl::MULTISAMPLE,
-}
-
-#[derive(Debug)]
-#[repr(u32)]
-pub enum PolygonMode
-{
-    Point = gl::POINT,
-    Line = gl::LINE,
-    Fill = gl::FILL,
-}
-
-impl From<crate::draw_flags::PolygonMode> for PolygonMode
-{
-    fn from(mode: crate::draw_flags::PolygonMode) -> Self
-    {
-        match mode {
-            crate::draw_flags::PolygonMode::Point => Self::Point,
-            crate::draw_flags::PolygonMode::Fill => Self::Fill,
-            crate::draw_flags::PolygonMode::Line => Self::Line,
-        }
-    }
-}
-
-#[derive(Debug)]
-#[repr(u32)]
-pub enum PolygonModeFace
-{
-    Front = gl::FRONT,
-    Back = gl::BACK,
-    FrontAndBack = gl::FRONT_AND_BACK,
-}
-
-impl From<crate::draw_flags::PolygonModeFace> for PolygonModeFace
-{
-    fn from(face: crate::draw_flags::PolygonModeFace) -> Self
-    {
-        match face {
-            crate::draw_flags::PolygonModeFace::Front => Self::Front,
-            crate::draw_flags::PolygonModeFace::Back => Self::Back,
-            crate::draw_flags::PolygonModeFace::FrontAndBack => Self::FrontAndBack,
-        }
-    }
-}
-
-bitflags! {
-#[derive(Debug, Clone, Copy)]
-pub struct ContextFlags: u32 {
-    const FORWARD_COMPATIBLE = gl::CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT;
-    const DEBUG = gl::CONTEXT_FLAG_DEBUG_BIT;
-    const ROBUST_ACCESS = gl::CONTEXT_FLAG_ROBUST_ACCESS_BIT;
-}
-}
diff --git a/engine/src/opengl/shader.rs b/engine/src/opengl/shader.rs
deleted file mode 100644
index a626fc7..0000000
--- a/engine/src/opengl/shader.rs
+++ /dev/null
@@ -1,270 +0,0 @@
-use std::ffi::CStr;
-use std::ptr::null_mut;
-
-use crate::matrix::Matrix;
-use crate::vector::Vec3;
-
-#[derive(Debug)]
-pub struct Shader
-{
-    shader: gl::types::GLuint,
-}
-
-impl Shader
-{
-    pub fn new(kind: Kind) -> Self
-    {
-        let shader = unsafe { gl::CreateShader(kind.into_gl()) };
-
-        Self { shader }
-    }
-
-    pub fn set_source(&mut self, source: &str) -> Result<(), Error>
-    {
-        if !source.is_ascii() {
-            return Err(Error::SourceNotAscii);
-        }
-
-        unsafe {
-            #[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
-            gl::ShaderSource(
-                self.shader,
-                1,
-                &source.as_ptr().cast(),
-                &(source.len() as gl::types::GLint),
-            );
-        }
-
-        Ok(())
-    }
-
-    pub fn compile(&mut self) -> Result<(), Error>
-    {
-        unsafe {
-            gl::CompileShader(self.shader);
-        }
-
-        let mut compile_success = gl::types::GLint::default();
-
-        unsafe {
-            gl::GetShaderiv(self.shader, gl::COMPILE_STATUS, &mut compile_success);
-        }
-
-        if compile_success == 0 {
-            let info_log = self.get_info_log();
-
-            return Err(Error::CompileFailed(info_log));
-        }
-
-        Ok(())
-    }
-
-    fn get_info_log(&self) -> String
-    {
-        let mut buf = vec![gl::types::GLchar::default(); 512];
-
-        unsafe {
-            #[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
-            gl::GetShaderInfoLog(
-                self.shader,
-                buf.len() as gl::types::GLsizei,
-                null_mut(),
-                buf.as_mut_ptr(),
-            );
-        }
-
-        let info_log = unsafe { CStr::from_ptr(buf.as_ptr()) };
-
-        unsafe { String::from_utf8_unchecked(info_log.to_bytes().to_vec()) }
-    }
-}
-
-impl Drop for Shader
-{
-    fn drop(&mut self)
-    {
-        unsafe {
-            gl::DeleteShader(self.shader);
-        }
-    }
-}
-
-/// Shader kind.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum Kind
-{
-    Vertex,
-    Fragment,
-}
-
-impl Kind
-{
-    fn into_gl(self) -> gl::types::GLenum
-    {
-        match self {
-            Self::Vertex => gl::VERTEX_SHADER,
-            Self::Fragment => gl::FRAGMENT_SHADER,
-        }
-    }
-}
-
-/// Shader program
-#[derive(Debug, PartialEq, Eq, Hash)]
-pub struct Program
-{
-    program: gl::types::GLuint,
-}
-
-impl Program
-{
-    pub fn new() -> Self
-    {
-        let program = unsafe { gl::CreateProgram() };
-
-        Self { program }
-    }
-
-    pub fn attach(&mut self, shader: &Shader)
-    {
-        unsafe {
-            gl::AttachShader(self.program, shader.shader);
-        }
-    }
-
-    pub fn link(&mut self) -> Result<(), Error>
-    {
-        unsafe {
-            gl::LinkProgram(self.program);
-        }
-
-        let mut link_success = gl::types::GLint::default();
-
-        unsafe {
-            gl::GetProgramiv(self.program, gl::LINK_STATUS, &mut link_success);
-        }
-
-        if link_success == 0 {
-            let info_log = self.get_info_log();
-
-            return Err(Error::CompileFailed(info_log));
-        }
-
-        Ok(())
-    }
-
-    pub fn activate(&self)
-    {
-        unsafe {
-            gl::UseProgram(self.program);
-        }
-    }
-
-    pub fn set_uniform(&mut self, name: &CStr, var: &impl UniformVariable)
-    {
-        let location = UniformLocation(unsafe {
-            gl::GetUniformLocation(self.program, name.as_ptr().cast())
-        });
-
-        var.set(self, location);
-    }
-
-    fn get_info_log(&self) -> String
-    {
-        let mut buf = vec![gl::types::GLchar::default(); 512];
-
-        unsafe {
-            #[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
-            gl::GetProgramInfoLog(
-                self.program,
-                buf.len() as gl::types::GLsizei,
-                null_mut(),
-                buf.as_mut_ptr(),
-            );
-        }
-
-        let info_log = unsafe { CStr::from_ptr(buf.as_ptr()) };
-
-        unsafe { String::from_utf8_unchecked(info_log.to_bytes().to_vec()) }
-    }
-}
-
-impl Drop for Program
-{
-    fn drop(&mut self)
-    {
-        unsafe {
-            gl::DeleteProgram(self.program);
-        }
-    }
-}
-
-pub trait UniformVariable
-{
-    fn set(&self, program: &mut Program, uniform_location: UniformLocation);
-}
-
-impl UniformVariable for f32
-{
-    fn set(&self, program: &mut Program, uniform_location: UniformLocation)
-    {
-        unsafe {
-            gl::ProgramUniform1f(program.program, uniform_location.0, *self);
-        }
-    }
-}
-
-impl UniformVariable for i32
-{
-    fn set(&self, program: &mut Program, uniform_location: UniformLocation)
-    {
-        unsafe {
-            gl::ProgramUniform1i(program.program, uniform_location.0, *self);
-        }
-    }
-}
-
-impl UniformVariable for Vec3<f32>
-{
-    fn set(&self, program: &mut Program, uniform_location: UniformLocation)
-    {
-        unsafe {
-            gl::ProgramUniform3f(
-                program.program,
-                uniform_location.0,
-                self.x,
-                self.y,
-                self.z,
-            );
-        }
-    }
-}
-
-impl UniformVariable for Matrix<f32, 4, 4>
-{
-    fn set(&self, program: &mut Program, uniform_location: UniformLocation)
-    {
-        unsafe {
-            gl::ProgramUniformMatrix4fv(
-                program.program,
-                uniform_location.0,
-                1,
-                gl::FALSE,
-                self.as_ptr(),
-            );
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct UniformLocation(gl::types::GLint);
-
-/// Shader error.
-#[derive(Debug, thiserror::Error)]
-pub enum Error
-{
-    #[error("All characters in source are not within the ASCII range")]
-    SourceNotAscii,
-
-    #[error("Failed to compile: {0}")]
-    CompileFailed(String),
-}
diff --git a/engine/src/opengl/texture.rs b/engine/src/opengl/texture.rs
deleted file mode 100644
index 80a5f37..0000000
--- a/engine/src/opengl/texture.rs
+++ /dev/null
@@ -1,169 +0,0 @@
-use crate::data_types::dimens::Dimens;
-
-#[derive(Debug)]
-pub struct Texture
-{
-    texture: gl::types::GLuint,
-}
-
-impl Texture
-{
-    pub fn new() -> Self
-    {
-        let mut texture = gl::types::GLuint::default();
-
-        unsafe {
-            gl::CreateTextures(gl::TEXTURE_2D, 1, &mut texture);
-        };
-
-        Self { texture }
-    }
-
-    pub fn bind_to_texture_unit(&self, texture_unit: u32)
-    {
-        unsafe {
-            gl::BindTextureUnit(texture_unit, self.texture);
-        }
-    }
-
-    pub fn generate(
-        &mut self,
-        dimens: Dimens<u32>,
-        data: &[u8],
-        pixel_data_format: PixelDataFormat,
-    )
-    {
-        self.alloc_image(pixel_data_format, dimens, data);
-
-        unsafe {
-            gl::GenerateTextureMipmap(self.texture);
-        }
-    }
-
-    pub fn set_wrap(&mut self, wrapping: Wrapping)
-    {
-        let wrapping_gl = wrapping as gl::types::GLenum;
-
-        #[allow(clippy::cast_possible_wrap)]
-        unsafe {
-            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(&mut self, filtering: Filtering)
-    {
-        let filtering_gl = filtering as gl::types::GLenum;
-
-        #[allow(clippy::cast_possible_wrap)]
-        unsafe {
-            gl::TextureParameteri(
-                self.texture,
-                gl::TEXTURE_MAG_FILTER,
-                filtering_gl as i32,
-            );
-        }
-    }
-
-    pub fn set_minifying_filter(&mut self, filtering: Filtering)
-    {
-        let filtering_gl = filtering as gl::types::GLenum;
-
-        #[allow(clippy::cast_possible_wrap)]
-        unsafe {
-            gl::TextureParameteri(
-                self.texture,
-                gl::TEXTURE_MIN_FILTER,
-                filtering_gl as i32,
-            );
-        }
-    }
-
-    fn alloc_image(
-        &mut self,
-        pixel_data_format: PixelDataFormat,
-        dimens: Dimens<u32>,
-        data: &[u8],
-    )
-    {
-        unsafe {
-            #[allow(clippy::cast_possible_wrap)]
-            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,
-                0,
-                dimens.width as i32,
-                dimens.height as i32,
-                pixel_data_format.to_format(),
-                gl::UNSIGNED_BYTE,
-                data.as_ptr().cast(),
-            );
-        }
-    }
-}
-
-impl Drop for Texture
-{
-    fn drop(&mut self)
-    {
-        unsafe {
-            gl::DeleteTextures(1, &self.texture);
-        }
-    }
-}
-
-/// Texture wrapping.
-#[derive(Debug, Clone, Copy)]
-#[repr(u32)]
-pub enum Wrapping
-{
-    Repeat = gl::REPEAT,
-    MirroredRepeat = gl::MIRRORED_REPEAT,
-    ClampToEdge = gl::CLAMP_TO_EDGE,
-    ClampToBorder = gl::CLAMP_TO_BORDER,
-}
-
-#[derive(Debug, Clone, Copy)]
-#[repr(u32)]
-pub enum Filtering
-{
-    Nearest = gl::NEAREST,
-    Linear = gl::LINEAR,
-}
-
-/// Texture pixel data format.
-#[derive(Debug, Clone, Copy)]
-pub enum PixelDataFormat
-{
-    Rgb8,
-    Rgba8,
-}
-
-impl PixelDataFormat
-{
-    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::Rgb8 => gl::RGB,
-            Self::Rgba8 => gl::RGBA,
-        }
-    }
-}
diff --git a/engine/src/opengl/util.rs b/engine/src/opengl/util.rs
deleted file mode 100644
index e60778f..0000000
--- a/engine/src/opengl/util.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-// May only be used when certain crate features are enabled
-#![allow(unused_macros, unused_imports)]
-
-macro_rules! gl_enum {
-    (
-        $visibility: vis enum $name: ident
-        {$(
-            $variant: ident = gl::$gl_enum: ident,
-        )+}
-    ) => {
-        #[derive(Debug, Clone, Copy)]
-        #[repr(u32)]
-        $visibility enum $name
-        {$(
-            $variant = gl::$gl_enum,
-        )+}
-
-        impl $name {
-            fn from_gl(num: gl::types::GLenum) -> Option<Self>
-            {
-                match num {
-                    $(gl::$gl_enum => Some(Self::$variant),)+
-                    _ => None
-                }
-            }
-        }
-    };
-}
-
-pub(crate) use gl_enum;
diff --git a/engine/src/opengl/vertex_array.rs b/engine/src/opengl/vertex_array.rs
deleted file mode 100644
index 1f8a870..0000000
--- a/engine/src/opengl/vertex_array.rs
+++ /dev/null
@@ -1,158 +0,0 @@
-use std::mem::size_of;
-
-use crate::opengl::buffer::Buffer;
-
-#[derive(Debug)]
-pub struct VertexArray
-{
-    array: gl::types::GLuint,
-}
-
-impl VertexArray
-{
-    pub fn new() -> Self
-    {
-        let mut array = 0;
-
-        unsafe {
-            gl::CreateVertexArrays(1, &mut array);
-        }
-
-        Self { array }
-    }
-
-    /// Draws the currently bound vertex array.
-    pub fn draw_arrays(primitive_kind: PrimitiveKind, start_index: u32, cnt: u32)
-    {
-        unsafe {
-            #[allow(clippy::cast_possible_wrap)]
-            gl::DrawArrays(
-                primitive_kind.into_gl(),
-                start_index as gl::types::GLint,
-                cnt as gl::types::GLsizei,
-            );
-        }
-    }
-
-    /// Draws the currently bound vertex array.
-    pub fn draw_elements(primitive_kind: PrimitiveKind, offset: u32, cnt: u32)
-    {
-        unsafe {
-            #[allow(clippy::cast_possible_wrap)]
-            gl::DrawElements(
-                primitive_kind.into_gl(),
-                cnt as gl::types::GLsizei,
-                gl::UNSIGNED_INT,
-                (offset as gl::types::GLint) as *const _,
-            );
-        }
-    }
-
-    pub fn bind_element_buffer(&mut self, element_buffer: &Buffer<u32>)
-    {
-        unsafe {
-            gl::VertexArrayElementBuffer(self.array, element_buffer.object());
-        }
-    }
-
-    pub fn bind_vertex_buffer<VertexT>(
-        &mut self,
-        binding_index: u32,
-        vertex_buffer: &Buffer<VertexT>,
-        offset: isize,
-    )
-    {
-        unsafe {
-            gl::VertexArrayVertexBuffer(
-                self.array,
-                binding_index,
-                vertex_buffer.object(),
-                offset,
-                size_of::<VertexT>() as i32,
-            );
-        }
-    }
-
-    pub fn enable_attrib(&mut self, attrib_index: u32)
-    {
-        unsafe {
-            gl::EnableVertexArrayAttrib(self.array, attrib_index as gl::types::GLuint);
-        }
-    }
-
-    pub fn set_attrib_format(
-        &mut self,
-        attrib_index: u32,
-        data_type: DataType,
-        normalized: bool,
-        offset: u32,
-    )
-    {
-        unsafe {
-            #[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,
-            );
-        }
-    }
-
-    /// 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 {
-            gl::VertexArrayAttribBinding(
-                self.array,
-                attrib_index,
-                vertex_buf_binding_index,
-            );
-        }
-    }
-
-    pub fn bind(&self)
-    {
-        unsafe { gl::BindVertexArray(self.array) }
-    }
-}
-
-#[derive(Debug)]
-pub enum PrimitiveKind
-{
-    Triangles,
-}
-
-impl PrimitiveKind
-{
-    fn into_gl(self) -> gl::types::GLenum
-    {
-        match self {
-            Self::Triangles => gl::TRIANGLES,
-        }
-    }
-}
-
-#[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,
-        }
-    }
-}