Autoformat everything + minor include fixes

ECS/Components/Camera.h

@@ -9,9 +9,10 @@
 #include <glm/gtc/matrix_transform.hpp>
 
 struct Camera {
-    /// Create a camera with a field of view (in degrees), width and height (in any unit) and near and far distances
+    /// Create a camera with a field of view (in degrees), width and height (in any unit) and near
-    Camera(float fov, float width, float height, float near, float far) : projection(
+    /// and far distances
-            glm::perspective(glm::radians(fov), width / height, near, far)) {}
+    Camera(float fov, float width, float height, float near, float far)
+        : projection(glm::perspective(glm::radians(fov), width / height, near, far)) {}
 
     glm::mat4 projection;
 

ECS/Components/DirectionalLight.h

@@ -5,6 +5,8 @@
 #ifndef ECSGAME_DIRECTIONALLIGHT_H
 #define ECSGAME_DIRECTIONALLIGHT_H
 
+#include <glm/glm.hpp>
+
 struct DirectionalLight {
     explicit DirectionalLight(const glm::vec3 &direction) : direction(direction) {}
 

ECS/Components/LODObjMesh.h

@@ -5,9 +5,9 @@
 #ifndef ECSGAME_LODOBJMESH_H
 #define ECSGAME_LODOBJMESH_H
 
+#include "ObjMesh.h"
 #include <utility>
 #include <vector>
-#include "ObjMesh.h"
 
 struct LODObjMesh {
     explicit LODObjMesh(std::vector<ObjMesh> meshes) : meshes(std::move(meshes)) {}

ECS/Components/Mesh.h

@@ -5,13 +5,15 @@
 #ifndef ECSGAME_MESH_H
 #define ECSGAME_MESH_H
 
-#include <glad/glad.h>
 #include <GLFW/glfw3.h>
+#include <glad/glad.h>
 #include <vector>
 
 struct Mesh {
-    explicit Mesh(const std::vector<float> &_vertices, const std::vector<unsigned int> &_indices) : vertex_count(_indices.size()) {
+    explicit Mesh(const std::vector<float> &_vertices, const std::vector<unsigned int> &_indices)
-        // Copy the vertices into a local classic float array. Nothing was displayed without this, maybe
+        : vertex_count(_indices.size()) {
+        // Copy the vertices into a local classic float array. Nothing was displayed without this,
+        // maybe
         //  due to weird hidden type incompatibility or out of scope issues?
         float vertices[_vertices.size()];
         std::copy(_vertices.begin(), _vertices.end(), vertices);
@@ -23,7 +25,8 @@ struct Mesh {
         glGenBuffers(1, &VBO);
         glGenBuffers(1, &EBO);
 
-        // bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s).
+        // bind the Vertex Array Object first, then bind and set vertex buffer(s), and then
+        // configure vertex attributes(s).
         glBindVertexArray(VAO);
 
         glBindBuffer(GL_ARRAY_BUFFER, VBO);
@@ -37,19 +40,23 @@ struct Mesh {
         glEnableVertexAttribArray(0);
 
         // Normal attribute
-        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(float), (void*)(3 * sizeof(float)));
+        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(float),
+                              (void *)(3 * sizeof(float)));
         glEnableVertexAttribArray(1);
 
         // texture coord attribute
-        glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 14 * sizeof(float), (void*)(6 * sizeof(float)));
+        glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 14 * sizeof(float),
+                              (void *)(6 * sizeof(float)));
         glEnableVertexAttribArray(2);
 
         // Tangent attribute
-        glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(float), (void*)(8 * sizeof(float)));
+        glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(float),
+                              (void *)(8 * sizeof(float)));
         glEnableVertexAttribArray(3);
 
         // Bitangent attribute
-        glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(float), (void*)(11 * sizeof(float)));
+        glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, 14 * sizeof(float),
+                              (void *)(11 * sizeof(float)));
         glEnableVertexAttribArray(4);
 
         glBindVertexArray(0);

ECS/Components/MouseLook.h

@@ -5,6 +5,9 @@
 #ifndef ECSGAME_MOUSELOOK_H
 #define ECSGAME_MOUSELOOK_H
 
