Finally fixed the UI

resources/shaders/basic.frag

@@ -0,0 +1,8 @@
+#version 460 core
+out vec4 FragColor;
+
+in vec4 _color;
+
+void main() {
+   FragColor = _color;
+}

resources/shaders/basic.vert

@@ -0,0 +1,14 @@
+#version 460 core
+layout (location = 0) in vec3 pos;
+layout (location = 1) in vec4 color;
+
+out vec4 _color;
+
+uniform mat4 proj;
+uniform mat4 view;
+uniform mat4 model;
+
+void main() {
+    gl_Position = proj * view * model * vec4(pos, 1.0);
+    _color = color;
+}

resources/shaders/texture.frag

@@ -0,0 +1,10 @@
+#version 460 core
+out vec4 FragColor;
+
+in vec2 _tex_coords;
+
+uniform sampler2D tex;
+
+void main() {
+   FragColor = texture(tex, _tex_coords);
+}

resources/shaders/texture.vert

@@ -0,0 +1,14 @@
+#version 460 core
+layout (location = 0) in vec3 pos;
+layout (location = 1) in vec2 tex_coords;
+
+out vec2 _tex_coords;
+
+uniform mat4 proj;
+uniform mat4 view;
+uniform mat4 model;
+
+void main() {
+    gl_Position = proj * view * model * vec4(pos, 1.0);
+    _tex_coords = tex_coords;
+}

src/graphics/context.rs

@@ -0,0 +1,12 @@
+use crate::maths::Matrix;
+
+pub struct Context {
+    pub projection: Matrix,
+    pub view: Matrix,
+}
+
+impl Context {
+    pub fn new(projection: Matrix, view: Matrix) -> Self {
+        Context { projection, view }
+    }
+}

src/graphics/geometry.rs

@@ -0,0 +1,3 @@
+pub mod triangle;
+
+pub use triangle::*;

src/graphics/geometry/triangle.rs

@@ -0,0 +1,121 @@
+use gl::types::*;
+use std::{mem, os::raw::c_void, ptr};
+
+use crate::{
+    graphics::{wrapper::*, Context},
+    maths::*,
+};
+
+pub trait Vertex {
+    fn x(&self) -> f32;
+    fn y(&self) -> f32;
+    fn z(&self) -> f32;
+}
+
+impl Vertex for Vector {
+    fn x(&self) -> f32 {
+        assert!(!self.is_empty());
+        self[0]
+    }
+    fn y(&self) -> f32 {
+        assert!(self.len() >= 2);
+        self[1]
+    }
+    fn z(&self) -> f32 {
+        assert!(self.len() >= 3);
+        self[2]
+    }
+}
+
+pub struct Triangle<'a> {
+    model: Matrix,
+    texture: Option<&'a Texture2D>,
+    shader: &'a mut ShaderProgram,
+}
+
+impl<'a> Triangle<'a> {
+    pub fn new(
+        model: Matrix,
+        texture: Option<&'a Texture2D>,
+        shader: &'a mut ShaderProgram,
+    ) -> Self {
+        assert_eq!(model.cols(), 4);
+        assert_eq!(model.rows(), 4);
+        Triangle {
+            model,
+            texture,
+            shader,
+        }
+    }
+    pub fn draw(&mut self, context: &Context) {
+        self.shader.bind();
+        self.shader.uniform_matrix_4fv("proj", &context.projection);
+        self.shader.uniform_matrix_4fv("view", &context.view);
+        self.shader.uniform_matrix_4fv("model", &self.model);
+        if let Some(texture) = self.texture {
+            texture.bind();
+            self.shader.uniform_2dtex("tex", texture)
+        }
+        unsafe {
+            gl::DrawElements(gl::TRIANGLES, 6, gl::UNSIGNED_INT, ptr::null());
+        }
+        if let Some(texture) = self.texture {
+            texture.unbind();
+        }
+        self.shader.unbind();
+    }
+}
+
+pub struct TrianglePool<'a> {
+    vao: VAO,
+    attribs: Vec<VertexAttrib>,
+    pool: Vec<Triangle<'a>>,
+}
+
+impl<'a> TrianglePool<'a> {
+    pub fn new(
+        base_data: Vec<f32>,
+        attribs_sizes: Vec<i32>,
+        shader: &'a mut ShaderProgram,
+    ) -> Self {
+        let vao = VAO::new();
+        let vbo: VBO = BO::new(gl::STATIC_DRAW, base_data);
+        let stride = attribs_sizes.iter().sum::<i32>() * mem::size_of::<GLfloat>() as GLsizei;
+        let mut cur_data_index = 0;
+        let attribs = attribs_sizes
+            .iter()
+            .enumerate()
+            .map(|(idx, attrib_size)| {
+                let attrib = VertexAttrib::new(
+                    idx as u32,
+                    *attrib_size,
+                    gl::FLOAT,
+                    gl::FALSE,
+                    stride,
+                    match cur_data_index {
+                        0 => ptr::null(),
+                        _ => (cur_data_index * mem::size_of::<GLfloat>()) as *const c_void,
+                    },
+                );
+                cur_data_index += *attrib_size as usize;
+                attrib
+            })
+            .collect::<Vec<VertexAttrib>>();
+        let pool = vec![Triangle::new(Matrix::model_default(), None, shader)];
+
+        vbo.unbind();
+        vao.unbind();
+        attribs.iter().for_each(|attrib| attrib.disable());
+
+        TrianglePool { vao, attribs, pool }
+    }
+    pub fn draw(&mut self, context: &Context) {
+        self.vao.bind();
+        self.attribs.iter().for_each(|attrib| attrib.enable());
+        self.pool
+            .iter_mut()
+            .for_each(|triangle| triangle.draw(context));
+        self.attribs.iter().for_each(|attrib| attrib.disable());
+        self.vao.unbind();
+    }
+}

