Removed Exceptions, moved GL code into Shader

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20141231 ]
+    * No longer using Exceptions.
+    * Moved OpenGL related code from Window into Shader, imguiShader in UI.
+
     [ 20141230 ]
     * Added random number generation utility
     * Added file name searching utilities

include/Exception.h

-/*!
- * \file include/Exception.h
- * \brief Custom global Exception
- *
- * \author xythobuz
- */
-
-#ifndef _EXCEPTION_H_
-#define _EXCEPTION_H_
-
-#include <memory>
-#include <stdexcept>
-#include <string>
-
-class Exception : std::runtime_error {
-  public:
-    Exception(std::string what);
-
-    static std::string getLastException();
-
-  private:
-    static std::string lastException;
-
-    virtual void foo(); //!< We don't want to emit a vtable in every translation unit
-};
-
-#endif
-

include/UI.h

 #include <glm/vec2.hpp>
 #include <glm/gtc/type_precision.hpp>
 
+#include "system/Shader.h"
+
 class ImDrawList;
 
 class UI {
     static std::list<std::tuple<unsigned int, unsigned int, KeyboardButton, bool>> clickEvents;
     static std::list<std::tuple<int, int, int, int>> motionEvents;
     static std::list<std::tuple<int, int>> scrollEvents;
+
+    static Shader imguiShader;
+    static const char* imguiShaderVertex;
+    static const char* imguiShaderFragment;
 };
 
 #endif

include/system/Shader.h

 
 #include "TextureManager.h"
 
+class ShaderBuffer {
+  public:
+    ShaderBuffer() : buffer(0), created(false) { }
+    ~ShaderBuffer();
+
+    void bufferData(int elem, int size, void* data);
+
+    template<typename T>
+    void bufferData(std::vector<T> v)
+        { bufferData(v.size(), sizeof(T), &v[0]); }
+
+    void bindBuffer();
+    void bindBuffer(int location, int size);
+    void unbind(int location);
+
+  private:
+    unsigned int buffer;
+    bool created;
+};
+
 class Shader {
   public:
     Shader() : programID(-1) { }
     unsigned int getBuffer(int n);
 
     template<typename T>
-    void bufferData(int buff, std::vector<T> v) {
-        glBindBuffer(GL_ARRAY_BUFFER, getBuffer(buff));
-        glBufferData(GL_ARRAY_BUFFER, v.size() * sizeof(T), &v[0], GL_STATIC_DRAW);
-    }
+    void bufferData(int buff, std::vector<T> v)
+        { bufferData(buff, v.size(), sizeof(T), &v[0]); }
+    void bufferData(int buff, int elem, int size, void* d);
 
     void loadUniform(int uni, glm::vec2 vec);
     void loadUniform(int uni, glm::vec4 vec);
 
     void disableAttribs();
 
+    static int initialize();
+    static void shutdown();
+
+    static void drawGL(std::vector<glm::vec2>& vertices, std::vector<glm::vec2>& uvs,
+                       glm::vec4 color, unsigned int texture);
+
+    static void drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec2>& uvs,
+                       std::vector<unsigned short>& indices, glm::mat4 MVP, unsigned int texture);
+
+    static void drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& colors,
+                       std::vector<unsigned short>& indices, glm::mat4 MVP, int mode = GL_TRIANGLES);
+
   private:
     int programID;
     std::vector<unsigned int> uniforms;
     std::vector<unsigned int> buffers;
     std::vector<bool> attribs;
+
+    static Shader textShader;
+    static const char* textShaderVertex;
+    static const char* textShaderFragment;
+
+    static Shader textureShader;
+    static const char* textureShaderVertex;
+    static const char* textureShaderFragment;
+
+    static Shader colorShader;
+    static const char* colorShaderVertex;
+    static const char* colorShaderFragment;
+
+    static unsigned int vertexArrayID;
 };
 
 #endif

include/system/Window.h

 #include <glm/vec4.hpp>
 #include <glm/gtc/type_precision.hpp>
 
-#include "Shader.h"
-
 class Window {
   public:
     static int initialize();
 
     static void setTextInput(bool t);
     static bool getTextInput();
-
-    static void drawTextGL(std::vector<glm::vec2>& vertices, std::vector<glm::vec2>& uvs,
-                           glm::vec4 color, unsigned int texture);
-
-    static void drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec2>& uvs,
-                       std::vector<unsigned short>& indices, glm::mat4 MVP, unsigned int texture);
-
-    static void drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& colors,
-                       std::vector<unsigned short>& indices, glm::mat4 MVP, int mode = GL_TRIANGLES);
-
-  private:
-    static int initializeGL();
-    static void shutdownGL();
-
-    static Shader textShader;
-    static const char* textShaderVertex;
-    static const char* textShaderFragment;
-
-    static Shader imguiShader;
-    static const char* imguiShaderVertex;
-    static const char* imguiShaderFragment;
-    friend class UI;
-
-    static Shader textureShader;
-    static const char* textureShaderVertex;
-    static const char* textureShaderFragment;
-
-    static Shader colorShader;
-    static const char* colorShaderVertex;
-    static const char* colorShaderFragment;
-
-    static unsigned int vertexArrayID;
 };
 
 #endif