+#include <glm/glm.hpp>
+#include <glm/gtc/quaternion.hpp>
+
 struct MouseLook {
     explicit MouseLook(float sensitivity) : sensitivity(sensitivity) {}
 

ECS/Components/Movement.h

@@ -5,6 +5,8 @@
 #ifndef ECSGAME_MOVEMENT_H
 #define ECSGAME_MOVEMENT_H
 
+#include <glm/glm.hpp>
+
 struct Movement {
     Movement(glm::vec3 speed) : speed(speed) {}
 

ECS/Components/ObjMesh.h

@@ -5,23 +5,25 @@
 #ifndef ECSGAME_OBJMESH_H
 #define ECSGAME_OBJMESH_H
 
-#include "Mesh.h"
 #include "../../Util/OBJ_Loader.h"
+#include "Mesh.h"
 
 struct ObjMesh : public Mesh {
     struct Settings {
         Settings() = default;
 
-        Settings(float minDistanceForRender, float maxDistanceForRender, float diffuse, float specular)
+        Settings(float minDistanceForRender, float maxDistanceForRender, float diffuse,
-                : minDistanceForRender(minDistanceForRender), maxDistanceForRender(maxDistanceForRender) {}
+                 float specular)
+            : minDistanceForRender(minDistanceForRender),
+              maxDistanceForRender(maxDistanceForRender) {}
 
         float minDistanceForRender = 0.0;
         float maxDistanceForRender = 1000.0;
     };
 
-    explicit ObjMesh(const std::string &path, const Settings &settings) : Mesh(getVerticesFromFile(path), getIndicesFromFile(path)),
+    explicit ObjMesh(const std::string &path, const Settings &settings)
-                                                                                 minDistance(settings.minDistanceForRender),
+        : Mesh(getVerticesFromFile(path), getIndicesFromFile(path)),
-                                                                                 maxDistance(settings.maxDistanceForRender) {}
+          minDistance(settings.minDistanceForRender), maxDistance(settings.maxDistanceForRender) {}
 
     float minDistance;
 
@@ -65,13 +67,16 @@ private:
             return vertexData;
         } else {
             // Output Error
-            std::cout << "Failed to Load File. May have failed to find it or it was not an .obj file.\n";
+            std::cout
+                << "Failed to Load File. May have failed to find it or it was not an .obj file.\n";
         }
     }
 
-    static std::pair<std::vector<glm::vec3>, std::vector<glm::vec3>> getTangentsFromVertices(const std::vector<objl::Vertex> &vertices, const std::vector<unsigned int> indices) {
+    static std::pair<std::vector<glm::vec3>, std::vector<glm::vec3>>
-        // These vectors hold tangents and bitangents in the same way in which the vertices vectors holds vertices:
+    getTangentsFromVertices(const std::vector<objl::Vertex> &vertices,
-        // Their index in the vector corresponds to indices in the indices vector.
+                            const std::vector<unsigned int> indices) {
+        // These vectors hold tangents and bitangents in the same way in which the vertices vectors
+        // holds vertices: Their index in the vector corresponds to indices in the indices vector.
         std::vector<glm::vec3> tangents(vertices.size());
         std::vector<glm::vec3> bitangents(vertices.size());
 
@@ -83,17 +88,26 @@ private:
             uint i2 = indices[index + 2];
 
             // Inputs
-            glm::vec3 vertex0 = glm::vec3(vertices[i0].Position.X, vertices[i0].Position.Y, vertices[i0].Position.Z);
+            glm::vec3 vertex0 = glm::vec3(vertices[i0].Position.X, vertices[i0].Position.Y,
-            glm::vec3 vertex1 = glm::vec3(vertices[i1].Position.X, vertices[i1].Position.Y, vertices[i1].Position.Z);
+                                          vertices[i0].Position.Z);
-            glm::vec3 vertex2 = glm::vec3(vertices[i2].Position.X, vertices[i2].Position.Y, vertices[i2].Position.Z);
+            glm::vec3 vertex1 = glm::vec3(vertices[i1].Position.X, vertices[i1].Position.Y,
+                                          vertices[i1].Position.Z);
+            glm::vec3 vertex2 = glm::vec3(vertices[i2].Position.X, vertices[i2].Position.Y,
+                                          vertices[i2].Position.Z);
 
-            glm::vec2 uv0 = glm::vec2(vertices[i0].TextureCoordinate.X, vertices[i0].TextureCoordinate.Y);
+            glm::vec2 uv0 =
-            glm::vec2 uv1 = glm::vec2(vertices[i1].TextureCoordinate.X, vertices[i1].TextureCoordinate.Y);
+                glm::vec2(vertices[i0].TextureCoordinate.X, vertices[i0].TextureCoordinate.Y);
-            glm::vec2 uv2 = glm::vec2(vertices[i2].TextureCoordinate.X, vertices[i2].TextureCoordinate.Y);
+            glm::vec2 uv1 =
+                glm::vec2(vertices[i1].TextureCoordinate.X, vertices[i1].TextureCoordinate.Y);
+            glm::vec2 uv2 =
+                glm::vec2(vertices[i2].TextureCoordinate.X, vertices[i2].TextureCoordinate.Y);
 
-            glm::vec3 normal0 = glm::vec3(vertices[i0].Normal.X, vertices[i0].Normal.Y, vertices[i0].Normal.Z);
+            glm::vec3 normal0 =
-            glm::vec3 normal1 = glm::vec3(vertices[i1].Normal.X, vertices[i1].Normal.Y, vertices[i1].Normal.Z);
+                glm::vec3(vertices[i0].Normal.X, vertices[i0].Normal.Y, vertices[i0].Normal.Z);
-            glm::vec3 normal2 = glm::vec3(vertices[i2].Normal.X, vertices[i2].Normal.Y, vertices[i2].Normal.Z);
+            glm::vec3 normal1 =
+                glm::vec3(vertices[i1].Normal.X, vertices[i1].Normal.Y, vertices[i1].Normal.Z);
+            glm::vec3 normal2 =
+                glm::vec3(vertices[i2].Normal.X, vertices[i2].Normal.Y, vertices[i2].Normal.Z);
 
             // Edges of the triangle : position delta
             glm::vec3 deltaPos1 = vertex1 - vertex0;
@@ -140,7 +154,8 @@ private:
             return indices;
         } else {
             // Output Error
-            std::cout << "Failed to Load File. May have failed to find it or it was not an .obj file.\n";
+            std::cout
+                << "Failed to Load File. May have failed to find it or it was not an .obj file.\n";
         }
     }
 
@@ -158,12 +173,12 @@ private:
 
             // Print Material
             std::cout << "Material: " << curMesh.MeshMaterial.name << "\n";
-            std::cout << "Ambient Color: " << curMesh.MeshMaterial.Ka.X << ", " << curMesh.MeshMaterial.Ka.Y << ", "
+            std::cout << "Ambient Color: " << curMesh.MeshMaterial.Ka.X << ", "
-                      << curMesh.MeshMaterial.Ka.Z << "\n";
+                      << curMesh.MeshMaterial.Ka.Y << ", " << curMesh.MeshMaterial.Ka.Z << "\n";
-            std::cout << "Diffuse Color: " << curMesh.MeshMaterial.Kd.X << ", " << curMesh.MeshMaterial.Kd.Y << ", "
+            std::cout << "Diffuse Color: " << curMesh.MeshMaterial.Kd.X << ", "
-                      << curMesh.MeshMaterial.Kd.Z << "\n";
+                      << curMesh.MeshMaterial.Kd.Y << ", " << curMesh.MeshMaterial.Kd.Z << "\n";
-            std::cout << "Specular Color: " << curMesh.MeshMaterial.Ks.X << ", " << curMesh.MeshMaterial.Ks.Y << ", "
+            std::cout << "Specular Color: " << curMesh.MeshMaterial.Ks.X << ", "
-                      << curMesh.MeshMaterial.Ks.Z << "\n";
+                      << curMesh.MeshMaterial.Ks.Y << ", " << curMesh.MeshMaterial.Ks.Z << "\n";
             std::cout << "Specular Exponent: " << curMesh.MeshMaterial.Ns << "\n";
             std::cout << "Optical Density: " << curMesh.MeshMaterial.Ni << "\n";
             std::cout << "Dissolve: " << curMesh.MeshMaterial.d << "\n";
@@ -177,7 +192,8 @@ private:
             return vertexData;
         } else {
             // Output Error
-            std::cout << "Failed to Load File. May have failed to find it or it was not an .obj file.\n";
+            std::cout
+                << "Failed to Load File. May have failed to find it or it was not an .obj file.\n";
         }
     }
 };