src/graphics/window.rs

@@ -1,7 +1,7 @@
-use std::ffi::CStr;
 use egui_glfw::EguiBackend;
 use gl::types::*;
 use glfw::{self, Action, Context, Key, WindowEvent};
+use std::ffi::CStr;
 use std::os::raw::c_void;
 use std::ptr;
 use std::sync::mpsc::Receiver;
@@ -147,24 +147,12 @@ extern "system" fn debug_callback(
     message: *const GLchar,
     _user_param: *mut c_void,
 ) {
-    unsafe {
-        println!(
-            "GL CALLBACK: {} type = {}, severity = {}, message = {}",
-            match gltype {
-                gl::DEBUG_TYPE_ERROR => "** GL ERROR **",
-                _ => ""
-            },
-            CStr::from_ptr(gl::GetString(gltype) as _).to_str().expect("Failed to convert debug GL type to String"),
-            CStr::from_ptr(gl::GetString(severity) as _).to_str().expect("Failed to convert debug severity to String"),
-            CStr::from_ptr(message as _).to_str().expect("Failed to convert debug message to String")
-        )
-    }
-    // println!(
-    //     "OpenGL Debug Message: source={}, type={}, id={}, severity={}, message={}",
-    //     source,
-    //     gltype,
-    //     id,
-    //     severity,
-    //     unsafe { std::ffi::CStr::from_ptr(message).to_str().unwrap() }
-    // );
+    println!(
+        "OpenGL Debug Message: source={}, type={}, id={}, severity={}, message={}",
+        source,
+        gltype,
+        id,
+        severity,
+        unsafe { CStr::from_ptr(message).to_str().unwrap() }
+    );
 }

src/main.rs