include/utils/Folder.h

 #ifndef _UTILS_FOLDER_H_
 #define _UTILS_FOLDER_H_
 
-#include "Exception.h"
-
 #include <functional>
 #include <memory>
 #include <string>

src/CMakeLists.txt

 set (SRCS ${SRCS} "Camera.cpp" "../include/Camera.h")
 set (SRCS ${SRCS} "Console.cpp" "../include/Console.h")
 set (SRCS ${SRCS} "Entity.cpp" "../include/Entity.h")
-set (SRCS ${SRCS} "Exception.cpp" "../include/Exception.h")
 set (SRCS ${SRCS} "Game.cpp" "../include/Game.h")
 set (SRCS ${SRCS} "Log.cpp" "../include/Log.h")
 set (SRCS ${SRCS} "main.cpp")

src/Camera.cpp

 
 #include "global.h"
 #include "RunTime.h"
+#include "system/Shader.h"
 #include "system/Window.h"
 #include "Camera.h"
 
         inds.push_back(4 * i);
     }
 
-    Window::drawGL(verts, cols, inds, MVP);
+    Shader::drawGL(verts, cols, inds, MVP);
 
     verts.clear();
     cols.clear();
     verts.push_back(drawPos);
     cols.push_back(glm::vec3(1.0f, 1.0f, 1.0f));
     inds.push_back(0);
-    Window::drawGL(verts, cols, inds, MVP, GL_POINTS);
+    Shader::drawGL(verts, cols, inds, MVP, GL_POINTS);
 }
 

src/Exception.cpp

-/*!
- * \file src/Exception.cpp
- * \brief Custom global Exception
- *
- * \author xythobuz
- */
-
-#include "global.h"
-#include "Exception.h"
-
-std::string Exception::lastException("No custom exception since start!");
-
-Exception::Exception(std::string what) : runtime_error(what) {
-    lastException = what;
-}
-
-std::string Exception::getLastException() {
-    return lastException;
-}
-
-void Exception::foo() { }
-

src/Mesh.cpp

 
 #include "global.h"
 #include "TextureManager.h"
-#include "system/Window.h"
+#include "system/Shader.h"
 #include "Mesh.h"
 
 Mesh::Mesh(const std::vector<glm::vec3>& vert,
                 indexPos++;
 
             std::vector<unsigned short> ind(indices.begin() + indexStart, indices.begin() + indexPos);
-            Window::drawGL(vertices, uvs, ind, MVP, texture);
+            Shader::drawGL(vertices, uvs, ind, MVP, texture);
 
             if (indexPos < indices.size()) {
                 indexStart = indexPos;
     }
 
     if (indicesColor.size() > 0)
-        Window::drawGL(verticesColor, colors, indicesColor, MVP);
+        Shader::drawGL(verticesColor, colors, indicesColor, MVP);
 }
 

src/Render.cpp

 #include "Log.h"
 #include "UI.h"
 #include "World.h"
+#include "system/Shader.h"
 #include "system/Window.h"
 #include "utils/strings.h"
 #include "Render.h"
     uvs.push_back(glm::vec2(1.0f, 1.0f));
     uvs.push_back(glm::vec2(0.0f, 0.0f));
 
-    //! \fixme drawTextGL only uses SYSTEM textures!
+    //! \fixme This drawGL only uses SYSTEM textures!
     assert(s == TextureManager::TextureStorage::SYSTEM);
 
-    Window::drawTextGL(vertices, uvs, color, texture);
+    Shader::drawGL(vertices, uvs, color, texture);
 }
 
 static const int modeStringCount = 4;

src/RoomData.cpp

 #include "global.h"
 #include "SkeletalModel.h"
 #include "World.h"
-#include "system/Window.h"
+#include "system/Shader.h"
 #include "RoomData.h"
 
 void BoundingBox::display(glm::mat4 VP, glm::vec3 colorLine, glm::vec3 colorDot) {
     inds.push_back(5);
     inds.push_back(2);
 
-    Window::drawGL(verts, cols, inds, VP, GL_LINE_STRIP);
+    Shader::drawGL(verts, cols, inds, VP, GL_LINE_STRIP);
 
     cols.clear();
     inds.clear();
         inds.push_back(i);
     }
 
-    Window::drawGL(verts, cols, inds, VP, GL_POINTS);
+    Shader::drawGL(verts, cols, inds, VP, GL_POINTS);
 }
 
 // ----------------------------------------------------------------------------

src/RoomMesh.cpp

 #include "global.h"
 #include "Mesh.h"
 #include "TextureManager.h"