ECS/Components/PathMove.h

@@ -26,9 +26,7 @@ struct PathMove {
     struct Views {
         Views(std::vector<glm::quat> views) : views(views) {}
 
-        void add_view(glm::quat new_quat) {
+        void add_view(glm::quat new_quat) { views.emplace_back(new_quat); }
-            views.emplace_back(new_quat);
-        }
 
         std::vector<glm::quat> views;
     };
@@ -40,7 +38,8 @@ struct PathMove {
     float time_passed = 0.0;
     int current_point_index = 0;
 
-    int speed_addition = 0;  // 0, -1 or 1 depending on whether the speed should stay, decrease or increase
+    int speed_addition =
+        0; // 0, -1 or 1 depending on whether the speed should stay, decrease or increase
 
     Path path;
     Views views;

ECS/Components/SineAnimation.h

@@ -5,8 +5,11 @@
 #ifndef ECSGAME_SINEANIMATION_H
 #define ECSGAME_SINEANIMATION_H
 
+#include <glm/gtc/matrix_transform.hpp>
+
 struct SineAnimation {
-    SineAnimation(const glm::vec3 &maxDistance, float speedScale) : maxDistance(maxDistance), speedScale(speedScale) {}
+    SineAnimation(const glm::vec3 &maxDistance, float speedScale)
+        : maxDistance(maxDistance), speedScale(speedScale) {}
 
     glm::vec3 maxDistance;
     float speedScale;

ECS/Components/Texture.h

@@ -41,15 +41,12 @@ struct Texture {
         if (data) {
             // Alpha channel?
             unsigned int glChannels = GL_RGB;
-            if (nrChannels == 4) {
+            if (nrChannels == 4) { glChannels = GL_RGBA; }
-                glChannels = GL_RGBA;
-            }
 
-            glTexImage2D(GL_TEXTURE_2D, 0, glChannels, width, height, 0, glChannels, GL_UNSIGNED_BYTE, data);
+            glTexImage2D(GL_TEXTURE_2D, 0, glChannels, width, height, 0, glChannels,
+                         GL_UNSIGNED_BYTE, data);
 
-            if (settings.mipmaps) {
+            if (settings.mipmaps) { glGenerateMipmap(GL_TEXTURE_2D); }
-                glGenerateMipmap(GL_TEXTURE_2D);
-            }
         } else {
             std::cout << "Failed to load texture" << std::endl;
         }
@@ -59,7 +56,8 @@ struct Texture {
         return gl_id;
     }
 
-    explicit Texture(const std::string& path, Settings settings, bool transparent) : id(loadTexture(path, settings)), render_transparent(transparent) {}
+    explicit Texture(const std::string &path, Settings settings, bool transparent)
+        : id(loadTexture(path, settings)), render_transparent(transparent) {}
 
     void addNormalmap(const std::string &path, Settings settings) {
         normal_id = loadTexture(path, settings);

ECS/Components/Transform.h

@@ -17,33 +17,21 @@ struct Transform {
     glm::mat4 matrix = glm::mat4(1.0f); // Initialize as identity
     glm::vec3 origin = glm::vec3(0.0f, 0.0f, 0.0f);
 
-    void translate(glm::vec3 offset) {
+    void translate(glm::vec3 offset) { matrix = glm::translate(matrix, offset); }
-        matrix = glm::translate(matrix, offset);
-    }
 
-    glm::vec3 get_translation() {
+    glm::vec3 get_translation() { return glm::vec3(matrix[3]); }
-        return glm::vec3(matrix[3]);
-    }
 
-    void uniform_scale(float factor) {
+    void uniform_scale(float factor) { scale(glm::vec3(factor, factor, factor)); }
-        scale(glm::vec3(factor, factor, factor));
-    }
 
-    void scale(glm::vec3 factors) {
+    void scale(glm::vec3 factors) { matrix = glm::scale(matrix, factors); }
-        matrix = glm::scale(matrix, factors);
-    }
 
     void rotate(float degrees, glm::vec3 axis) {
         matrix = glm::rotate(matrix, glm::radians(degrees), axis);
     }
 
-    void set_origin(glm::vec3 position) {
+    void set_origin(glm::vec3 position) { origin = position; }
-        origin = position;
-    }
 
-    void add_to_origin(glm::vec3 addition) {
+    void add_to_origin(glm::vec3 addition) { origin += addition; }
-        origin += addition;
-    }
 
     void set_rotation_from_quat(glm::quat quaternion) {
         // Remember translation
@@ -53,21 +41,13 @@ struct Transform {
         matrix[3] = save;
     }
 
-    glm::vec3 get_origin() const {
+    glm::vec3 get_origin() const { return origin; }
-        return origin;
-    }
 
-    glm::vec3 forward() const {
+    glm::vec3 forward() const { return matrix * glm::vec4(0.0, 0.0, -1.0, 0.0); }
-        return matrix * glm::vec4(0.0, 0.0, -1.0, 0.0);
-    }
 
-    glm::vec3 up() const {
+    glm::vec3 up() const { return matrix * glm::vec4(0.0, 1.0, 0.0, 0.0); }
-        return  matrix * glm::vec4(0.0, 1.0, 0.0, 0.0);
-    }
 
-    glm::vec3 right() const {
+    glm::vec3 right() const { return matrix * glm::vec4(1.0, 0.0, 0.0, 0.0); }
-        return matrix * glm::vec4(1.0, 0.0, 0.0, 0.0);
-    }
 };
 
 #endif // ECSGAME_TRANSFORM_H

ECS/Systems/GravitySystem.h

@@ -5,16 +5,14 @@
 #ifndef ECSGAME_GRAVITYSYSTEM_H
 #define ECSGAME_GRAVITYSYSTEM_H
 
-#include "../ECS.h"
 #include "../Components/Transform.h"
+#include "../ECS.h"
 
 using namespace ECS;
 
 class GravitySystem : public EntitySystem {
   public:
-    explicit GravitySystem(float amount) {
+    explicit GravitySystem(float amount) { gravityAmount = amount; }
-        gravityAmount = amount;
-    }
 
     void tick(World *pWorld, float deltaTime) override {
         pWorld->each<Transform>([&](Entity *ent, ComponentHandle<Transform> position) {

ECS/Systems/InteractivePathSystem.h

@@ -1,16 +1,16 @@
 #ifndef __PATHMOVEMENTSWITCHSYSTEM_H__
 #define __PATHMOVEMENTSWITCHSYSTEM_H__
 
-#include <glad/glad.h>
 #include <GLFW/glfw3.h>
+#include <glad/glad.h>
 
 #include <iostream>
 
-#include "../ECS.h"
-#include "../Components/PathMove.h"
-#include "../Events/InputEvent.h"
-#include "../Components/Movement.h" 
 #include "../Components/MouseLook.h"
+#include "../Components/Movement.h"
+#include "../Components/PathMove.h"
+#include "../ECS.h"
+#include "../Events/InputEvent.h"
 
 using namespace ECS;
 
@@ -23,7 +23,9 @@ class InteractivePathSystem : public EntitySystem, public EventSubscriber<InputE
 
     void receive(World *pWorld, const InputEvent &event) override {
         if (event.key == GLFW_KEY_P) {
-            myWorld->each<PathMove, Movement, MouseLook>([&](Entity *ent, ComponentHandle<PathMove> pathmove, ComponentHandle<Movement> movement, ComponentHandle<MouseLook> mouselook) {
+            myWorld->each<PathMove, Movement, MouseLook>(
+                [&](Entity *ent, ComponentHandle<PathMove> pathmove,
+                    ComponentHandle<Movement> movement, ComponentHandle<MouseLook> mouselook) {
                     if (event.action == GLFW_PRESS) {
                         // Switch between them
                         if (pathmove->is_active) {
@@ -38,7 +40,10 @@ class InteractivePathSystem : public EntitySystem, public EventSubscriber<InputE
                     }
                 });
         } else if (event.key == GLFW_KEY_R) {
-            myWorld->each<PathMove, Movement, MouseLook, Transform>([&](Entity *ent, ComponentHandle<PathMove> pathmove, ComponentHandle<Movement> movement, ComponentHandle<MouseLook> mouselook, ComponentHandle<Transform> transform) {
+            myWorld->each<PathMove, Movement, MouseLook, Transform>(
+                [&](Entity *ent, ComponentHandle<PathMove> pathmove,
+                    ComponentHandle<Movement> movement, ComponentHandle<MouseLook> mouselook,
+                    ComponentHandle<Transform> transform) {
                     if (event.action == GLFW_PRESS) {
                         // Add this point to the path
                         pathmove->path.add_point(transform->origin);
@@ -48,9 +53,7 @@ class InteractivePathSystem : public EntitySystem, public EventSubscriber<InputE
         }
     }
 
-    void unconfigure(World *pWorld) override {
+    void unconfigure(World *pWorld) override { pWorld->unsubscribeAll(this); }
-        pWorld->unsubscribeAll(this);
-    }
 
   private:
     World *myWorld;

ECS/Systems/KeyboardMovementSystem.h

@@ -5,15 +5,15 @@
 #ifndef ECSGAME_KEYBOARDMOVEMENTSYSTEM_H
 #define ECSGAME_KEYBOARDMOVEMENTSYSTEM_H
 
-#include <glad/glad.h>
 #include <GLFW/glfw3.h>
+#include <glad/glad.h>
 
 #include <iostream>
 
-#include "../ECS.h"
-#include "../Components/Transform.h"
-#include "../Events/InputEvent.h"
 #include "../Components/Movement.h"
+#include "../Components/Transform.h"
+#include "../ECS.h"
+#include "../Events/InputEvent.h"
 
 using namespace ECS;
 
@@ -61,17 +61,17 @@ class KeyboardMovementSystem : public EntitySystem, public EventSubscriber<Input
     }
 
     void tick(World *pWorld, float deltaTime) override {
-        pWorld->each<Transform, Movement>(
+        pWorld->each<Transform, Movement>([&](Entity *ent, ComponentHandle<Transform> transform,
-                [&](Entity *ent, ComponentHandle<Transform> transform, ComponentHandle<Movement> movement) {
+                                              ComponentHandle<Movement> movement) {
             if (!movement->is_active) return;
 
-                    transform->add_to_origin(transform->matrix * glm::vec4((glm::vec3(movement->moving) * movement->speed * deltaTime), 0.0));
+            transform->add_to_origin(
+                transform->matrix *
+                glm::vec4((glm::vec3(movement->moving) * movement->speed * deltaTime), 0.0));
         });
     }
 
-    void unconfigure(World *pWorld) override {
+    void unconfigure(World *pWorld) override { pWorld->unsubscribeAll(this); }
-        pWorld->unsubscribeAll(this);
-    }
 
   private:
     World *myWorld;

ECS/Systems/MouseLookSystem.h

@@ -5,9 +5,10 @@
 #ifndef ECSGAME_MOUSELOOKSYSTEM_H
 #define ECSGAME_MOUSELOOKSYSTEM_H
 
-#include "../ECS.h"
+#include "../Components/Camera.h"
-#include "../Components/Transform.h"
 #include "../Components/MouseLook.h"
+#include "../Components/Transform.h"
+#include "../ECS.h"
 #include "../Events/MouseMoveEvent.h"
 
 using namespace ECS;
@@ -22,12 +23,12 @@ public:
         myWorld->subscribe<MouseMoveEvent>(this);
     }
 
-    void unconfigure(World *pWorld) override {
+    void unconfigure(World *pWorld) override { pWorld->unsubscribeAll(this); }
-        pWorld->unsubscribeAll(this);
-    }
 
     void receive(World *pWorld, const MouseMoveEvent &event) override {
-        pWorld->each<Transform, MouseLook, Camera>([&](Entity *ent, ComponentHandle<Transform> transform, ComponentHandle<MouseLook> mouse, ComponentHandle<Camera> camera) {
+        pWorld->each<Transform, MouseLook, Camera>(
+            [&](Entity *ent, ComponentHandle<Transform> transform, ComponentHandle<MouseLook> mouse,
+                ComponentHandle<Camera> camera) {
                 double xOffset = lastX - event.newX;
                 double yOffset = lastY - event.newY;
 
@@ -40,16 +41,18 @@ public:
     }
 
     void tick(World *pWorld, float deltaTime) override {
-        pWorld->each<Transform, MouseLook, Camera>([&](Entity *ent, ComponentHandle<Transform> transform, ComponentHandle<MouseLook> mouse, ComponentHandle<Camera> camera) {
+        pWorld->each<Transform, MouseLook, Camera>(
+            [&](Entity *ent, ComponentHandle<Transform> transform, ComponentHandle<MouseLook> mouse,
+                ComponentHandle<Camera> camera) {
                 if (!mouse->is_active) return;
 
-            if(mouse->pitch > 80.0f)
+                if (mouse->pitch > 80.0f) mouse->pitch = 80.0f;
-                mouse->pitch =  80.0f;
+                if (mouse->pitch < -80.0f) mouse->pitch = -80.0f;
-            if(mouse->pitch < -80.0f)
-                mouse->pitch = -80.0f;
 
-            mouse->rotation = glm::angleAxis(glm::radians((float)mouse->yaw), glm::vec3(0.f, 1.f, 0.f));
+                mouse->rotation =
-            mouse->rotation *= glm::angleAxis(glm::radians((float)mouse->pitch), glm::vec3(1.f, 0.f, 0.f));
+                    glm::angleAxis(glm::radians((float)mouse->yaw), glm::vec3(0.f, 1.f, 0.f));
+                mouse->rotation *=
+                    glm::angleAxis(glm::radians((float)mouse->pitch), glm::vec3(1.f, 0.f, 0.f));
 
                 transform->set_rotation_from_quat(mouse->rotation);
             });

ECS/Systems/PathMoveSystem.h

@@ -1,15 +1,15 @@
 #ifndef __PATHMOVESYSTEM_H__
 #define __PATHMOVESYSTEM_H__
 
-#include <glad/glad.h>
 #include <GLFW/glfw3.h>
+#include <glad/glad.h>
 
 #include <iostream>
 
-#include "../ECS.h"
-#include "../Components/Transform.h"
-#include "../Events/InputEvent.h"
 #include "../Components/PathMove.h"
+#include "../Components/Transform.h"
+#include "../ECS.h"
+#include "../Events/InputEvent.h"
 
 using namespace ECS;
 
@@ -75,8 +75,8 @@ class PathMoveSystem : public EntitySystem, public EventSubscriber<InputEvent> {
     }
 
     void tick(World *pWorld, float deltaTime) override {
-        pWorld->each<Transform, PathMove>(
+        pWorld->each<Transform, PathMove>([&](Entity *ent, ComponentHandle<Transform> transform,
-                [&](Entity *ent, ComponentHandle<Transform> transform, ComponentHandle<PathMove> pathmove) {
+                                              ComponentHandle<PathMove> pathmove) {
             if (!pathmove->is_active) return;
 
             // Handle change in speed
@@ -88,7 +88,8 @@ class PathMoveSystem : public EntitySystem, public EventSubscriber<InputEvent> {
 
             // Add the passed time
             float desired_distance = deltaTime * pathmove->speed; // TODO
-                    pathmove->time_passed += desired_distance / path.distances[pathmove->current_point_index];
+            pathmove->time_passed +=
+                desired_distance / path.distances[pathmove->current_point_index];
 
             // Shorthand for number of points in the path
             int num_points = path.points.size();
@@ -99,22 +100,25 @@ class PathMoveSystem : public EntitySystem, public EventSubscriber<InputEvent> {
                 pathmove->current_point_index += 1;
 
                 // If the point index is greater than the second to last one, reset
-                        // (The point index specifies the point we're coming from, not the one we're moving towards)
+                // (The point index specifies the point we're coming from, not the one we're moving
+                // towards)
                 if (pathmove->current_point_index >= num_points - 1) {
                     pathmove->current_point_index = 0;
                 }
             }
 
             // The four points which are needed for the spline
-                    // p1 and p2 are always the same (the current origin and the current target), but the rest depends on edge cases
+            // p1 and p2 are always the same (the current origin and the current target), but the
+            // rest depends on edge cases
             glm::vec3 p0;
             glm::vec3 p1 = path.points[pathmove->current_point_index];
             glm::vec3 p2 = path.points[pathmove->current_point_index + 1];
             glm::vec3 p3;
 
             if (pathmove->current_point_index == num_points - 2) {
-                        // We're moving towards the last point, so the point after that needs to be interpolated.
+                // We're moving towards the last point, so the point after that needs to be
-                        // We interpolate linearly along the line from this point to the target point.
+                // interpolated. We interpolate linearly along the line from this point to the
+                // target point.
                 glm::vec3 interp_direction = p2 - p1;
                 p3 = p2 + interp_direction * 2.0f;
             } else {
@@ -125,7 +129,8 @@ class PathMoveSystem : public EntitySystem, public EventSubscriber<InputEvent> {
             if (pathmove->current_point_index == 0) {
                 // We're at the first point, so the point before this needs to be interpolated.
                 // We interpolate linearly along the line from this to the next point (backwards).
-                        glm::vec3 interp_direction = path.points[pathmove->current_point_index] - path.points[pathmove->current_point_index + 1];
+                glm::vec3 interp_direction = path.points[pathmove->current_point_index] -
+                                             path.points[pathmove->current_point_index + 1];
                 p0 = path.points[pathmove->current_point_index] + interp_direction;
             } else {
                 // We're fine - use the point before the current point
@@ -133,12 +138,7 @@ class PathMoveSystem : public EntitySystem, public EventSubscriber<InputEvent> {
             }
 
             // Calculate the point on the spline
-                    glm::vec3 point = catmul(1.f,
+            glm::vec3 point = catmul(1.f, p0, p1, p2, p3, pathmove->time_passed);
-                            p0,
-                            p1,
-                            p2,
-                            p3,
-                            pathmove->time_passed);
 
             // Apply
             transform->set_origin(point);
@@ -162,7 +162,8 @@ class PathMoveSystem : public EntitySystem, public EventSubscriber<InputEvent> {
             }
 
             if (pathmove->current_point_index == 0) {
-                        // Interpolate what q0 would be if the same change happened from q0 to q1 as from q1 to q2
+                // Interpolate what q0 would be if the same change happened from q0 to q1 as from q1
+                // to q2
                 q0 = glm::fastMix(q1, q2, -1.0f);
             } else {
                 // We're fine - use the point before the current point
@@ -170,16 +171,15 @@ class PathMoveSystem : public EntitySystem, public EventSubscriber<InputEvent> {
             }
 
             // Interpolate
-                    glm::quat result = glm::squad(q1, q2, glm::intermediate(q0, q1, q2), glm::intermediate(q1, q2, q3), pathmove->time_passed);
+            glm::quat result = glm::squad(q1, q2, glm::intermediate(q0, q1, q2),
+                                          glm::intermediate(q1, q2, q3), pathmove->time_passed);
 
             // Apply
             transform->set_rotation_from_quat(result);
         });
     }
 
-    void unconfigure(World *pWorld) override {
+    void unconfigure(World *pWorld) override { pWorld->unsubscribeAll(this); }
-        pWorld->unsubscribeAll(this);
-    }
 
   private:
     World *myWorld;

ECS/Systems/PositionDebugSystem.h

@@ -7,8 +7,8 @@
 
 #include <iostream>
 
-#include "../ECS.h"
 #include "../Components/Transform.h"
+#include "../ECS.h"
 
 using namespace ECS;
 
@@ -16,10 +16,8 @@ class PositionDebugOutputSystem : public EntitySystem {
   public:
     void tick(World *pWorld, float deltaTime) override {
         pWorld->each<Transform>([&](Entity *ent, ComponentHandle<Transform> transform) {
-            std::cout << ent->getEntityId() << ": "
+            std::cout << ent->getEntityId() << ": " << transform->get_origin().x << ", "
-                      << transform->get_origin().x << ", "
+                      << transform->get_origin().y << ", " << transform->get_origin().z
-                      << transform->get_origin().y << ", "
-                      << transform->get_origin().z
                       << std::endl;
         });
     }

ECS/Systems/RenderSystem.h

@@ -5,32 +5,28 @@
 #ifndef ECSGAME_RENDERSYSTEM_H
 #define ECSGAME_RENDERSYSTEM_H
 
-#include "../ECS.h"
+#include "../../Rendering/Material.h"
-#include "../Components/Transform.h"
-#include "../Components/Mesh.h"
-#include "../Components/Camera.h"
 #include "../../Rendering/Shader.h"
+#include "../Components/Camera.h"
+#include "../Components/DirectionalLight.h"
+#include "../Components/LODObjMesh.h"
+#include "../Components/Mesh.h"
 #include "../Components/ObjMesh.h"
 #include "../Components/Texture.h"
-#include "../Components/LODObjMesh.h"
+#include "../Components/Transform.h"
-#include "../Components/DirectionalLight.h"
+#include "../ECS.h"
-#include "../../Rendering/Material.h"
 
 using namespace ECS;
 
 // For Debugging
 unsigned int quadVAO = 0;
 unsigned int quadVBO;
-void renderQuad()
+void renderQuad() {
-{
+    if (quadVAO == 0) {
-    if (quadVAO == 0)
-    {
         float quadVertices[] = {
             // positions        // texture Coords
-            -1.0f,  1.0f, 0.0f, 0.0f, 1.0f,
+            -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0.0f,
-            -1.0f, -1.0f, 0.0f, 0.0f, 0.0f,
+            1.0f,  1.0f, 0.0f, 1.0f, 1.0f, 1.0f,  -1.0f, 0.0f, 1.0f, 0.0f,
-             1.0f,  1.0f, 0.0f, 1.0f, 1.0f,
-             1.0f, -1.0f, 0.0f, 1.0f, 0.0f,
         };
         // setup plane VAO
         glGenVertexArrays(1, &quadVAO);
@@ -41,7 +37,8 @@ void renderQuad()
         glEnableVertexAttribArray(0);
         glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void *)0);
         glEnableVertexAttribArray(1);
-        glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
+        glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float),
+                              (void *)(3 * sizeof(float)));
     }
     glBindVertexArray(quadVAO);
     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
@@ -51,14 +48,11 @@ void renderQuad()
 class RenderSystem : public EntitySystem, public EventSubscriber<InputEvent> {
   public:
     struct RenderObject {
-        RenderObject(const glm::mat4 &matrix, const glm::vec3 &origin, unsigned int textureId, unsigned int normalId, const Mesh &mesh, float distance, const Material &material)
+        RenderObject(const glm::mat4 &matrix, const glm::vec3 &origin, unsigned int textureId,
-                                                                                        : matrix(matrix),
+                     unsigned int normalId, const Mesh &mesh, float distance,
-                                                                                          origin(origin),
+                     const Material &material)
-                                                                                          texture_id(textureId),
+            : matrix(matrix), origin(origin), texture_id(textureId), normal_id(normalId),
-                                                                                          normal_id(normalId),
+              mesh(mesh), distance(distance), material(material) {}
-                                                                                          mesh(mesh),
-                                                                                          distance(distance),
-                                                                                          material(material) {}
 
         void render(Shader shader) const {
             glm::mat4 model_matrix = matrix;
@@ -97,24 +91,31 @@ public:
     std::vector<std::vector<RenderObject>> getRenderObjects(World *world, glm::vec3 cameraPos) {
         std::vector<std::vector<RenderObject>> renderObjects(2); // First normal, then transparent
 
-        /*pWorld->each<Mesh, Transform>([&](Entity *ent, ComponentHandle<Mesh> mesh, ComponentHandle<Transform> transform) {
+        /*pWorld->each<Mesh, Transform>([&](Entity *ent, ComponentHandle<Mesh> mesh,
+        ComponentHandle<Transform> transform) {
             renderObjects.emplace_back(RenderObject(transform->matrix, 0, mesh.get(), 0));
         });*/
 
-        /*// TODO: Is it possible to do get ObjMeshes in the Mesh loop above implicitly via polymorphism?
+        /*// TODO: Is it possible to do get ObjMeshes in the Mesh loop above implicitly via
-            * // TODO: Commented out because of double rendering - we only want to get objects that explicitly DON'T have a texture here!
+        polymorphism?
-        pWorld->each<ObjMesh, Transform>([&](Entity *ent, ComponentHandle<ObjMesh> mesh, ComponentHandle<Transform> transform) {
+            * // TODO: Commented out because of double rendering - we only want to get objects that
-            // Add the object to the renderObjects to draw if the distance is within the min and max distance of the mesh
+        explicitly DON'T have a texture here! pWorld->each<ObjMesh, Transform>([&](Entity *ent,
-            float distance = glm::distance(cameraPos, transform->getPosition());
+        ComponentHandle<ObjMesh> mesh, ComponentHandle<Transform> transform) {
+            // Add the object to the renderObjects to draw if the distance is within the min and max
+        distance of the mesh float distance = glm::distance(cameraPos, transform->getPosition());
 
             if (distance > mesh->minDistance && distance < mesh->maxDistance) {
-                renderObjects.emplace_back(RenderObject(transform->matrix, 0, mesh.get(), distance));
+                renderObjects.emplace_back(RenderObject(transform->matrix, 0, mesh.get(),
+        distance));
             }
         });*/
 
         // ObjMesh with textures
-        world->each<ObjMesh, Transform, Texture>([&](Entity *ent, ComponentHandle<ObjMesh> mesh, ComponentHandle<Transform> transform, ComponentHandle<Texture> texture) {
+        world->each<ObjMesh, Transform, Texture>([&](Entity *ent, ComponentHandle<ObjMesh> mesh,
-            // Add the object to the renderObjects to draw if the distance is within the min and max distance of the mesh
+                                                     ComponentHandle<Transform> transform,
+                                                     ComponentHandle<Texture> texture) {
+            // Add the object to the renderObjects to draw if the distance is within the min and max
+            // distance of the mesh
             float distance = glm::distance(cameraPos, transform->get_origin());
 
             if (distance > mesh->minDistance && distance < mesh->maxDistance) {
@@ -122,21 +123,29 @@ public:
                 ComponentHandle<Texture> textureComponent = ent->get<Texture>();
                 ComponentHandle<Material> materialComponent = ent->get<Material>();
 
-                Material material = materialComponent.isValid() ? materialComponent.get() : Material();
+                Material material =
+                    materialComponent.isValid() ? materialComponent.get() : Material();
                 unsigned int textureID = textureComponent.isValid() ? textureComponent->id : 0;
-                unsigned int normalID = textureComponent.isValid() ? textureComponent->normal_id : 0;
+                unsigned int normalID =
+                    textureComponent.isValid() ? textureComponent->normal_id : 0;
 
-                // Put it into the list of transparent render objects if the texture wants to be rendered transparently
+                // Put it into the list of transparent render objects if the texture wants to be
+                // rendered transparently
                 if (textureComponent.isValid() && textureComponent->render_transparent) {
-                    renderObjects[1].emplace_back(RenderObject(transform->matrix, transform->get_origin(), textureID, normalID, mesh.get(), distance, material));
+                    renderObjects[1].emplace_back(
+                        RenderObject(transform->matrix, transform->get_origin(), textureID,
+                                     normalID, mesh.get(), distance, material));
                 } else {
-                    renderObjects[0].emplace_back(RenderObject(transform->matrix, transform->get_origin(), textureID, normalID, mesh.get(), distance, material));
+                    renderObjects[0].emplace_back(
+                        RenderObject(transform->matrix, transform->get_origin(), textureID,
+                                     normalID, mesh.get(), distance, material));
                 }
             }
         });
 
         // LODObjMesh with Texture
-        world->each<LODObjMesh, Transform>([&](Entity *ent, ComponentHandle<LODObjMesh> lodMesh, ComponentHandle<Transform> transform) {
+        world->each<LODObjMesh, Transform>([&](Entity *ent, ComponentHandle<LODObjMesh> lodMesh,
+                                               ComponentHandle<Transform> transform) {
             float distance = glm::distance(cameraPos, transform->get_origin());
 
             for (const auto &mesh : lodMesh->meshes) {
@@ -145,31 +154,37 @@ public:
                     ComponentHandle<Texture> textureComponent = ent->get<Texture>();
                     ComponentHandle<Material> materialComponent = ent->get<Material>();
 
-                    Material material = materialComponent.isValid() ? materialComponent.get() : Material();
+                    Material material =
+                        materialComponent.isValid() ? materialComponent.get() : Material();
                     unsigned int textureID = textureComponent.isValid() ? textureComponent->id : 0;
-                    unsigned int normalID = textureComponent.isValid() ? textureComponent->normal_id : 0;
+                    unsigned int normalID =
+                        textureComponent.isValid() ? textureComponent->normal_id : 0;
 
-                    // Put it into the list of transparent render objects if the texture wants to be rendered transparently
+                    // Put it into the list of transparent render objects if the texture wants to be
+                    // rendered transparently
                     if (textureComponent.isValid() && textureComponent->render_transparent) {
-                        renderObjects[1].emplace_back(RenderObject(transform->matrix, transform->get_origin(), textureID, normalID, mesh, distance, material));
+                        renderObjects[1].emplace_back(
+                            RenderObject(transform->matrix, transform->get_origin(), textureID,
+                                         normalID, mesh, distance, material));
                     } else {
-                        renderObjects[0].emplace_back(RenderObject(transform->matrix, transform->get_origin(), textureID, normalID, mesh, distance, material));
+                        renderObjects[0].emplace_back(
+                            RenderObject(transform->matrix, transform->get_origin(), textureID,
+                                         normalID, mesh, distance, material));
                     }
                 }
             }
         });
 
         // Sort transparent objects
-        std::sort(renderObjects[1].begin(), renderObjects[1].end(), [](const RenderObject &first, const RenderObject &second) -> bool {
+        std::sort(renderObjects[1].begin(), renderObjects[1].end(),
+                  [](const RenderObject &first, const RenderObject &second) -> bool {
                       return first.distance > second.distance;
                   });
 
         return renderObjects;
     }
 
-    RenderSystem() {
+    RenderSystem() { setup(); }
-        setup();
-    }
 
     void configure(World *pWorld) override {
         myWorld = pWorld;
@@ -196,7 +211,8 @@ public:
         // Create depth texture
         glGenTextures(1, &depthMap);
         glBindTexture(GL_TEXTURE_2D, depthMap);
-        glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, shadow_width, shadow_height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, shadow_width, shadow_height, 0,
+                     GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
@@ -210,11 +226,12 @@ public:
         glBindFramebuffer(GL_FRAMEBUFFER, 0);
     }
 
-
     void render(World *pWorld, Shader normalShader, Shader shadowShader, Shader debugShader) {
-        pWorld->each<Camera, Transform>([&](Entity *ent, ComponentHandle<Camera> camera, ComponentHandle<Transform> cameraTransform) {
+        pWorld->each<Camera, Transform>([&](Entity *ent, ComponentHandle<Camera> camera,
+                                            ComponentHandle<Transform> cameraTransform) {
             // Get render objects
-            std::vector<std::vector<RenderObject>> allRenderObjects = getRenderObjects(pWorld, cameraTransform->get_origin());
+            std::vector<std::vector<RenderObject>> allRenderObjects =
+                getRenderObjects(pWorld, cameraTransform->get_origin());
             std::vector<RenderObject> renderObjects = allRenderObjects[0];
             std::vector<RenderObject> transparentRenderObjects = allRenderObjects[1];
 
@@ -222,12 +239,15 @@ public:
             // Get light direction
             // TODO: Currently only the last light is used!
             glm::vec3 lightDirection;
-            pWorld->each<DirectionalLight>([&](Entity *ent, ComponentHandle<DirectionalLight> light) {
+            pWorld->each<DirectionalLight>(
+                [&](Entity *ent, ComponentHandle<DirectionalLight> light) {
                     lightDirection = light->direction;
                 });
             float near_plane = 1.0f, far_plane = 100.0f;
-            glm::mat4 lightProjection = glm::ortho(-20.0f, 20.0f, -20.0f, 20.0f, near_plane, far_plane);
+            glm::mat4 lightProjection =
-            glm::mat4 lightView = glm::lookAt(lightDirection * 40.0f, -lightDirection, glm::vec3(0.0, 1.0, 0.0));
+                glm::ortho(-20.0f, 20.0f, -20.0f, 20.0f, near_plane, far_plane);
+            glm::mat4 lightView =
+                glm::lookAt(lightDirection * 40.0f, -lightDirection, glm::vec3(0.0, 1.0, 0.0));
             glm::mat4 lightSpaceMatrix = lightProjection * lightView;
 
             // Render shadows

ECS/Systems/SineAnimationSystem.h

@@ -5,9 +5,9 @@
 #ifndef ECSGAME_SINEANIMATIONSYSTEM_H
 #define ECSGAME_SINEANIMATIONSYSTEM_H
 
-#include "../ECS.h"
-#include "../Components/Transform.h"
 #include "../Components/SineAnimation.h"
+#include "../Components/Transform.h"
+#include "../ECS.h"
 
 using namespace ECS;
 
@@ -16,8 +16,11 @@ public:
     void tick(World *pWorld, float deltaTime) override {
         passedTime += deltaTime;
 
-        pWorld->each<Transform, SineAnimation>([&](Entity *ent, ComponentHandle<Transform> transform, ComponentHandle<SineAnimation> anim) {
+        pWorld->each<Transform, SineAnimation>([&](Entity *ent,
-            transform->translate(anim->maxDistance * glm::sin(passedTime * anim->speedScale) * deltaTime);
+                                                   ComponentHandle<Transform> transform,
+                                                   ComponentHandle<SineAnimation> anim) {
+            transform->translate(anim->maxDistance * glm::sin(passedTime * anim->speedScale) *
+                                 deltaTime);
         });
     }
 

Rendering/Shader.cpp

@@ -5,11 +5,11 @@
 #include "Shader.h"
 #include <glad/glad.h>
 
-#include <string>
 #include <fstream>
-#include <sstream>
-#include <iostream>
 #include <glm/gtc/type_ptr.hpp>
+#include <iostream>
+#include <sstream>
+#include <string>
 
 Shader::Shader(const char *vertexPath, const char *fragmentPath) {
     // 1. retrieve the vertex/fragment source code from filePath
@@ -36,8 +36,7 @@ Shader::Shader(const char *vertexPath, const char *fragmentPath) {
         // convert stream into string
         vertexCode = vShaderStream.str();
         fragmentCode = fShaderStream.str();
-    }
+    } catch (std::ifstream::failure &e) {
-    catch (std::ifstream::failure &e) {
         std::cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ" << std::endl;
     }
 
@@ -69,7 +68,6 @@ Shader::Shader(const char *vertexPath, const char *fragmentPath) {
     // delete the shaders as they're linked into our program now and no longer necessary
     glDeleteShader(vertex);
     glDeleteShader(fragment);
-
 }
 
 void Shader::use() {
@@ -92,7 +90,6 @@ void Shader::setMat4(const std::string &name, glm::mat4 mat) const {
     glUniformMatrix4fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, glm::value_ptr(mat));
 }
 
-
 void Shader::setVec3(const std::string &name, glm::vec3 vec) const {
     glUniform3f(glGetUniformLocation(ID, name.c_str()), vec.x, vec.y, vec.z);
 }
@@ -104,15 +101,17 @@ void Shader::checkCompileErrors(unsigned int shader, const std::string &type) {
         glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
         if (!success) {
             glGetShaderInfoLog(shader, 1024, nullptr, infoLog);
-            std::cout << "ERROR::SHADER_COMPILATION_ERROR of type: " << type << "\n" << infoLog
+            std::cout << "ERROR::SHADER_COMPILATION_ERROR of type: " << type << "\n"
-                      << "\n -- --------------------------------------------------- -- " << std::endl;
+                      << infoLog << "\n -- --------------------------------------------------- -- "
+                      << std::endl;
         }
     } else {
         glGetProgramiv(shader, GL_LINK_STATUS, &success);
         if (!success) {
             glGetProgramInfoLog(shader, 1024, nullptr, infoLog);
-            std::cout << "ERROR::PROGRAM_LINKING_ERROR of type: " << type << "\n" << infoLog
+            std::cout << "ERROR::PROGRAM_LINKING_ERROR of type: " << type << "\n"
-                      << "\n -- --------------------------------------------------- -- " << std::endl;
+                      << infoLog << "\n -- --------------------------------------------------- -- "
+                      << std::endl;
         }
     }
 }

Rendering/Shader.h

@@ -5,8 +5,8 @@
 #ifndef ECSGAME_SHADER_H
 #define ECSGAME_SHADER_H
 
-#include <string>
 #include <glm/glm.hpp>
+#include <string>
 
 class Shader {
   public:
@@ -14,7 +14,8 @@ public:
     unsigned int ID;
 
     /// Read and build the shader from the files at vertexPath and fragmentPath.
-    /// Note that an OpenGL context has to be initialized before calling this! Otherwise a SIGSEGV will be thrown.
+    /// Note that an OpenGL context has to be initialized before calling this! Otherwise a SIGSEGV
+    /// will be thrown.
     Shader(const char *vertexPath, const char *fragmentPath);
 
     /// Activate the shader - usually called before rendering.
@@ -39,5 +40,4 @@ private:
     static void checkCompileErrors(unsigned int shader, const std::string &type);
 };
 
-
 #endif // ECSGAME_SHADER_H

main.cpp

@@ -1,4 +1,3 @@
-#include <GLFW/glfw3.h>
 #include <glad/glad.h>
 
 #include <iostream>