@@ -89,7 +89,7 @@ fn main() {
         {
             t = window.glfw_handle().get_time() as f32;
 
-            shader_program.bind();
+            // shader_program.bind();
             // _pos_attrib.enable();
             // _tex_attrib.enable();
             _vao.bind();
@@ -108,17 +108,17 @@ fn main() {
                 "model",
                 &(Matrix::translation((0., 0.5 * (1.5 * t).sin(), 0.))
                     * Matrix::translation((
-                    translate.0.parse::<f32>().unwrap_or(0.0),
-                    translate.1.parse::<f32>().unwrap_or(0.0),
-                    translate.2.parse::<f32>().unwrap_or(0.0),
-                ))
+                        translate.0.parse::<f32>().unwrap_or(0.0),
+                        translate.1.parse::<f32>().unwrap_or(0.0),
+                        translate.2.parse::<f32>().unwrap_or(0.0),
+                    ))
                     * Matrix::rotation((0.12, t, 0.))
                     * Matrix::rotation(rotate)
                     * Matrix::scaling((
-                    scale.0.parse::<f32>().unwrap_or(0.0),
-                    scale.1.parse::<f32>().unwrap_or(0.0),
-                    scale.2.parse::<f32>().unwrap_or(0.0),
-                ))),
+                        scale.0.parse::<f32>().unwrap_or(0.0),
+                        scale.1.parse::<f32>().unwrap_or(0.0),
+                        scale.2.parse::<f32>().unwrap_or(0.0),
+                    ))),
             );
 
             texture_gato.bind();
@@ -130,17 +130,17 @@ fn main() {
                 "model",
                 &(Matrix::translation(((2. * t).sin(), 0., (2. * t).cos()))
                     * Matrix::translation((
-                    translate.0.parse::<f32>().unwrap_or(0.0),
-                    translate.1.parse::<f32>().unwrap_or(0.0),
-                    translate.2.parse::<f32>().unwrap_or(0.0),
-                ))
+                        translate.0.parse::<f32>().unwrap_or(0.0),
+                        translate.1.parse::<f32>().unwrap_or(0.0),
+                        translate.2.parse::<f32>().unwrap_or(0.0),
+                    ))
                     * Matrix::rotation((0.12, 2. * PI * t, 0.))
                     * Matrix::rotation(rotate)
                     * Matrix::scaling((
-                    scale.0.parse::<f32>().unwrap_or(0.0),
-                    scale.1.parse::<f32>().unwrap_or(0.0),
-                    scale.2.parse::<f32>().unwrap_or(0.0),
-                ))),
+                        scale.0.parse::<f32>().unwrap_or(0.0),
+                        scale.1.parse::<f32>().unwrap_or(0.0),
+                        scale.2.parse::<f32>().unwrap_or(0.0),
+                    ))),
             );
 
             texture_gatorrito.bind();
@@ -152,17 +152,17 @@ fn main() {
                 "model",
                 &(Matrix::translation((0.2 * (t).sin(), (2. * t).sin(), (2. * t).cos()))
                     * Matrix::translation((
-                    translate.0.parse::<f32>().unwrap_or(0.0),
-                    translate.1.parse::<f32>().unwrap_or(0.0),
-                    translate.2.parse::<f32>().unwrap_or(0.0),
-                ))
+                        translate.0.parse::<f32>().unwrap_or(0.0),
+                        translate.1.parse::<f32>().unwrap_or(0.0),
+                        translate.2.parse::<f32>().unwrap_or(0.0),
+                    ))
                     * Matrix::rotation((0.12, 2. * PI * t, 0.))
                     * Matrix::rotation(rotate)
                     * Matrix::scaling((
-                    scale.0.parse::<f32>().unwrap_or(0.0),
-                    scale.1.parse::<f32>().unwrap_or(0.0),
-                    scale.2.parse::<f32>().unwrap_or(0.0),
-                ))),
+                        scale.0.parse::<f32>().unwrap_or(0.0),
+                        scale.1.parse::<f32>().unwrap_or(0.0),
+                        scale.2.parse::<f32>().unwrap_or(0.0),
+                    ))),
             );
 
             texture_pog.bind();