-#include "system/Window.h"
+#include "system/Shader.h"
 #include "RoomMesh.h"
 
 RoomMesh::RoomMesh(const std::vector<RoomVertexTR2>& vert,
                 indexPos++;
 
             std::vector<unsigned short> ind(indices.begin() + indexStart, indices.begin() + indexPos);
-            Window::drawGL(vertices, uvs, ind, MVP, texture);
+            Shader::drawGL(vertices, uvs, ind, MVP, texture);
 
             if (indexPos < indices.size()) {
                 indexStart = indexPos;

src/UI.cpp

 #include "utils/time.h"
 #include "UI.h"
 
+Shader UI::imguiShader;
 bool UI::visible = false;
 unsigned int UI::fontTex;
 std::string UI::iniFilename;
 }
 
 int UI::initialize() {
+    if (imguiShader.compile(imguiShaderVertex, imguiShaderFragment) < 0)
+        return -1;
+    if (imguiShader.addUniform("screen") < 0)
+        return -2;
+    if (imguiShader.addUniform("textureSampler") < 0)
+        return -3;
+    imguiShader.addBuffer(3);
+
     iniFilename = RunTime::getBaseDir() + "/imgui.ini";
     logFilename = RunTime::getBaseDir() + "/imgui_log.txt";
 
     glEnable(GL_SCISSOR_TEST);
     glDisable(GL_DEPTH_TEST);
 
-    Window::imguiShader.use();
-    Window::imguiShader.loadUniform(0, Window::getSize());
-    Window::imguiShader.loadUniform(1, fontTex, TextureManager::TextureStorage::SYSTEM);
-    Window::imguiShader.bindBuffer(0, 0, 2);
-    Window::imguiShader.bindBuffer(1, 1, 2);
-    Window::imguiShader.bindBuffer(2, 2, 4);
+    imguiShader.use();
+    imguiShader.loadUniform(0, Window::getSize());
+    imguiShader.loadUniform(1, fontTex, TextureManager::TextureStorage::SYSTEM);
+    imguiShader.bindBuffer(0, 0, 2);
+    imguiShader.bindBuffer(1, 1, 2);
+    imguiShader.bindBuffer(2, 2, 4);
 
     std::vector<glm::vec2> vertices;
     std::vector<glm::vec2> uvs;
 
             offset += commands[n].vtx_count;
 
-            Window::imguiShader.bufferData(0, vertices);
-            Window::imguiShader.bufferData(1, uvs);
-            Window::imguiShader.bufferData(2, colors);
+            imguiShader.bufferData(0, vertices);
+            imguiShader.bufferData(1, uvs);
+            imguiShader.bufferData(2, colors);
 
             glScissor(commands[n].clip_rect.x,
                       Window::getSize().y - commands[n].clip_rect.w,
         }
     }
 
-    Window::imguiShader.disableAttribs();
+    imguiShader.disableAttribs();
 
     glEnable(GL_DEPTH_TEST);
     glDisable(GL_SCISSOR_TEST);
 }
 
+// --------------------------------------
+// *INDENT-OFF*
+
+const char* UI::imguiShaderVertex = R"!?!(
+#version 330 core
+
+layout(location = 0) in vec2 vertexPosition_screen;
+layout(location = 1) in vec2 vertexUV;
+layout(location = 2) in vec4 vertexColor;
+
+out vec2 UV;
+out vec4 FragColor;
+
+uniform vec2 screen;
+
+void main() {
+    vec2 halfScreen = screen / 2;
+    vec2 vertexPosition_homogenous = (vertexPosition_screen - halfScreen) / halfScreen;
+
+    gl_Position = vec4(vertexPosition_homogenous.x, -vertexPosition_homogenous.y, 0, 1);
+    UV = vertexUV;
+    FragColor = vertexColor;
+}
+)!?!";
+
+const char* UI::imguiShaderFragment = R"!?!(
+#version 330 core
+
+in vec2 UV;
+in vec4 FragColor;
+
+out vec4 color;
+
+uniform sampler2D textureSampler;
+
+void main() {
+    color = texture(textureSampler, UV) * FragColor;
+}
+)!?!";
+
+// --------------------------------------
+// *INDENT-ON*
+

src/main.cpp

 
 #include "global.h"
 #include "Camera.h"
-#include "Exception.h"
 #include "Game.h"
 #include "Log.h"
 #include "MenuFolder.h"
 #include "commander/commander.h"
 #include "commands/Command.h"
 #include "system/Font.h"
+#include "system/Shader.h"
 #include "system/Sound.h"
 #include "system/Window.h"
 #include "utils/time.h"
     // Initialize Windowing
     int error = Window::initialize();
     if (error != 0) {
-        std::cout << "Could not initialize Window/GL (" << error << ")!" << std::endl;
+        std::cout << "Could not initialize Window (" << error << ")!" << std::endl;
         return -1;
     }
 
+    error = Shader::initialize();
+    if (error != 0) {
+        std::cout << "Could not initialize OpenGL (" << error << ")!" << std::endl;
+        return -2;
+    }
+
     // Initialize Texture Manager
     error = getTextureManager().initialize();
     if (error != 0) {
         std::cout << "Could not initialize TextureManager (" << error << ")!" << std::endl;
-        return -2;
+        return -3;
     }
 
     if (configFileToUse == "") {
     error = getTextureManager().initializeSplash();
     if (error != 0) {
         std::cout << "Coult not load Splash Texture (" << error << ")!" << std::endl;
-        return -3;
+        return -4;
     }
 
     // Initialize Sound
     error = Sound::initialize();
     if (error != 0) {
         std::cout << "Could not initialize Sound (" << error << ")!" << std::endl;
-        return -4;
+        return -5;
     }
 
     // Initialize Menu
     error = getMenu().initialize();
     if (error != 0) {
         std::cout << "Could not initialize Menu (" << error << ")!" << std::endl;
-        return -5;
+        return -6;
     }
 
     // Initialize Debug UI
     error = UI::initialize();
     if (error != 0) {
         std::cout << "Could not initialize Debug UI (" << error << ")!" << std::endl;
-        return -6;
+        return -7;
     }
 
     // Initialize Game Engine
     error = getGame().initialize();
     if (error != 0) {
         std::cout << "Could not initialize Game (" << error << ")!" << std::endl;
-        return -7;
+        return -8;
     }
 
     getLog() << "Starting " << VERSION << Log::endl;
     UI::shutdown();
     Font::shutdown();
     Sound::shutdown();
+    Shader::shutdown();
     Window::shutdown();
 
 #ifdef DEBUG
 
         delete [] strs;
 
-        std::cout << std::endl << "Last custom Exception:" << std::endl;
-        std::cout << "    " << Exception::getLastException() << std::endl << std::endl;
-
         oldTerminateHandler();
         abort();
     }

src/system/FontSDL.cpp

 
 #include "global.h"
 #include "TextureManager.h"
-#include "system/Window.h"
+#include "system/Shader.h"
 #include "system/FontSDL.h"
 
 bool FontSDL::mFontInit = false;
     uvs.push_back(glm::vec2(1.0f, 1.0f));
     uvs.push_back(glm::vec2(0.0f, 0.0f));
 
-    Window::drawTextGL(vertices, uvs, glm::vec4(1.0f, 1.0f, 1.0f, 1.0f), mFontTexture);
+    Shader::drawGL(vertices, uvs, glm::vec4(1.0f, 1.0f, 1.0f, 1.0f), mFontTexture);
 }
 
 unsigned int FontSDL::heightText(float scale, unsigned int maxWidth, std::string s) {
     uvs.push_back(glm::vec2(1.0f, 1.0f));
     uvs.push_back(glm::vec2(0.0f, 0.0f));
 
-    Window::drawTextGL(vertices, uvs, glm::vec4(1.0f, 1.0f, 1.0f, 1.0f), mFontTexture);
+    Shader::drawGL(vertices, uvs, glm::vec4(1.0f, 1.0f, 1.0f, 1.0f), mFontTexture);
 }
 

src/system/FontTRLE.cpp

 #include "global.h"
 #include "TextureManager.h"
 #include "utils/strings.h"
-#include "system/Window.h"
+#include "system/Shader.h"
 #include "system/FontTRLE.h"
 
 #define SCALING 2.0f
     }
 
     glm::vec4 col(color[0] / 256.0f, color[1] / 256.0f, color[2] / 256.0f, color[3] / 256.0f);
-    Window::drawTextGL(vertices, uvs, col, mFontTexture);
+    Shader::drawGL(vertices, uvs, col, mFontTexture);
 }
 
 unsigned int FontTRLE::heightText(float scale, unsigned int maxWidth, std::string s) {
     }
 
     glm::vec4 col(color[0] / 256.0f, color[1] / 256.0f, color[2] / 256.0f, color[3] / 256.0f);
-    Window::drawTextGL(vertices, uvs, col, mFontTexture);
+    Shader::drawGL(vertices, uvs, col, mFontTexture);
 }
 
 int FontTRLE::defaultOffsets[106][5] = {

src/system/Shader.cpp

 #include "global.h"
 #include "Log.h"
 #include "TextureManager.h"
+#include "system/Window.h"
 #include "system/Shader.h"
 
+ShaderBuffer::~ShaderBuffer() {
+    if (created) {
+        glDeleteBuffers(1, &buffer);
+    }
+}
+
+void ShaderBuffer::bufferData(int elem, int size, void* data) {
+    if (!created) {
+        glGenBuffers(1, &buffer);
+        created = true;
+    }
+
+    glBindBuffer(GL_ARRAY_BUFFER, buffer);
+    glBufferData(GL_ARRAY_BUFFER, elem * size, data, GL_STATIC_DRAW);
+}
+
+void ShaderBuffer::bindBuffer() {
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer);
+}
+
+void ShaderBuffer::bindBuffer(int location, int size) {
+    glEnableVertexAttribArray(location);
+    glBindBuffer(GL_ARRAY_BUFFER, buffer);
+    glVertexAttribPointer(location, size, GL_FLOAT, GL_FALSE, 0, nullptr);
+}
+
+void ShaderBuffer::unbind(int location) {
+    glDisableVertexAttribArray(location);
+}
+
+// ----------------------------------------------------------------------------
+
 Shader::~Shader() {
     if (programID >= 0)
         glDeleteProgram(programID);
     return buffers.at(n);
 }
 
+void Shader::bufferData(int buff, int elem, int size, void* d) {
+    glBindBuffer(GL_ARRAY_BUFFER, getBuffer(buff));
+    glBufferData(GL_ARRAY_BUFFER, elem * size, d, GL_STREAM_DRAW);
+}
+
 void Shader::loadUniform(int uni, glm::vec2 vec) {
     glUniform2f(getUniform(uni), vec.x, vec.y);
 }
     return programID;
 }
 
+// ----------------------------------------------------------------------------
+
+Shader Shader::textShader;
+Shader Shader::textureShader;
+Shader Shader::colorShader;
+unsigned int Shader::vertexArrayID = 0;
+
+int Shader::initialize() {
+    getLog() << "GL Ven.: " << glGetString(GL_VENDOR) << Log::endl;
+    getLog() << "GL Ren.: " << glGetString(GL_RENDERER) << Log::endl;
+    getLog() << "GL Ver.: " << glGetString(GL_VERSION) << Log::endl;
+    getLog() << "GLSL V.: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << Log::endl;
+
+    glGenVertexArrays(1, &vertexArrayID);
+    glBindVertexArray(vertexArrayID);
+
+    // Set background to black
+    //glClearColor(BLACK[0] / 256.0f, BLACK[1] / 256.0f, BLACK[2] / 256.0f, BLACK[3] / 256.0f);
+    glClearColor(0.0f, 0.0f, 0.4f, 1.0f);
+
+    // Set up Z buffer
+    glEnable(GL_DEPTH_TEST);
+    // Accept fragment if closer to camera
+    glDepthFunc(GL_LESS);
+
+    // Set up culling
+    //glEnable(GL_CULL_FACE); //! \todo Transparency?
+
+    glPointSize(5.0f);
+
+    if (textShader.compile(textShaderVertex, textShaderFragment) < 0)
+        return -1;
+    if (textShader.addUniform("screen") < 0)
+        return -2;
+    if (textShader.addUniform("textureSampler") < 0)
+        return -3;
+    if (textShader.addUniform("colorVar") < 0)
+        return -4;
+    textShader.addBuffer(2);
+
+    if (textureShader.compile(textureShaderVertex, textureShaderFragment) < 0)
+        return -5;
+    if (textureShader.addUniform("MVP") < 0)
+        return -6;
+    if (textureShader.addUniform("textureSampler") < 0)
+        return -7;
+    textureShader.addBuffer(3);
+
+    if (colorShader.compile(colorShaderVertex, colorShaderFragment) < 0)
+        return -8;
+    if (colorShader.addUniform("MVP") < 0)
+        return -9;
+    colorShader.addBuffer(3);
+
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    return 0;
+}
+
+void Shader::shutdown() {
+    glDeleteVertexArrays(1, &vertexArrayID);
+}
+
+void Shader::drawGL(std::vector<glm::vec2>& vertices, std::vector<glm::vec2>& uvs,
+                    glm::vec4 color, unsigned int texture) {
+    assert(vertices.size() == uvs.size());
+    assert((vertices.size() % 3) == 0);
+
+    textShader.bufferData(0, vertices);
+    textShader.bufferData(1, uvs);
+    textShader.use();
+    textShader.loadUniform(0, Window::getSize());
+    textShader.loadUniform(1, texture, TextureManager::TextureStorage::SYSTEM);
+    textShader.loadUniform(2, color);
+    textShader.bindBuffer(0, 0, 2);
+    textShader.bindBuffer(1, 1, 2);
+
+    glDisable(GL_DEPTH_TEST);
+    glDrawArrays(GL_TRIANGLES, 0, vertices.size());
+    glEnable(GL_DEPTH_TEST);
+
+    textShader.disableAttribs();
+}
+
+void Shader::drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec2>& uvs,
+                    std::vector<unsigned short>& indices, glm::mat4 MVP, unsigned int texture) {
+    assert(vertices.size() == uvs.size());
+    assert((indices.size() % 3) == 0);
+
+    textureShader.bufferData(0, vertices);
+    textureShader.bufferData(1, uvs);
+    textureShader.bufferData(2, indices);
+    textureShader.use();
+    textureShader.loadUniform(0, MVP);
+    textureShader.loadUniform(1, texture, TextureManager::TextureStorage::GAME);
+    textureShader.bindBuffer(0, 0, 3);
+    textureShader.bindBuffer(1, 1, 2);
+    textureShader.bindBuffer(2);
+    glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_SHORT, nullptr);
+    textureShader.disableAttribs();
+}
+
+void Shader::drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& colors,
+                    std::vector<unsigned short>& indices, glm::mat4 MVP, int mode) {
+    assert(vertices.size() == colors.size());
+
+    colorShader.bufferData(0, vertices);
+    colorShader.bufferData(1, colors);
+    colorShader.bufferData(2, indices);
+    colorShader.use();
+    colorShader.loadUniform(0, MVP);
+    colorShader.bindBuffer(0, 0, 3);
+    colorShader.bindBuffer(1, 1, 3);
+    colorShader.bindBuffer(2);
+    glDrawElements(mode, indices.size(), GL_UNSIGNED_SHORT, nullptr);
+    colorShader.disableAttribs();
+}
+
+// --------------------------------------
+// *INDENT-OFF*
+
+const char* Shader::textShaderVertex = R"!?!(
+#version 330 core
+
+layout(location = 0) in vec2 vertexPosition_screen;
+layout(location = 1) in vec2 vertexUV;
+
+out vec2 UV;
+
+uniform vec2 screen;
+
+void main() {
+    vec2 halfScreen = screen / 2;
+    vec2 vertexPosition_homogenous = (vertexPosition_screen - halfScreen) / halfScreen;
+
+    gl_Position = vec4(vertexPosition_homogenous.x, -vertexPosition_homogenous.y, 0, 1);
+    UV = vertexUV;
+}
+)!?!";
+
+const char* Shader::textShaderFragment = R"!?!(
+#version 330 core
+
+in vec2 UV;
+
+out vec4 color;
+
+uniform sampler2D textureSampler;
+uniform vec4 colorVar;
+
+void main() {
+    color = texture(textureSampler, UV) * colorVar;
+}
+)!?!";
+
+// --------------------------------------
+
+const char* Shader::textureShaderVertex = R"!?!(
+#version 330 core
+
+layout(location = 0) in vec3 vertexPosition_modelspace;
+layout(location = 1) in vec2 vertexUV;
+
+out vec2 UV;
+
+uniform mat4 MVP;
+
+void main() {
+    vec4 pos = MVP * vec4(vertexPosition_modelspace.x,
+                          -vertexPosition_modelspace.y,
+                          vertexPosition_modelspace.z,
+                          1);
+    gl_Position = vec4(-pos.x, pos.yzw);
+    UV = vertexUV;
+}
+)!?!";
+
+const char* Shader::textureShaderFragment = R"!?!(
+#version 330 core
+
+in vec2 UV;
+
+out vec4 color;
+
+uniform sampler2D textureSampler;
+
+void main() {
+    color = texture(textureSampler, UV);
+}
+)!?!";
+
+// --------------------------------------
+
+const char* Shader::colorShaderVertex = R"!?!(
+#version 330 core
+
+layout(location = 0) in vec3 vertexPosition_modelspace;
+layout(location = 1) in vec3 vertexColor;
+
+out vec3 Color;
+
+uniform mat4 MVP;
+
+void main() {
+    vec4 pos = MVP * vec4(vertexPosition_modelspace.x,
+                          -vertexPosition_modelspace.y,
+                          vertexPosition_modelspace.z,
+                          1);
+    gl_Position = vec4(-pos.x, pos.yzw);
+    Color = vertexColor;
+}
+)!?!";
+
+const char* Shader::colorShaderFragment = R"!?!(
+#version 330 core
+
+in vec3 Color;
+
+out vec4 color;
+
+void main() {
+    color = vec4(Color, 1);
+}
+)!?!";
+
+// --------------------------------------
+// *INDENT-ON*
+

src/system/Window.cpp

 
 #include "global.h"
 #include "Camera.h"
-#include "Log.h"
 #include "UI.h"
-#include "utils/strings.h"
 #include "system/Window.h"
 
 #ifdef USING_SDL
 #else
     res = -1;
 #endif
-
-    initializeGL();
     return res;
 }
 
 }
 
 void Window::shutdown() {
-    shutdownGL();
-
 #ifdef USING_SDL
     WindowSDL::shutdown();
 #elif defined(USING_GLFW)
     return ret;
 }
 
-// --------------------------------------
-
-Shader Window::textShader;
-Shader Window::imguiShader;
-Shader Window::textureShader;
-Shader Window::colorShader;
-unsigned int Window::vertexArrayID = 0;
-
-int Window::initializeGL() {
-    getLog() << "GL Ven.: " << glGetString(GL_VENDOR) << Log::endl;
-    getLog() << "GL Ren.: " << glGetString(GL_RENDERER) << Log::endl;
-    getLog() << "GL Ver.: " << glGetString(GL_VERSION) << Log::endl;
-    getLog() << "GLSL V.: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << Log::endl;
-
-    glGenVertexArrays(1, &vertexArrayID);
-    glBindVertexArray(vertexArrayID);
-
-    // Set background to black
-    //glClearColor(BLACK[0] / 256.0f, BLACK[1] / 256.0f, BLACK[2] / 256.0f, BLACK[3] / 256.0f);
-    glClearColor(0.0f, 0.0f, 0.4f, 1.0f);
-
-    // Set up Z buffer
-    glEnable(GL_DEPTH_TEST);
-    // Accept fragment if closer to camera
-    glDepthFunc(GL_LESS);
-
-    // Set up culling
-    //glEnable(GL_CULL_FACE); //! \todo Transparency?
-
-    glPointSize(5.0f);
-
-    if (textShader.compile(textShaderVertex, textShaderFragment) < 0)
-        return -1;
-    if (textShader.addUniform("screen") < 0)
-        return -2;
-    if (textShader.addUniform("textureSampler") < 0)
-        return -3;
-    if (textShader.addUniform("colorVar") < 0)
-        return -4;
-    textShader.addBuffer(2);
-
-    if (imguiShader.compile(imguiShaderVertex, imguiShaderFragment) < 0)
-        return -5;
-    if (imguiShader.addUniform("screen") < 0)
-        return -6;
-    if (imguiShader.addUniform("textureSampler") < 0)
-        return -7;
-    imguiShader.addBuffer(3);
-
-    if (textureShader.compile(textureShaderVertex, textureShaderFragment) < 0)
-        return -8;
-    if (textureShader.addUniform("MVP") < 0)
-        return -9;
-    if (textureShader.addUniform("textureSampler") < 0)
-        return -10;
-    textureShader.addBuffer(3);
-
-    if (colorShader.compile(colorShaderVertex, colorShaderFragment) < 0)
-        return -11;
-    if (colorShader.addUniform("MVP") < 0)
-        return -12;
-    colorShader.addBuffer(3);
-
-    glEnable(GL_BLEND);
-    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-
-    return 0;
-}
-
-void Window::shutdownGL() {
-    glDeleteVertexArrays(1, &vertexArrayID);
-}
-
-void Window::drawTextGL(std::vector<glm::vec2>& vertices, std::vector<glm::vec2>& uvs,
-                        glm::vec4 color, unsigned int texture) {
-    assert(vertices.size() == uvs.size());
-    assert((vertices.size() % 3) == 0);
-
-    textShader.bufferData(0, vertices);
-    textShader.bufferData(1, uvs);
-    textShader.use();
-    textShader.loadUniform(0, getSize());
-    textShader.loadUniform(1, texture, TextureManager::TextureStorage::SYSTEM);
-    textShader.loadUniform(2, color);
-    textShader.bindBuffer(0, 0, 2);
-    textShader.bindBuffer(1, 1, 2);
-
-    glDisable(GL_DEPTH_TEST);
-    glDrawArrays(GL_TRIANGLES, 0, vertices.size());
-    glEnable(GL_DEPTH_TEST);
-
-    textShader.disableAttribs();
-}
-
-void Window::drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec2>& uvs,
-                    std::vector<unsigned short>& indices, glm::mat4 MVP, unsigned int texture) {
-    assert(vertices.size() == uvs.size());
-    assert((indices.size() % 3) == 0);
-
-    textureShader.bufferData(0, vertices);
-    textureShader.bufferData(1, uvs);
-    textureShader.bufferData(2, indices);
-    textureShader.use();
-    textureShader.loadUniform(0, MVP);
-    textureShader.loadUniform(1, texture, TextureManager::TextureStorage::GAME);
-    textureShader.bindBuffer(0, 0, 3);
-    textureShader.bindBuffer(1, 1, 2);
-    textureShader.bindBuffer(2);
-    glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_SHORT, nullptr);
-    textureShader.disableAttribs();
-}
-
-void Window::drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& colors,
-                    std::vector<unsigned short>& indices, glm::mat4 MVP, int mode) {
-    assert(vertices.size() == colors.size());
-
-    colorShader.bufferData(0, vertices);
-    colorShader.bufferData(1, colors);
-    colorShader.bufferData(2, indices);
-    colorShader.use();
-    colorShader.loadUniform(0, MVP);
-    colorShader.bindBuffer(0, 0, 3);
-    colorShader.bindBuffer(1, 1, 3);
-    colorShader.bindBuffer(2);
-    glDrawElements(mode, indices.size(), GL_UNSIGNED_SHORT, nullptr);
-    colorShader.disableAttribs();
-}
-
-// --------------------------------------
-// *INDENT-OFF*
-
-const char* Window::textShaderVertex = R"!?!(
-#version 330 core
-
-layout(location = 0) in vec2 vertexPosition_screen;
-layout(location = 1) in vec2 vertexUV;
-
-out vec2 UV;
-
-uniform vec2 screen;
-
-void main() {
-    vec2 halfScreen = screen / 2;
-    vec2 vertexPosition_homogenous = (vertexPosition_screen - halfScreen) / halfScreen;
-
-    gl_Position = vec4(vertexPosition_homogenous.x, -vertexPosition_homogenous.y, 0, 1);
-    UV = vertexUV;
-}
-)!?!";
-
-const char* Window::textShaderFragment = R"!?!(
-#version 330 core
-
-in vec2 UV;
-
-out vec4 color;
-
-uniform sampler2D textureSampler;
-uniform vec4 colorVar;
-
-void main() {
-    color = texture(textureSampler, UV) * colorVar;
-}
-)!?!";
-
-// --------------------------------------
-
-const char* Window::imguiShaderVertex = R"!?!(
-#version 330 core
-
-layout(location = 0) in vec2 vertexPosition_screen;
-layout(location = 1) in vec2 vertexUV;
-layout(location = 2) in vec4 vertexColor;
-
-out vec2 UV;
-out vec4 FragColor;
-
-uniform vec2 screen;
-
-void main() {
-    vec2 halfScreen = screen / 2;
-    vec2 vertexPosition_homogenous = (vertexPosition_screen - halfScreen) / halfScreen;
-
-    gl_Position = vec4(vertexPosition_homogenous.x, -vertexPosition_homogenous.y, 0, 1);
-    UV = vertexUV;
-    FragColor = vertexColor;
-}
-)!?!";
-
-const char* Window::imguiShaderFragment = R"!?!(
-#version 330 core
-
-in vec2 UV;
-in vec4 FragColor;
-
-out vec4 color;
-
-uniform sampler2D textureSampler;
-
-void main() {
-    color = texture(textureSampler, UV) * FragColor;
-}
-)!?!";
-
-// --------------------------------------
-
-const char* Window::textureShaderVertex = R"!?!(
-#version 330 core
-
-layout(location = 0) in vec3 vertexPosition_modelspace;
-layout(location = 1) in vec2 vertexUV;
-
-out vec2 UV;
-
-uniform mat4 MVP;
-
-void main() {
-    vec4 pos = MVP * vec4(vertexPosition_modelspace.x,
-                          -vertexPosition_modelspace.y,
-                          vertexPosition_modelspace.z,
-                          1);
-    gl_Position = vec4(-pos.x, pos.yzw);
-    UV = vertexUV;
-}
-)!?!";
-
-const char* Window::textureShaderFragment = R"!?!(
-#version 330 core
-
-in vec2 UV;
-
-out vec4 color;
-
-uniform sampler2D textureSampler;
-
-void main() {
-    color = texture(textureSampler, UV);
-}
-)!?!";
-
-// --------------------------------------
-
-const char* Window::colorShaderVertex = R"!?!(
-#version 330 core
-
-layout(location = 0) in vec3 vertexPosition_modelspace;
-layout(location = 1) in vec3 vertexColor;
-
-out vec3 Color;
-
-uniform mat4 MVP;
-
-void main() {
-    vec4 pos = MVP * vec4(vertexPosition_modelspace.x,
-                          -vertexPosition_modelspace.y,
-                          vertexPosition_modelspace.z,
-                          1);
-    gl_Position = vec4(-pos.x, pos.yzw);
-    Color = vertexColor;
-}
-)!?!";
-
-const char* Window::colorShaderFragment = R"!?!(
-#version 330 core
-
-in vec3 Color;
-
-out vec4 color;
-
-void main() {
-    color = vec4(Color, 1);
-}
-)!?!";
-
-// --------------------------------------
-// *INDENT-ON*
-

src/utils/Folder.cpp

 #include <cstring>
 
 #include "global.h"
+#include <Log.h>
 #include "utils/filesystem.h"
 #include "utils/strings.h"
 #include "utils/Folder.h"
         return;
 
     std::vector<std::string> foundFiles, foundFolders;
-    if (readFolderItems(foundFiles, foundFolders) != 0)
-        throw Exception(std::string("Could not open folder ") + name);
+    if (readFolderItems(foundFiles, foundFolders) != 0) {
+        getLog() << "Could not open folder " << name << Log::endl;
+    }
 
     if (!listDot) {
         std::vector<std::string>::iterator it = foundFiles.begin();

src/utils/binary.cpp

 #include <sstream>
 
 #include "global.h"
-#include "Exception.h"
 #include "utils/binary.h"
 
 BinaryReader::~BinaryReader() {
 void BinaryMemory::read(char* d, int c) {
     assert(offset >= 0);
     assert(c > 0);
-    if ((offset + c) > max) {
-        std::ostringstream ss;
-        ss << "BinaryMemory read out of bounds ("
-           << offset << " + " << c << " > " << max << ")";
-        throw new Exception(ss.str());
-    }
-
+    assert((offset + c) <= max);
     for (int i = 0; i < c; i++) {
         d[i] = data[offset + i];
     }

test/CMakeLists.txt

 
 add_executable (tester_binary EXCLUDE_FROM_ALL
     "binary.cpp" "../src/utils/binary.cpp"
-    "../src/Exception.cpp"
 )
 add_dependencies (check tester_binary)
 add_test (NAME test_binary COMMAND tester_binary)
 
 add_executable (tester_script EXCLUDE_FROM_ALL
     "Script.cpp" "ScriptPayload.h" "ScriptTest.h"
-    "../src/Script.cpp" "../src/Exception.cpp"
-    "../src/utils/binary.cpp"
+    "../src/Script.cpp" "../src/utils/binary.cpp"
 )
 
 find_package (ZLIB REQUIRED)