Windowing classes now static. Tried to clamp camera rotation.

ChangeLog.md

@@ -4,6 +4,9 @@
 
     [ 20141228 ]
     * Room Bounding Boxes are now visualized in Wireframe mode (again)
+    * Window/WindowSDL/WindowGLFW are now completely static
+    * Shader class got some helper methods. Now in own file, system/Shader.
+    * Tried to limit camera vertical rotation.
 
     [ 20141227 ]
     * Added rudimentary SDL2 Game Controller support.

include/Camera.h

@@ -56,7 +56,7 @@ class Camera {
     static glm::mat4 projection;
     static glm::mat4 view;
     static float rotationDeltaX, rotationDeltaY;
-    static bool updateViewFrustum;
+    static bool updateViewFrustum, dirty;
 };
 
 #endif

include/Log.h

@@ -11,6 +11,8 @@
 #include <string>
 #include <sstream>
 #include <vector>
+#include <glm/vec2.hpp>
+#include <glm/vec3.hpp>
 
 class Log {
   public:
@@ -35,6 +37,14 @@ class Log {
         return (*this);
     }
 
+    Log& operator<< (const glm::vec2& v) {
+        return (*this) << v.x << " " << v.y;
+    }
+
+    Log& operator<< (const glm::vec3& v) {
+        return (*this) << v.x << " " << v.y << " " << v.z;
+    }
+
   private:
     std::vector<std::string> mHistory;
     std::ostringstream printBuffer;

include/RoomData.h

@@ -40,7 +40,7 @@ class BoundingBox {
         return corner[i];
     }
 
-    void display(glm::mat4 VP, glm::vec3 color);
+    void display(glm::mat4 VP);
 
   private:
     glm::vec3 corner[8];

include/system/Font.h

@@ -1,5 +1,5 @@
 /*!
- * \file include/Font.h
+ * \file include/system/Font.h
  * \brief Font interface
  *
  * \author xythobuz

include/system/FontImGui.h

@@ -1,5 +1,5 @@
 /*!
- * \file include/FontImGui.h
+ * \file include/system/FontImGui.h
  * \brief Default Font implementation
  *
  * \author xythobuz

include/system/FontSDL.h

@@ -1,5 +1,5 @@
 /*!
- * \file include/FontSDL.h
+ * \file include/system/FontSDL.h
  * \brief SDL Font implementation
  *
  * \author xythobuz

include/system/FontTRLE.h

@@ -1,5 +1,5 @@
 /*!
- * \file include/FontTRLE.h
+ * \file include/system/FontTRLE.h
  * \brief Tomb Raider Level Editor Font loader
  *
  * \author xythobuz

include/system/Shader.h

@@ -0,0 +1,56 @@
+/*!
+ * \file include/system/Shader.h
+ * \brief OpenGL Shader implementation
+ *
+ * \author xythobuz
+ */
+
+#ifndef _SHADER_H_
+#define _SHADER_H_
+
+#include <vector>
+#include <glm/mat4x4.hpp>
+#include <glm/vec2.hpp>
+#include <glm/vec4.hpp>
+
+#include "TextureManager.h"
+
+class Shader {
+  public:
+    Shader() : programID(-1) { }
+    ~Shader();
+
+    int compile(const char* vertex, const char* fragment);
+    void use();
+
+    int addUniform(const char* name);
+    unsigned int getUniform(int n);
+
+    void addBuffer(int n = 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 loadUniform(int uni, glm::vec2 vec);
+    void loadUniform(int uni, glm::vec4 vec);
+    void loadUniform(int uni, glm::mat4 mat);
+    void loadUniform(int uni, int texture, TextureManager::TextureStorage store, int slot = 0);
+
+    void bindBuffer(int buff);
+    void bindBuffer(int buff, int location, int size);
+
+    void disableAttribs();
+
+  private:
+    int programID;
+    std::vector<unsigned int> uniforms;
+    std::vector<unsigned int> buffers;
+    std::vector<bool> attribs;
+};
+
+#endif
+

include/system/Window.h

@@ -1,5 +1,5 @@
 /*!
- * \file include/Window.h
+ * \file include/system/Window.h
  * \brief Windowing interface
  *
  * \author xythobuz
@@ -14,53 +14,26 @@
 #include <glm/vec3.hpp>
 #include <glm/vec4.hpp>
 
-class Shader {
-  public:
-    Shader() : programID(-1) { }
-    ~Shader();
-
-    int compile(const char* vertex, const char* fragment);
-    void use();
-
-    int addUniform(const char* name);
-    unsigned int getUniform(int n);
-
-    void addBuffer(int n = 1);
-    unsigned int getBuffer(int n);
-
-  private:
-    int programID;
-    std::vector<unsigned int> uniforms;
-    std::vector<unsigned int> buffers;
-};
+#include "Shader.h"
 
 class Window {
   public:
+    static int initialize();
+    static void eventHandling();
+    static void swapBuffers();
+    static void shutdown();
 
-    virtual ~Window() {}
-
-    virtual void setSize(unsigned int width, unsigned int height) = 0;
-    virtual unsigned int getWidth();
-    virtual unsigned int getHeight();
-
-    virtual void setFullscreen(bool fullscreen) = 0;
-    virtual bool getFullscreen();
+    static void setSize(glm::vec2 s);
+    static glm::vec2 getSize();
 
-    virtual void setMousegrab(bool grab) = 0;
-    virtual bool getMousegrab();
+    static void setFullscreen(bool f);
+    static bool getFullscreen();
 
-    virtual int initialize() = 0;
+    static void setMousegrab(bool g);
+    static bool getMousegrab();
 
-    virtual void eventHandling() = 0;
-
-    virtual void setTextInput(bool on) = 0;
-    virtual bool getTextInput();
-
-    virtual void swapBuffersGL() = 0;
-
-    static int initializeGL();
-    static void shutdownGL();
-    static void resizeGL();
+    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);
@@ -69,20 +42,12 @@ class Window {
                        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);
-
-    static void drawLinesGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& colors,
-                            std::vector<unsigned short>& indices, glm::mat4 MVP);
-
-  protected:
-    bool mInit;
-    bool mFullscreen;
-    bool mMousegrab;
-    bool mTextInput;
-    unsigned int mWidth;
-    unsigned int mHeight;
+                       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;
@@ -90,6 +55,7 @@ class Window {
     static Shader imguiShader;
     static const char* imguiShaderVertex;
     static const char* imguiShaderFragment;
+    friend class UI;
 
     static Shader textureShader;
     static const char* textureShaderVertex;
@@ -100,11 +66,7 @@ class Window {
     static const char* colorShaderFragment;
 
     static unsigned int vertexArrayID;
-
-    friend class UI;
 };
 
-Window& getWindow();
-
 #endif
 

include/system/WindowGLFW.h

@@ -1,5 +1,5 @@
 /*!
- * \file include/WindowGLFW.h
+ * \file include/system/WindowGLFW.h
  * \brief GLFW windowing implementation
  *
  * \author xythobuz
@@ -10,27 +10,24 @@
 
 #include <GLFW/glfw3.h>
 
-#include "system/Window.h"
-
-class WindowGLFW : public Window {
+class WindowGLFW {
   public:
+    static int initialize();
+    static void eventHandling();
+    static void swapBuffers();
+    static void shutdown();
 
-    WindowGLFW();
-    virtual ~WindowGLFW();
-
-    virtual void setSize(unsigned int width, unsigned int height);
-
-    virtual void setFullscreen(bool fullscreen);
-
-    virtual void setMousegrab(bool grab);
-
-    virtual int initialize();
+    static void setSize(glm::vec2 s);
+    static glm::vec2 getSize() { return size; }
 
-    virtual void eventHandling();
+    static void setFullscreen(bool f);
+    static bool getFullscreen() { return fullscreen; }
 
-    virtual void setTextInput(bool on);
+    static void setMousegrab(bool g);
+    static bool getMousegrab() { return mousegrab; }
 
-    virtual void swapBuffersGL();
+    static void setTextInput(bool t);
+    static bool getTextInput() { return textinput; }
 
   private:
     static void errorCallback(int error, const char* desc);
@@ -42,7 +39,17 @@ class WindowGLFW : public Window {
 
     static KeyboardButton convertAsciiButton(int key);
 
-    GLFWwindow* mWindow;
+    static glm::vec2 size;
+    static bool fullscreen;
+    static bool mousegrab;
+    static bool textinput;
+    static GLFWwindow* window;
+    static int lastMouseX;
+    static int lastMouseY;
+    static bool modShift;
+    static bool modControl;
+    static bool modAlt;
+    static bool modSuper;
 };
 
 #endif

include/system/WindowSDL.h

@@ -1,5 +1,5 @@
 /*!
- * \file include/WindowSDL.h
+ * \file include/system/WindowSDL.h
  * \brief SDL windowing implementation
  *
  * \author xythobuz
@@ -8,44 +8,37 @@
 #ifndef _WINDOW_SDL_H_
 #define _WINDOW_SDL_H_
 
-#include "SDL.h"
+#include <glm/vec2.hpp>
 
-#include "system/Window.h"
+#include "SDL.h"
 
-/*!
- * \brief SDL windowing implementation
- */
-class WindowSDL : public Window {
+class WindowSDL {
   public:
+    static int initialize();
+    static void eventHandling();
+    static void swapBuffers();
+    static void shutdown();
 
-    /*!
-     * \brief Constructs an object of WindowSDL
-     */
-    WindowSDL();
-
-    /*!
-     * \brief Deconstructs an object of WindowSDL
-     */
-    virtual ~WindowSDL();
-
-    virtual void setSize(unsigned int width, unsigned int height);
-
-    virtual void setFullscreen(bool fullscreen);
-
-    virtual void setMousegrab(bool grab);
-
-    virtual int initialize();
+    static void setSize(glm::vec2 s);
+    static glm::vec2 getSize() { return size; }
 
-    virtual void eventHandling();
+    static void setFullscreen(bool f);
+    static bool getFullscreen() { return fullscreen; }
 
-    virtual void setTextInput(bool on);
+    static void setMousegrab(bool g);
+    static bool getMousegrab() { return mousegrab; }
 
-    virtual void swapBuffersGL();
+    static void setTextInput(bool t);
+    static bool getTextInput() { return textinput; }
 
   private:
-    SDL_Window* mWindow;      //!< This is the pointer to the SDL surface
-    SDL_GLContext mGLContext; //!< The OpenGL Context
-    SDL_GameController* controller;
+    static glm::vec2 size;
+    static bool fullscreen;
+    static bool mousegrab;
+    static bool textinput;
+    static SDL_Window* window;
+    static SDL_GLContext context;
+    static SDL_GameController* controller;
 };
 
 #endif

src/Camera.cpp

@@ -6,6 +6,7 @@
  * \author xythobuz
  */
 
+#include <limits>
 #include <glm/gtc/epsilon.hpp>
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtx/quaternion.hpp>
@@ -15,21 +16,19 @@
 #include "system/Window.h"
 #include "Camera.h"
 
-#define NEAR 0
-#define FAR 1
-#define TOP 2
-#define BOTTOM 3
-#define LEFT 4
-#define RIGHT 5
+static bool equal(float a, float b) {
+    return glm::epsilonEqual(a, b, std::numeric_limits<float>::epsilon());
+}
 
-#define NTL 0
-#define NBL 1
-#define NBR 2
-#define NTR 3
-#define FTL 4
-#define FBL 5
-#define FBR 6
-#define FTR 7
+static bool equal(glm::vec2 a, float b) {
+    return equal(a.x, b) && equal(a.y, b);
+}
+
+static bool equal(glm::vec3 a, float b) {
+    return equal(a.x, b) && equal(a.y, b) && equal(a.z, b);
+}
+
+// ----------------------------------------------------------------------------
 
 const static float fov = 45.0f;
 const static float nearDist = 0.1f;
@@ -52,12 +51,14 @@ glm::mat4 Camera::view(1.0f);
 float Camera::rotationDeltaX = 0.75f;
 float Camera::rotationDeltaY = 0.75f;
 bool Camera::updateViewFrustum = true;
+bool Camera::dirty = true;
 
 void Camera::reset() {
     pos = glm::vec3(0.0f, 0.0f, 0.0f);
     quaternion = glm::quat(glm::vec3(0.0f, 0.0f, 0.0f));
     posSpeed = glm::vec3(0.0f, 0.0f, 0.0f);
     rotSpeed = glm::vec2(0.0f, 0.0f);
+    dirty = true;
     lastSize = glm::vec2(0.0f, 0.0f);
     projection = glm::mat4(1.0f);
     view = glm::mat4(1.0f);
@@ -80,21 +81,39 @@ void Camera::handleAction(ActionEvents action, bool isFinished) {
         posSpeed += upUnit * maxSpeed * factor;
     } else if (action == crouchAction) {
         posSpeed -= upUnit * maxSpeed * factor;
+    } else {
+        return;
     }
+
+    dirty = true;
 }
 
 void Camera::handleMouseMotion(int x, int y) {
-    if (x != 0)
-        quaternion = glm::quat(upUnit * rotationDeltaX * float(x)) * quaternion;
+    if (x != 0) {
+        quaternion = glm::quat(upUnit * (rotationDeltaX * x)) * quaternion;
+        dirty = true;
+    }
+
+    static int lastDir = 0;
+    if (y != 0) {
+        float a = glm::dot(upUnit, quaternion * upUnit);
+        if (((lastDir >= 0) && (y < 0)) || ((lastDir <= 0) && (y > 0)) || (a > 0.5f)) {
+            quaternion = glm::quat(quaternion * -rightUnit * (rotationDeltaY * y)) * quaternion;
+            dirty = true;
 
-    if (y != 0)
-        quaternion = glm::quat(quaternion * -rightUnit * rotationDeltaY * float(y)) * quaternion;
+            // TODO find better way to clamp Y rotation axis!
+            if (a > 0.5f)
+                lastDir = y;
+        }
+    }
 }
 
 void Camera::handleControllerAxis(float value, KeyboardButton axis) {
     if (glm::epsilonEqual(value, 0.0f, controllerDeadZone))
         value = 0.0f;
 
+    // TODO clamp Y rotation axis somehow...?
+
     if (axis == leftXAxis) {
         posSpeed.x = -maxSpeed * value;
     } else if (axis == leftYAxis) {
@@ -103,7 +122,11 @@ void Camera::handleControllerAxis(float value, KeyboardButton axis) {
         rotSpeed.x = controllerViewFactor * value;
     } else if (axis == rightYAxis) {
         rotSpeed.y = controllerViewFactor * value;
+    } else {
+        return;
     }
+
+    dirty = true;
 }
 
 void Camera::handleControllerButton(KeyboardButton button, bool released) {
@@ -119,11 +142,15 @@ void Camera::handleControllerButton(KeyboardButton button, bool released) {
         handleAction(leftAction, released);
     } else if (button == padRight) {
         handleAction(rightAction, released);
+    } else {
+        return;
     }
+
+    dirty = true;
 }
 
 bool Camera::update() {
-    glm::vec2 size(getWindow().getWidth(), getWindow().getHeight());
+    glm::vec2 size(Window::getSize());
 
     if (lastSize != size) {
         //! \fixme TODO instead of mirroring the Y axis in the shader, scale with -1 here
@@ -131,6 +158,9 @@ bool Camera::update() {
         lastSize = size;
     }
 
+    if ((!dirty) && equal(posSpeed, 0.0f) && equal(rotSpeed, 0.0f))
+        return false;
+
     float dT = getRunTime().getLastFrameTime();
     pos += quaternion * posSpeed * dT;
 
@@ -147,12 +177,14 @@ bool Camera::update() {
     if (updateViewFrustum)
         calculateFrustumPlanes();
 
+    dirty = false;
     return updateViewFrustum;
 }
 
 glm::vec2 Camera::getRotation() {
-    glm::vec3 euler = glm::eulerAngles(quaternion);
-    return glm::vec2(euler.y, euler.x);
+    float x = glm::dot(dirUnit, quaternion * dirUnit);
+    float y = glm::dot(upUnit, quaternion * upUnit);
+    return glm::vec2(x, y);
 }
 
 // ----------------------------------------------------------------------------
@@ -174,6 +206,22 @@ class FrustumPlane {
 
 // ----------------------------------------------------------------------------
 
+#define NEAR 0
+#define FAR 1
+#define TOP 2
+#define BOTTOM 3
+#define LEFT 4
+#define RIGHT 5
+
+#define NTL 0
+#define NBL 1
+#define NBR 2
+#define NTR 3
+#define FTL 4
+#define FBL 5
+#define FBR 6
+#define FTR 7
+
 static FrustumPlane planes[6];
 static glm::vec3 frustumColors[6] = {
     glm::vec3(1.0f, 0.0f, 0.0f), // NEAR, red

src/Game.cpp

@@ -53,19 +53,19 @@ void Game::display() {
     if (getRunTime().getShowFPS()) {
         std::ostringstream s;
         s << getRunTime().getFPS() << "FPS";
-        Font::drawText(10, getWindow().getHeight() - 25, 0.6f, BLUE, s.str());
+        Font::drawText(10, Window::getSize().y - 25, 0.6f, BLUE, s.str());
 
         s.str("");
         s << "X: " << Camera::getPosition().x << " (" << Camera::getRotation().x << ")";
-        Font::drawText(10, getWindow().getHeight() - 70, 0.6f, BLUE, s.str());
+        Font::drawText(10, Window::getSize().y - 70, 0.6f, BLUE, s.str());
 
         s.str("");
         s << "Y: " << Camera::getPosition().y << " (" << Camera::getRotation().y << ")";
-        Font::drawText(10, getWindow().getHeight() - 55, 0.6f, BLUE, s.str());
+        Font::drawText(10, Window::getSize().y - 55, 0.6f, BLUE, s.str());
 
         s.str("");
         s << "Z: " << Camera::getPosition().z;
-        Font::drawText(10, getWindow().getHeight() - 40, 0.6f, BLUE, s.str());
+        Font::drawText(10, Window::getSize().y - 40, 0.6f, BLUE, s.str());
     }
 }
 

src/Menu.cpp

@@ -87,7 +87,7 @@ bool Menu::handleMouseScrollDialog(int xrel, int yrel) {
 
 void Menu::displayDialog() {
     if (dialogText.length() > 0) {
-        unsigned int wMax = ((unsigned int)(::getWindow().getWidth() * 0.66f));
+        unsigned int wMax = ((unsigned int)(Window::getSize().x * 0.66f));
 
         unsigned int w0 = Font::widthText(1.0f, dialogText) + 20;
         if (w0 > wMax)
@@ -139,8 +139,8 @@ void Menu::displayDialog() {
             hOverlay = h0 + h1;
         }
 
-        unsigned int xOverlay = (::getWindow().getWidth() - wOverlay) / 2;
-        unsigned int yOverlay = (::getWindow().getHeight() - hOverlay) / 2;
+        unsigned int xOverlay = (Window::getSize().x - wOverlay) / 2;
+        unsigned int yOverlay = (Window::getSize().y - hOverlay) / 2;
 
         /*
         glColor4f(0.0f, 0.0f, 0.0f, 0.75f);
@@ -157,13 +157,13 @@ void Menu::displayDialog() {
                 Font::drawTextWrapped(xOverlay + 10 + w1, yOverlay + 10 + h0,
                                       1.0f, dialogState ? RED : BLUE, w2, dialogButton2);
             } else {
-                Font::drawTextWrapped((::getWindow().getWidth() - w1) / 2,
+                Font::drawTextWrapped((Window::getSize().x - w1) / 2,
                                       yOverlay + 10 + h0, 1.0f, dialogState ? BLUE : RED, w1, dialogButton1);
-                Font::drawTextWrapped((::getWindow().getWidth() - w2) / 2,
+                Font::drawTextWrapped((Window::getSize().x - w2) / 2,
                                       yOverlay + 10 + h0 + h1, 1.0f, dialogState ? RED : BLUE, w2, dialogButton2);
             }
         } else {
-            Font::drawTextWrapped((::getWindow().getWidth() - w1) / 2,
+            Font::drawTextWrapped((Window::getSize().x - w1) / 2,
                                   yOverlay + 10 + h0, 1.0f, RED, w1, dialogButton1);
         }
     }

src/MenuFolder.cpp

@@ -77,18 +77,18 @@ void MenuFolder::display() {
     if (!visible)
         return;
 
-    Font::drawTextCentered(0, 10, 1.2f, BLUE, ::getWindow().getWidth(), VERSION);
+    Font::drawTextCentered(0, 10, 1.2f, BLUE, Window::getSize().x, VERSION);
 
     // Draw half-transparent overlay
     glm::vec4 color(0.0f, 0.0f, 0.0f, 0.75f);
-    Render::drawTexture(0.0f, 0.0f, getWindow().getWidth(), getWindow().getHeight(),
+    Render::drawTexture(0.0f, 0.0f, Window::getSize().x, Window::getSize().y,
                         color, TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
 
     // Draw heading
-    Font::drawTextCentered(0, 10, 1.2f, BLUE, getWindow().getWidth(), VERSION);
+    Font::drawTextCentered(0, 10, 1.2f, BLUE, Window::getSize().x, VERSION);
 
     // Estimate displayable number of items
-    int items = (getWindow().getHeight() - 60) / 25;
+    int items = (Window::getSize().y - 60) / 25;
 
     // Print list of "..", folders, files
     for (long i = mMin; (i < (mMin + items))
@@ -137,7 +137,7 @@ void MenuFolder::handleKeyboard(KeyboardButton key, bool pressed) {
         return;
 
     assert(mapFolder != nullptr);
-    int items = (::getWindow().getHeight() - 60) / 25;
+    int items = (Window::getSize().y - 60) / 25;
 
     if (key == upKey) {
         if (mCursor > 0)
@@ -168,7 +168,7 @@ void MenuFolder::handleMouseClick(unsigned int x, unsigned int y, KeyboardButton
     if (handleMouseClickDialog(x, y, button, released))
         return;
 
-    int items = (::getWindow().getHeight() - 60) / 25;
+    int items = (Window::getSize().y - 60) / 25;
 
     if (released || (button != leftmouseKey))
         return;
@@ -189,7 +189,7 @@ void MenuFolder::handleMouseScroll(int xrel, int yrel) {
 
     assert((xrel != 0) || (yrel != 0));
     assert(mapFolder != nullptr);
-    int items = (::getWindow().getHeight() - 60) / 25;
+    int items = (Window::getSize().y - 60) / 25;
 
     if ((mapFolder->folderCount() + mapFolder->fileCount() + 1) > items) {
         if (yrel < 0) {

src/Render.cpp

@@ -53,7 +53,7 @@ void Render::display() {
 
     if (mode == RenderMode::LoadScreen) {
         glm::vec4 color(1.0f, 1.0f, 1.0f, 1.0f);
-        drawTexture(0.0f, 0.0f, getWindow().getWidth(), getWindow().getHeight(),
+        drawTexture(0.0f, 0.0f, Window::getSize().x, Window::getSize().y,
                     color, TEXTURE_SPLASH, TextureManager::TextureStorage::SYSTEM);
         return;
     } else if (mode == RenderMode::Disabled) {
@@ -132,7 +132,7 @@ void Render::buildRoomList(int room) {
 
 void Render::screenShot(const char* filenameBase) {
     /*
-    int sz = getWindow().getWidth() * getWindow().getHeight();
+    int sz = Window::getSize().x * Window::getSize().y;
     unsigned char* image = new unsigned char[sz * 3];
     static int count = 0;
     bool done = false;
@@ -152,9 +152,9 @@ void Render::screenShot(const char* filenameBase) {
         }
     }
 
-    glReadPixels(0, 0, getWindow().getWidth(), getWindow().getHeight(), GL_BGR_EXT, GL_UNSIGNED_BYTE,
+    glReadPixels(0, 0, Window::getSize().x, Window::getSize().y, GL_BGR_EXT, GL_UNSIGNED_BYTE,
                  image);
-    tgaSave(filename.str().c_str(), image, getWindow().getWidth(), getWindow().getHeight(), 0);
+    tgaSave(filename.str().c_str(), image, Window::getSize().x, Window::getSize().y, 0);
     delete [] image;
     */
 }

src/Room.cpp

@@ -25,7 +25,7 @@ void Room::display(glm::mat4 view, glm::mat4 projection) {
     }
 
     if (Render::getMode() == RenderMode::Wireframe)
-        bbox->display(projection * view, glm::vec3(0.0f, 1.0f, 0.0f));
+        bbox->display(projection * view);
 }
 
 bool Room::isWall(unsigned long sector) {

src/RoomData.cpp

@@ -13,14 +13,14 @@
 #include "system/Window.h"
 #include "RoomData.h"
 
-void BoundingBox::display(glm::mat4 VP, glm::vec3 color) {
+void BoundingBox::display(glm::mat4 VP) {
     std::vector<glm::vec3> verts;
     std::vector<glm::vec3> cols;
     std::vector<unsigned short> inds;
 
     for (int i = 0; i < 8; i++) {
         verts.push_back(corner[i]);
-        cols.push_back(color);
+        cols.push_back(glm::vec3(0.0f, 1.0f, 0.0f));
     }
 
     inds.push_back(0);
@@ -40,7 +40,17 @@ void BoundingBox::display(glm::mat4 VP, glm::vec3 color) {
     inds.push_back(5);
     inds.push_back(2);
 
-    Window::drawLinesGL(verts, cols, inds, VP);
+    Window::drawGL(verts, cols, inds, VP, GL_LINE_STRIP);
+
+    cols.clear();
+    inds.clear();
+
+    for (int i = 0; i < 8; i++) {
+        cols.push_back(glm::vec3(1.0f, 0.0f, 0.0f));
+        inds.push_back(i);
+    }
+
+    Window::drawGL(verts, cols, inds, VP, GL_POINTS);
 }
 
 // ----------------------------------------------------------------------------

src/UI.cpp

@@ -44,7 +44,7 @@ int UI::initialize() {
     logFilename = getRunTime().getBaseDir() + "/imgui_log.txt";
 
     ImGuiIO& io = ImGui::GetIO();
-    io.DisplaySize = ImVec2((float)getWindow().getWidth(), (float)getWindow().getHeight());
+    io.DisplaySize = ImVec2(Window::getSize().x, Window::getSize().y);
     io.DeltaTime = 1.0f / 60.0f;
 
     io.IniFilename = iniFilename.c_str();
@@ -90,7 +90,7 @@ int UI::initialize() {
 
 void UI::eventsFinished() {
     ImGuiIO& io = ImGui::GetIO();
-    io.DisplaySize = ImVec2((float)getWindow().getWidth(), (float)getWindow().getHeight());
+    io.DisplaySize = ImVec2(Window::getSize().x, Window::getSize().y);
 
     static unsigned long lastTime = 0;
     io.DeltaTime = ((float)(systemTimerGet() - lastTime)) / 1000.0f;
@@ -175,12 +175,12 @@ void UI::eventsFinished() {
         visible = false;
     }
 
-    if (getWindow().getTextInput() != visible)
-        getWindow().setTextInput(visible);
+    if (Window::getTextInput() != visible)
+        Window::setTextInput(visible);
 
     bool input = !(visible || getMenu().isVisible());
-    if (getWindow().getMousegrab() != input)
-        getWindow().setMousegrab(input);
+    if (Window::getMousegrab() != input)
+        Window::setMousegrab(input);
 
     io.MouseWheel = 0;
 }
@@ -229,9 +229,9 @@ void UI::display() {
                 Sound::setEnabled(sound);
             }
             ImGui::SameLine();
-            bool fullscreen = getWindow().getFullscreen();
+            bool fullscreen = Window::getFullscreen();
             if (ImGui::Checkbox("Fullscreen##runtime", &fullscreen)) {
-                getWindow().setFullscreen(fullscreen);
+                Window::setFullscreen(fullscreen);
             }
 
             bool updateViewFrustum = Camera::getUpdateViewFrustum();
@@ -254,17 +254,17 @@ void UI::display() {
                 Sound::setVolume(vol);
             }
 
-            int w = getWindow().getWidth();
+            int w = Window::getSize().x;
             if (ImGui::InputInt("Width##runtime", &w, 10, 100, ImGuiInputTextFlags_EnterReturnsTrue)) {
                 if (w < 1)
                     w = 1;
-                getWindow().setSize(w, getWindow().getHeight());
+                Window::setSize(glm::vec2(w, Window::getSize().y));
             }
-            int h = getWindow().getHeight();
+            int h = Window::getSize().y;
             if (ImGui::InputInt("Height##runtime", &h, 10, 100, ImGuiInputTextFlags_EnterReturnsTrue)) {
                 if (h < 1)
                     h = 1;
-                getWindow().setSize(getWindow().getWidth(), h);
+                Window::setSize(glm::vec2(Window::getSize().x, h));
             }
 
             static int fr = 0;
@@ -677,23 +677,11 @@ void UI::renderImGui(ImDrawList** const cmd_lists, int cmd_lists_count) {
     glDisable(GL_DEPTH_TEST);
 
     Window::imguiShader.use();
-
-    glUniform2f(Window::imguiShader.getUniform(0), getWindow().getWidth(), getWindow().getHeight());
-
-    getTextureManager().bindTextureId(fontTex, TextureManager::TextureStorage::SYSTEM, 0);
-    glUniform1i(Window::imguiShader.getUniform(1), 0);
-
-    glEnableVertexAttribArray(0); // Vertices
-    glBindBuffer(GL_ARRAY_BUFFER, Window::imguiShader.getBuffer(0));
-    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
-
-    glEnableVertexAttribArray(1); // UVs
-    glBindBuffer(GL_ARRAY_BUFFER, Window::imguiShader.getBuffer(1));
-    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
-
-    glEnableVertexAttribArray(2); // Colors
-    glBindBuffer(GL_ARRAY_BUFFER, Window::imguiShader.getBuffer(2));
-    glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, 0, nullptr);
+    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);
 
     std::vector<glm::vec2> vertices;
     std::vector<glm::vec2> uvs;
@@ -724,17 +712,12 @@ void UI::renderImGui(ImDrawList** const cmd_lists, int cmd_lists_count) {
 
             offset += commands[n].vtx_count;
 
-            glBindBuffer(GL_ARRAY_BUFFER, Window::imguiShader.getBuffer(0));
-            glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(glm::vec2), &vertices[0], GL_STATIC_DRAW);
-
-            glBindBuffer(GL_ARRAY_BUFFER, Window::imguiShader.getBuffer(1));
-            glBufferData(GL_ARRAY_BUFFER, uvs.size() * sizeof(glm::vec2), &uvs[0], GL_STATIC_DRAW);
-
-            glBindBuffer(GL_ARRAY_BUFFER, Window::imguiShader.getBuffer(2));
-            glBufferData(GL_ARRAY_BUFFER, colors.size() * sizeof(glm::vec4), &colors[0], GL_STATIC_DRAW);
+            Window::imguiShader.bufferData(0, vertices);
+            Window::imguiShader.bufferData(1, uvs);
+            Window::imguiShader.bufferData(2, colors);
 
             glScissor(commands[n].clip_rect.x,
-                      getWindow().getHeight() - commands[n].clip_rect.w,
+                      Window::getSize().y - commands[n].clip_rect.w,
                       commands[n].clip_rect.z - commands[n].clip_rect.x,
                       commands[n].clip_rect.w - commands[n].clip_rect.y);
 
@@ -746,9 +729,7 @@ void UI::renderImGui(ImDrawList** const cmd_lists, int cmd_lists_count) {
         }
     }
 
-    glDisableVertexAttribArray(0);
-    glDisableVertexAttribArray(1);
-    glDisableVertexAttribArray(2);
+    Window::imguiShader.disableAttribs();
 
     glEnable(GL_DEPTH_TEST);
     glDisable(GL_SCISSOR_TEST);

src/commands/CommandSet.cpp

@@ -77,14 +77,14 @@ int CommandSet::execute(std::istream& args) {
             getLog() << "set-size-Error: Invalid value(s)" << Log::endl;
             return -2;
         }
-        getWindow().setSize(w, h);
+        Window::setSize(glm::vec2(w, h));
     } else if (var.compare("fullscreen") == 0) {
         bool fullscreen = false;
         if (!(args >> fullscreen)) {
             getLog() << "set-fullscreen-Error: Invalid value" << Log::endl;
             return -3;
         }
-        getWindow().setFullscreen(fullscreen);
+        Window::setFullscreen(fullscreen);
     } else if (var.compare("audio") == 0) {
         bool audio = false;
         if (!(args >> audio)) {
@@ -181,9 +181,9 @@ int CommandGet::execute(std::istream& args) {
     args >> var;
 
     if (var.compare("size") == 0) {
-        getLog() << getWindow().getWidth() << " " << getWindow().getHeight() << Log::endl;
+        getLog() << Window::getSize() << Log::endl;
     } else if (var.compare("fullscreen") == 0) {
-        getLog() << getWindow().getFullscreen() << Log::endl;
+        getLog() << Window::getFullscreen() << Log::endl;
     } else if (var.compare("audio") == 0) {
         getLog() << Sound::getEnabled() << Log::endl;
     } else if (var.compare("volume") == 0) {

src/main.cpp

@@ -28,14 +28,6 @@
 #include "system/Sound.h"
 #include "system/Window.h"
 
-#ifdef USING_SDL
-#include "system/WindowSDL.h"
-#elif defined(USING_GLFW)
-#include "system/WindowGLFW.h"
-#else
-#error No Windowing Library selected!
-#endif
-
 static std::string configFileToUse;
 
 static std::shared_ptr<Game> gGame;
@@ -43,7 +35,6 @@ static std::shared_ptr<Log> gLog;
 static std::shared_ptr<MenuFolder> gMenu;
 static std::shared_ptr<RunTime> gRunTime;
 static std::shared_ptr<TextureManager> gTextureManager;
-static std::shared_ptr<Window> gWindow;
 static std::shared_ptr<World> gWorld;
 
 Game& getGame() {
@@ -66,10 +57,6 @@ TextureManager& getTextureManager() {
     return *gTextureManager;
 }
 
-Window& getWindow() {
-    return *gWindow;
-}
-
 World& getWorld() {
     return *gWorld;
 }
@@ -93,35 +80,22 @@ int main(int argc, char* argv[]) {
     gTextureManager.reset(new TextureManager());
     gWorld.reset(new World());
 
-#ifdef USING_SDL
-    gWindow.reset(new WindowSDL());
-#elif defined(USING_GLFW)
-    gWindow.reset(new WindowGLFW());
-#endif
-
     Command::fillCommandList();
 
     getLog() << "Initializing " << VERSION << Log::endl;
 
     // Initialize Windowing
-    int error = getWindow().initialize();
+    int error = Window::initialize();
     if (error != 0) {
-        std::cout << "Could not initialize Window (" << error << ")!" << std::endl;
+        std::cout << "Could not initialize Window/GL (" << error << ")!" << std::endl;
         return -1;
     }
 
-    // Initialize OpenGL
-    error = getWindow().initializeGL();
-    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 -3;
+        return -2;
     }
 
     if (configFileToUse == "") {
@@ -141,35 +115,35 @@ int main(int argc, char* argv[]) {
     error = getTextureManager().initializeSplash();
     if (error != 0) {
         std::cout << "Coult not load Splash Texture (" << error << ")!" << std::endl;
-        return -4;
+        return -3;
     }
 
     // Initialize Sound
     error = Sound::initialize();
     if (error != 0) {
         std::cout << "Could not initialize Sound (" << error << ")!" << std::endl;
-        return -5;
+        return -4;
     }
 
     // Initialize Menu
     error = getMenu().initialize();
     if (error != 0) {
         std::cout << "Could not initialize Menu (" << error << ")!" << std::endl;
-        return -6;
+        return -5;
     }
 
     // Initialize Debug UI
     error = UI::initialize();
     if (error != 0) {
         std::cout << "Could not initialize Debug UI (" << error << ")!" << std::endl;
-        return -7;
+        return -6;
     }
 
     // Initialize Game Engine
     error = getGame().initialize();
     if (error != 0) {
         std::cout << "Could not initialize Game (" << error << ")!" << std::endl;
-        return -8;
+        return -7;
     }
 
     getLog() << "Starting " << VERSION << Log::endl;
@@ -178,14 +152,14 @@ int main(int argc, char* argv[]) {
     getRunTime().setRunning(true);
 
     while (getRunTime().isRunning()) {
-        getWindow().eventHandling();
+        Window::eventHandling();
         renderFrame();
     }
 
     UI::shutdown();
     Font::shutdown();
     Sound::shutdown();
-    Window::shutdownGL();
+    Window::shutdown();
 
 #ifdef DEBUG
     std::cout << std::endl;
@@ -203,7 +177,7 @@ void renderFrame() {
     getGame().display();
     getMenu().display();
     UI::display();
-    getWindow().swapBuffersGL();
+    Window::swapBuffers();
     getRunTime().updateFPS();
 }
 

src/system/CMakeLists.txt

@@ -2,6 +2,7 @@
 set (SYS_SRCS ${SYS_SRCS} "Font.cpp" "../../include/system/Font.h")
 set (SYS_SRCS ${SYS_SRCS} "FontImGui.cpp" "../../include/system/FontImGui.h")
 set (SYS_SRCS ${SYS_SRCS} "FontTRLE.cpp" "../../include/system/FontTRLE.h")
+set (SYS_SRCS ${SYS_SRCS} "Shader.cpp" "../../include/system/Shader.h")
 set (SYS_SRCS ${SYS_SRCS} "Sound.cpp" "../../include/system/Sound.h")
 set (SYS_SRCS ${SYS_SRCS} "Window.cpp" "../../include/system/Window.h")
 

src/system/Font.cpp

@@ -1,5 +1,5 @@
 /*!
- * \file src/Font.cpp
+ * \file src/system/Font.cpp
  * \brief Font implementation
  *
  * \author xythobuz

src/system/FontImGui.cpp

@@ -1,5 +1,5 @@
 /*!
- * \file src/FontImGui.cpp
+ * \file src/system/FontImGui.cpp
  * \brief Default Font implementation
  *
  * \author xythobuz

src/system/FontSDL.cpp

@@ -1,5 +1,5 @@
 /*!
- * \file src/FontSDL.cpp
+ * \file src/system/FontSDL.cpp
  * \brief SDL Font implementation
  *
  * \author xythobuz

src/system/FontTRLE.cpp

@@ -1,5 +1,5 @@
 /*!
- * \file src/FontTRLE.cpp
+ * \file src/system/FontTRLE.cpp
  * \brief SDL Font implementation
  *
  * \author xythobuz

src/system/Shader.cpp

@@ -0,0 +1,167 @@
+/*!
+ * \file src/system/Shader.cpp
+ * \brief OpenGL Shader implementation
+ *
+ * \author xythobuz
+ */
+
+#include "global.h"
+#include "Log.h"
+#include "TextureManager.h"
+#include "system/Shader.h"
+
+Shader::~Shader() {
+    if (programID >= 0)
+        glDeleteProgram(programID);
+
+    if (!buffers.empty())
+        glDeleteBuffers(buffers.size(), &buffers[0]);
+}
+
+int Shader::addUniform(const char* name) {
+    assert(programID >= 0);
+    int r = glGetUniformLocation(programID, name);
+    if (r < 0) {
+        getLog() << "Can't find GLSL Uniform \"" << name << "\"!" << Log::endl;
+        return -1;
+    }
+    uniforms.push_back(r);
+    return uniforms.size() - 1;
+}
+
+unsigned int Shader::getUniform(int n) {
+    assert(n >= 0);
+    assert(n < uniforms.size());
+    return uniforms.at(n);
+}
+
+void Shader::addBuffer(int n) {
+    int s = buffers.size();
+    for (int i = 0; i < n; i++)
+        buffers.push_back(0);
+    glGenBuffers(n, &buffers[s]);
+}
+
+unsigned int Shader::getBuffer(int n) {
+    assert(n >= 0);
+    assert(n < buffers.size());
+    return buffers.at(n);
+}
+
+void Shader::loadUniform(int uni, glm::vec2 vec) {
+    glUniform2f(getUniform(uni), vec.x, vec.y);
+}
+
+void Shader::loadUniform(int uni, glm::vec4 vec) {
+    glUniform4f(getUniform(uni), vec.r, vec.g, vec.b, vec.a);
+}
+
+void Shader::loadUniform(int uni, glm::mat4 mat) {
+    glUniformMatrix4fv(getUniform(uni), 1, GL_FALSE, &mat[0][0]);
+}
+
+void Shader::loadUniform(int uni, int texture, TextureManager::TextureStorage store, int slot) {
+    getTextureManager().bindTextureId(texture, store, slot);
+    glUniform1i(getUniform(uni), slot);
+}
+
+void Shader::bindBuffer(int buff) {
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, getBuffer(buff));
+}
+
+void Shader::bindBuffer(int buff, int location, int size) {
+    glEnableVertexAttribArray(location);
+    glBindBuffer(GL_ARRAY_BUFFER, getBuffer(buff));
+    glVertexAttribPointer(location, size, GL_FLOAT, GL_FALSE, 0, nullptr);
+
+    while (attribs.size() <= location)
+        attribs.push_back(false);
+    attribs.at(location) = true;
+}
+
+void Shader::disableAttribs() {
+    for (int i = 0; i < attribs.size(); i++) {
+        if (attribs.at(i)) {
+            glDisableVertexAttribArray(i);
+            attribs.at(i) = false;
+        }
+    }
+}
+
+void Shader::use() {
+    assert(programID >= 0);
+    glUseProgram(programID);
+}
+
+int Shader::compile(const char* vertex, const char* fragment) {
+    assert(vertex != nullptr);
+    assert(fragment != nullptr);
+
+    GLuint vertexID = glCreateShader(GL_VERTEX_SHADER);
+    GLuint fragmentID = glCreateShader(GL_FRAGMENT_SHADER);
+
+    GLint result = GL_FALSE;
+    GLint logLength = 0;
+
+    // Compile vertex shader
+    glShaderSource(vertexID, 1, &vertex, nullptr);
+    glCompileShader(vertexID);
+
+    // Check vertex shader
+    glGetShaderiv(vertexID, GL_COMPILE_STATUS, &result);
+    glGetShaderiv(vertexID, GL_INFO_LOG_LENGTH, &logLength);
+    if (logLength > 0) {
+        std::vector<char> message(logLength + 1);
+        glGetShaderInfoLog(vertexID, logLength, nullptr, &message[0]);
+        if (result != GL_TRUE)
+            getLog() << "Vertex Shader compilation error:" << Log::endl;
+        getLog() << &message[0] << Log::endl;
+        glDeleteShader(vertexID);
+        glDeleteShader(fragmentID);
+        return -1;
+    }
+
+    // Compile fragment shader
+    glShaderSource(fragmentID, 1, &fragment, nullptr);
+    glCompileShader(fragmentID);
+
+    // Check fragment shader
+    glGetShaderiv(fragmentID, GL_COMPILE_STATUS, &result);
+    glGetShaderiv(fragmentID, GL_INFO_LOG_LENGTH, &logLength);
+    if (logLength > 0) {
+        std::vector<char> message(logLength + 1);
+        glGetShaderInfoLog(fragmentID, logLength, nullptr, &message[0]);
+        if (result != GL_TRUE)
+            getLog() << "Fragment Shader compilation error:" << Log::endl;
+        getLog() << &message[0] << Log::endl;
+        glDeleteShader(vertexID);
+        glDeleteShader(fragmentID);
+        return -2;
+    }
+
+    // Link both shaders
+    programID = glCreateProgram();
+    glAttachShader(programID, vertexID);
+    glAttachShader(programID, fragmentID);
+    glLinkProgram(programID);
+
+    // Check resulting program
+    glGetProgramiv(programID, GL_LINK_STATUS, &result);
+    glGetProgramiv(programID, GL_INFO_LOG_LENGTH, &logLength);
+    if (logLength > 0) {
+        std::vector<char> message(logLength + 1);
+        glGetProgramInfoLog(programID, logLength, nullptr, &message[0]);
+        if (result != GL_TRUE)
+            getLog() << "Shader link error:" << Log::endl;
+        getLog() << &message[0] << Log::endl;
+        glDeleteShader(vertexID);
+        glDeleteShader(fragmentID);
+        glDeleteProgram(programID);
+        return -3;
+    }
+
+    glDeleteShader(vertexID);
+    glDeleteShader(fragmentID);
+    return programID;
+}
+

src/system/Window.cpp

@@ -1,5 +1,5 @@
 /*!
- * \file src/Window.cpp
+ * \file src/system/Window.cpp
  * \brief windowing implementation
  *
  * \author xythobuz
@@ -7,31 +7,132 @@
 
 #include "global.h"
 #include "Log.h"
-#include "TextureManager.h"
 #include "utils/strings.h"
 #include "system/Window.h"
 
-unsigned int Window::getWidth() {
-    return mWidth;
+#ifdef USING_SDL
+#include "system/WindowSDL.h"
+#elif defined(USING_GLFW)
+#include "system/WindowGLFW.h"
+#else
+#error "No windowing library selected!"
+#endif
+
+int Window::initialize() {
+    int res = -1;
+#ifdef USING_SDL
+    res = WindowSDL::initialize();
+#elif defined(USING_GLFW)
+    res = WindowGLFW::initialize();
+#endif
+
+    initializeGL();
+    return res;
 }
 
-unsigned int Window::getHeight() {
-    return mHeight;
+void Window::eventHandling() {
+#ifdef USING_SDL
+    WindowSDL::eventHandling();
+#elif defined(USING_GLFW)
+    WindowGLFW::eventHandling();
+#endif
+}
+
+void Window::swapBuffers() {
+#ifdef USING_SDL
+    WindowSDL::swapBuffers();
+#elif defined(USING_GLFW)
+    WindowGLFW::swapBuffers();
+#endif
+}
+
+void Window::shutdown() {
+    shutdownGL();
+
+#ifdef USING_SDL
+    WindowSDL::shutdown();
+#elif defined(USING_GLFW)
+    WindowGLFW::shutdown();
+#endif
+}
+
+void Window::setSize(glm::vec2 s) {
+#ifdef USING_SDL
+    WindowSDL::setSize(s);
+#elif defined(USING_GLFW)
+    WindowGLFW::setSize(s);
+#endif
+}
+
+glm::vec2 Window::getSize() {
+    glm::vec2 ret(-1, -1);
+#ifdef USING_SDL
+    ret = WindowSDL::getSize();
+#elif defined(USING_GLFW)
+    ret = WindowGLFW::getSize();
+#endif
+
+    return ret;
+}
+
+void Window::setFullscreen(bool f) {
+#ifdef USING_SDL
+    WindowSDL::setFullscreen(f);
+#elif defined(USING_GLFW)
+    WindowGLFW::setFullscreen(f);
+#endif
 }
 
 bool Window::getFullscreen() {
-    return mFullscreen;
+    bool ret = false;
+#ifdef USING_SDL
+    ret = WindowSDL::getFullscreen();
+#elif defined(USING_GLFW)
+    ret = WindowGLFW::getFullscreen();
+#endif
+
+    return ret;
+}
+
+void Window::setMousegrab(bool g) {
+#ifdef USING_SDL
+    WindowSDL::setMousegrab(g);
+#elif defined(USING_GLFW)
+    WindowGLFW::setMousegrab(g);
+#endif
 }
 
 bool Window::getMousegrab() {
-    return mMousegrab;
+    bool ret = false;
+#ifdef USING_SDL
+    ret = WindowSDL::getMousegrab();
+#elif defined(USING_GLFW)
+    ret = WindowGLFW::getMousegrab();
+#endif
+
+    return ret;
+}
+
+void Window::setTextInput(bool t) {
+#ifdef USING_SDL
+    WindowSDL::setTextInput(t);
+#elif defined(USING_GLFW)
+    WindowGLFW::setTextInput(t);
+#endif
 }
 
 bool Window::getTextInput() {
-    return mTextInput;
+    bool ret = false;
+#ifdef USING_SDL
+    ret = WindowSDL::getTextInput();
+#elif defined(USING_GLFW)
+    ret = WindowGLFW::getTextInput();
+#endif
+
+    return ret;
 }
 
-// ----------------------------------------------------------------------------
+// --------------------------------------
 
 Shader Window::textShader;
 Shader Window::imguiShader;
@@ -60,6 +161,8 @@ int Window::initializeGL() {
     // 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)
@@ -102,44 +205,25 @@ void Window::shutdownGL() {
     glDeleteVertexArrays(1, &vertexArrayID);
 }
 
-void Window::resizeGL() {
-    // new matrix?
-}
-
 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);
 
-    glBindBuffer(GL_ARRAY_BUFFER, textShader.getBuffer(0));
-    glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(glm::vec2), &vertices[0], GL_STATIC_DRAW);
-
-    glBindBuffer(GL_ARRAY_BUFFER, textShader.getBuffer(1));
-    glBufferData(GL_ARRAY_BUFFER, uvs.size() * sizeof(glm::vec2), &uvs[0], GL_STATIC_DRAW);
-
+    textShader.bufferData(0, vertices);
+    textShader.bufferData(1, uvs);
     textShader.use();
-
-    glUniform2f(textShader.getUniform(0), getWindow().getWidth(), getWindow().getHeight());
-
-    getTextureManager().bindTextureId(texture, TextureManager::TextureStorage::SYSTEM, 0);
-    glUniform1i(textShader.getUniform(1), 0);
-
-    glUniform4fv(textShader.getUniform(2), 1, &color.r);
-
-    glEnableVertexAttribArray(0); // Vertices
-    glBindBuffer(GL_ARRAY_BUFFER, textShader.getBuffer(0));
-    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
-
-    glEnableVertexAttribArray(1); // UVs
-    glBindBuffer(GL_ARRAY_BUFFER, textShader.getBuffer(1));
-    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
+    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);
 
-    glDisableVertexAttribArray(0);
-    glDisableVertexAttribArray(1);
+    textShader.disableAttribs();
 }
 
 void Window::drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec2>& uvs,
@@ -147,223 +231,36 @@ void Window::drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec2>& uv
     assert(vertices.size() == uvs.size());
     assert((indices.size() % 3) == 0);
 
-    glBindBuffer(GL_ARRAY_BUFFER, textureShader.getBuffer(0));
-    glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(glm::vec3), &vertices[0], GL_STATIC_DRAW);
-
-    glBindBuffer(GL_ARRAY_BUFFER, textureShader.getBuffer(1));
-    glBufferData(GL_ARRAY_BUFFER, uvs.size() * sizeof(glm::vec2), &uvs[0], GL_STATIC_DRAW);
-
-    glBindBuffer(GL_ARRAY_BUFFER, textureShader.getBuffer(2));
-    glBufferData(GL_ARRAY_BUFFER, indices.size() * sizeof(unsigned short), &indices[0], GL_STATIC_DRAW);
-
+    textureShader.bufferData(0, vertices);
+    textureShader.bufferData(1, uvs);
+    textureShader.bufferData(2, indices);
     textureShader.use();
-
-    glUniformMatrix4fv(textureShader.getUniform(0), 1, GL_FALSE, &MVP[0][0]);
-
-    getTextureManager().bindTextureId(texture, TextureManager::TextureStorage::GAME, 0);
-    glUniform1i(textureShader.getUniform(1), 0);
-
-    glEnableVertexAttribArray(0);
-    glBindBuffer(GL_ARRAY_BUFFER, textureShader.getBuffer(0));
-    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
-
-    glEnableVertexAttribArray(1);
-    glBindBuffer(GL_ARRAY_BUFFER, textureShader.getBuffer(1));
-    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
-
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, textureShader.getBuffer(2));
-
+    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);
-
-    glDisableVertexAttribArray(0);
-    glDisableVertexAttribArray(1);
+    textureShader.disableAttribs();
 }
 
 void Window::drawGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& colors,
-                    std::vector<unsigned short>& indices, glm::mat4 MVP) {
-    assert(vertices.size() == colors.size());
-    assert((indices.size() % 3) == 0);
-
-    glBindBuffer(GL_ARRAY_BUFFER, colorShader.getBuffer(0));
-    glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(glm::vec3), &vertices[0], GL_STATIC_DRAW);
-
-    glBindBuffer(GL_ARRAY_BUFFER, colorShader.getBuffer(1));
-    glBufferData(GL_ARRAY_BUFFER, colors.size() * sizeof(glm::vec3), &colors[0], GL_STATIC_DRAW);
-
-    glBindBuffer(GL_ARRAY_BUFFER, colorShader.getBuffer(2));
-    glBufferData(GL_ARRAY_BUFFER, indices.size() * sizeof(unsigned short), &indices[0], GL_STATIC_DRAW);
-
-    colorShader.use();
-
-    glUniformMatrix4fv(colorShader.getUniform(0), 1, GL_FALSE, &MVP[0][0]);
-
-    glEnableVertexAttribArray(0);
-    glBindBuffer(GL_ARRAY_BUFFER, colorShader.getBuffer(0));
-    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
-
-    glEnableVertexAttribArray(1);
-    glBindBuffer(GL_ARRAY_BUFFER, colorShader.getBuffer(1));
-    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
-
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, colorShader.getBuffer(2));
-
-    glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_SHORT, nullptr);
-
-    glDisableVertexAttribArray(0);
-    glDisableVertexAttribArray(1);
-}
-
-void Window::drawLinesGL(std::vector<glm::vec3>& vertices, std::vector<glm::vec3>& colors,
-                         std::vector<unsigned short>& indices, glm::mat4 MVP) {
+                    std::vector<unsigned short>& indices, glm::mat4 MVP, int mode) {
     assert(vertices.size() == colors.size());
 
-    glBindBuffer(GL_ARRAY_BUFFER, colorShader.getBuffer(0));
-    glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(glm::vec3), &vertices[0], GL_STATIC_DRAW);
-
-    glBindBuffer(GL_ARRAY_BUFFER, colorShader.getBuffer(1));
-    glBufferData(GL_ARRAY_BUFFER, colors.size() * sizeof(glm::vec3), &colors[0], GL_STATIC_DRAW);
-
-    glBindBuffer(GL_ARRAY_BUFFER, colorShader.getBuffer(2));
-    glBufferData(GL_ARRAY_BUFFER, indices.size() * sizeof(unsigned short), &indices[0], GL_STATIC_DRAW);
-
+    colorShader.bufferData(0, vertices);
+    colorShader.bufferData(1, colors);
+    colorShader.bufferData(2, indices);
     colorShader.use();
-
-    glUniformMatrix4fv(colorShader.getUniform(0), 1, GL_FALSE, &MVP[0][0]);
-
-    glEnableVertexAttribArray(0);
-    glBindBuffer(GL_ARRAY_BUFFER, colorShader.getBuffer(0));
-    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
-
-    glEnableVertexAttribArray(1);
-    glBindBuffer(GL_ARRAY_BUFFER, colorShader.getBuffer(1));
-    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
-
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, colorShader.getBuffer(2));
-
-    glDrawElements(GL_LINE_STRIP, indices.size(), GL_UNSIGNED_SHORT, nullptr);
-
-    glDisableVertexAttribArray(0);
-    glDisableVertexAttribArray(1);
-}
-
-// ----------------------------------------------------------------------------
-
-Shader::~Shader() {
-    if (programID >= 0)
-        glDeleteProgram(programID);
-
-    if (!buffers.empty())
-        glDeleteBuffers(buffers.size(), &buffers[0]);
-}
-
-int Shader::addUniform(const char* name) {
-    assert(programID >= 0);
-    int r = glGetUniformLocation(programID, name);
-    if (r < 0) {
-        getLog() << "Can't find GLSL Uniform \"" << name << "\"!" << Log::endl;
-        return -1;
-    }
-    uniforms.push_back(r);
-    return uniforms.size() - 1;
+    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();
 }
 
-unsigned int Shader::getUniform(int n) {
-    assert(n >= 0);
-    assert(n < uniforms.size());
-    return uniforms.at(n);
-}
-
-void Shader::addBuffer(int n) {
-    int s = buffers.size();
-    for (int i = 0; i < n; i++)
-        buffers.push_back(0);
-    glGenBuffers(n, &buffers[s]);
-}
-
-unsigned int Shader::getBuffer(int n) {
-    assert(n >= 0);
-    assert(n < buffers.size());
-    return buffers.at(n);
-}
-
-void Shader::use() {
-    assert(programID >= 0);
-    glUseProgram(programID);
-}
-
-int Shader::compile(const char* vertex, const char* fragment) {
-    assert(vertex != nullptr);
-    assert(fragment != nullptr);
-
-    GLuint vertexID = glCreateShader(GL_VERTEX_SHADER);
-    GLuint fragmentID = glCreateShader(GL_FRAGMENT_SHADER);
-
-    GLint result = GL_FALSE;
-    GLint logLength = 0;
-
-    // Compile vertex shader
-    glShaderSource(vertexID, 1, &vertex, nullptr);
-    glCompileShader(vertexID);
-
-    // Check vertex shader
-    glGetShaderiv(vertexID, GL_COMPILE_STATUS, &result);
-    glGetShaderiv(vertexID, GL_INFO_LOG_LENGTH, &logLength);
-    if (logLength > 0) {
-        std::vector<char> message(logLength + 1);
-        glGetShaderInfoLog(vertexID, logLength, nullptr, &message[0]);
-        if (result != GL_TRUE)
-            getLog() << "Vertex Shader compilation error:" << Log::endl;
-        getLog() << &message[0] << Log::endl;
-        glDeleteShader(vertexID);
-        glDeleteShader(fragmentID);
-        return -1;
-    }
-
-    // Compile fragment shader
-    glShaderSource(fragmentID, 1, &fragment, nullptr);
-    glCompileShader(fragmentID);
-
-    // Check fragment shader
-    glGetShaderiv(fragmentID, GL_COMPILE_STATUS, &result);
-    glGetShaderiv(fragmentID, GL_INFO_LOG_LENGTH, &logLength);
-    if (logLength > 0) {
-        std::vector<char> message(logLength + 1);
-        glGetShaderInfoLog(fragmentID, logLength, nullptr, &message[0]);
-        if (result != GL_TRUE)
-            getLog() << "Fragment Shader compilation error:" << Log::endl;
-        getLog() << &message[0] << Log::endl;
-        glDeleteShader(vertexID);
-        glDeleteShader(fragmentID);
-        return -2;
-    }
-
-    // Link both shaders
-    programID = glCreateProgram();
-    glAttachShader(programID, vertexID);
-    glAttachShader(programID, fragmentID);
-    glLinkProgram(programID);
-
-    // Check resulting program
-    glGetProgramiv(programID, GL_LINK_STATUS, &result);
-    glGetProgramiv(programID, GL_INFO_LOG_LENGTH, &logLength);
-    if (logLength > 0) {
-        std::vector<char> message(logLength + 1);
-        glGetProgramInfoLog(programID, logLength, nullptr, &message[0]);
-        if (result != GL_TRUE)
-            getLog() << "Shader link error:" << Log::endl;
-        getLog() << &message[0] << Log::endl;
-        glDeleteShader(vertexID);
-        glDeleteShader(fragmentID);
-        glDeleteProgram(programID);
-        return -3;
-    }
-
-    glDeleteShader(vertexID);
-    glDeleteShader(fragmentID);
-    return programID;
-}
-
-// ----------------------------------------------------------------------------
+// --------------------------------------
 // *INDENT-OFF*
 
 const char* Window::textShaderVertex = R"!?!(

src/system/WindowGLFW.cpp

@@ -1,5 +1,5 @@
 /*!
- * \file src/WindowGLFW.cpp
+ * \file src/system/WindowGLFW.cpp
  * \brief GLFW windowing implementation
  *
  * \author xythobuz
@@ -14,32 +14,19 @@
 #include "utils/strings.h"
 #include "system/WindowGLFW.h"
 
-static int lastMouseX = 0;
-static int lastMouseY = 0;
-
-WindowGLFW::WindowGLFW() {
-    mInit = false;
-    mWidth = DEFAULT_WIDTH;
-    mHeight = DEFAULT_HEIGHT;
-    mFullscreen = false;
-    mMousegrab = false;
-    mTextInput = false;
-    mWindow = nullptr;
-}
-
-WindowGLFW::~WindowGLFW() {
-    if (mInit) {
-        if (mWindow) {
-            glfwDestroyWindow(mWindow);
-        }
-
-        glfwTerminate();
-    }
-}
+glm::vec2 WindowGLFW::size(DEFAULT_WIDTH, DEFAULT_HEIGHT);
+bool WindowGLFW::fullscreen = false;
+bool WindowGLFW::mousegrab = false;
+bool WindowGLFW::textinput = false;
+GLFWwindow* WindowGLFW::window = nullptr;
+int WindowGLFW::lastMouseX = 0;
+int WindowGLFW::lastMouseY = 0;
+bool WindowGLFW::modShift = false;
+bool WindowGLFW::modControl = false;
+bool WindowGLFW::modAlt = false;
+bool WindowGLFW::modSuper = false;
 
 int WindowGLFW::initialize() {
-    assert(mInit == false);
-
     glfwSetErrorCallback(WindowGLFW::errorCallback);
     if (!glfwInit()) {
         return -1;
@@ -51,77 +38,74 @@ int WindowGLFW::initialize() {
     glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
     glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
 
-    mWindow = glfwCreateWindow(mWidth, mHeight, VERSION,
-                               mFullscreen ? glfwGetPrimaryMonitor() : nullptr, nullptr);
-    if (!mWindow) {
+    window = glfwCreateWindow(size.x, size.y, VERSION,
+                              fullscreen ? glfwGetPrimaryMonitor() : nullptr, nullptr);
+    if (!window) {
         glfwTerminate();
         return -2;
     }
 
-    glfwMakeContextCurrent(mWindow);
+    glfwMakeContextCurrent(window);
 
-    glfwSetWindowSizeCallback(mWindow, WindowGLFW::sizeCallback);
-    glfwSetCursorPosCallback(mWindow, WindowGLFW::cursorCallback);
-    glfwSetKeyCallback(mWindow, WindowGLFW::keyCallback);
-    glfwSetMouseButtonCallback(mWindow, WindowGLFW::buttonCallback);
-    glfwSetScrollCallback(mWindow, WindowGLFW::scrollCallback);
+    glfwSetWindowSizeCallback(window, WindowGLFW::sizeCallback);
+    glfwSetCursorPosCallback(window, WindowGLFW::cursorCallback);
+    glfwSetKeyCallback(window, WindowGLFW::keyCallback);
+    glfwSetMouseButtonCallback(window, WindowGLFW::buttonCallback);
+    glfwSetScrollCallback(window, WindowGLFW::scrollCallback);
 
-    mInit = true;
     return 0;
 }
 
 void WindowGLFW::eventHandling() {
-    assert(mInit == true);
-
     glfwPollEvents();
 
-    if (glfwWindowShouldClose(mWindow)) {
+    if (glfwWindowShouldClose(window)) {
         getRunTime().setRunning(false);
     }
 
     UI::eventsFinished();
 }
 
-void WindowGLFW::setSize(unsigned int width, unsigned int height) {
-    assert(width > 0);
-    assert(height > 0);
+void WindowGLFW::swapBuffers() {
+    glfwSwapBuffers(window);
+}
 
-    if (mInit) {
-        if ((mWidth != width) || (mHeight != height)) {
-            glfwSetWindowSize(mWindow, width, height);
-            getWindow().resizeGL();
-        }
+void WindowGLFW::shutdown() {
+    if (window) {
+        glfwDestroyWindow(window);
+        glfwTerminate();
+        window = nullptr;
     }
-
-    mWidth = width;
-    mHeight = height;
 }
 
-void WindowGLFW::setFullscreen(bool fullscreen) {
-    mFullscreen = fullscreen;
+void WindowGLFW::setSize(glm::vec2 s) {
+    assert((s.x > 0) && (s.y > 0));
+    if (window) {
+        if ((size.x != s.x) || (size.y != s.y)) {
+            glfwSetWindowSize(window, s.x, s.y);
+        }
+    }
+    size = s;
+}
 
+void WindowGLFW::setFullscreen(bool f) {
+    fullscreen = f;
     //! \todo GLFW does not support toggling fullscreen?!
 }
 
-void WindowGLFW::setMousegrab(bool grab) {
-    mMousegrab = grab;
+void WindowGLFW::setMousegrab(bool g) {
+    mousegrab = g;
 
-    if (mInit == true) {
-        if (mMousegrab)
-            glfwSetInputMode(mWindow, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
+    if (window) {
+        if (mousegrab)
+            glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
         else
-            glfwSetInputMode(mWindow, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
+            glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
     }
 }
 
-void WindowGLFW::setTextInput(bool on) {
-    assert(mInit == true);
-    mTextInput = on;
-}
-
-void WindowGLFW::swapBuffersGL() {
-    assert(mInit == true);
-    glfwSwapBuffers(mWindow);
+void WindowGLFW::setTextInput(bool t) {
+    textinput = t;
 }
 
 void WindowGLFW::errorCallback(int error, const char* desc) {
@@ -129,7 +113,7 @@ void WindowGLFW::errorCallback(int error, const char* desc) {
 }
 
 void WindowGLFW::sizeCallback(GLFWwindow* w, int width, int height) {
-    getWindow().setSize(width, height);
+    size = glm::vec2(width, height);
 }
 
 void WindowGLFW::cursorCallback(GLFWwindow* w, double xpos, double ypos) {
@@ -140,11 +124,6 @@ void WindowGLFW::cursorCallback(GLFWwindow* w, double xpos, double ypos) {
     lastMouseY = ypos;
 }
 
-static bool modShift = false;
-static bool modControl = false;
-static bool modAlt = false;
-static bool modSuper = false;
-
 void WindowGLFW::keyCallback(GLFWwindow* w, int key, int scancode, int action, int mods) {
     if (((mods & GLFW_MOD_SHIFT) != 0) != modShift) {
         modShift = (mods & GLFW_MOD_SHIFT) != 0;
@@ -166,8 +145,8 @@ void WindowGLFW::keyCallback(GLFWwindow* w, int key, int scancode, int action, i
         UI::handleKeyboard(leftguiKey, modSuper);
     }
 
-    if (getWindow().getTextInput() && (action != GLFW_RELEASE)) {
-        //! \todo Handle text input properly!
+    if (textinput && (action != GLFW_RELEASE)) {
+        //! \todo GLFW does not support UTF8 text input?!
         if ((key >= '0') && (key <= '9')) {
             char s[2] = { (char)key, '\0' };
             UI::handleText(s, false);

src/system/WindowSDL.cpp

@@ -1,5 +1,5 @@
 /*!
- * \file src/WindowSDL.cpp
+ * \file src/system/WindowSDL.cpp
  * \brief SDL windowing implementation
  *
  * \author xythobuz
@@ -16,75 +16,22 @@
 
 #define SUBSYSTEMS_USED (SDL_INIT_VIDEO | SDL_INIT_EVENTS | SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER)
 
-WindowSDL::WindowSDL() {
-    mInit = false;
-    mWidth = DEFAULT_WIDTH;
-    mHeight = DEFAULT_HEIGHT;
-    mFullscreen = false;
-    mMousegrab = false;
-    mTextInput = false;
-    mWindow = nullptr;
-    mGLContext = nullptr;
-    controller = nullptr;
-}
-
-WindowSDL::~WindowSDL() {
-    if (mInit) {
-        if (controller)
-            SDL_GameControllerClose(controller);
-
-        SDL_QuitSubSystem(SUBSYSTEMS_USED);
-        SDL_Quit();
-    }
-}
-
-void WindowSDL::setSize(unsigned int width, unsigned int height) {
-    assert(width > 0);
-    assert(height > 0);
-
-    mWidth = width;
-    mHeight = height;
-
-    if (mInit == true) {
-        SDL_SetWindowSize(mWindow, mWidth, mHeight);
-        resizeGL();
-    }
-}
-
-void WindowSDL::setFullscreen(bool fullscreen) {
-    mFullscreen = fullscreen;
-
-    if (mInit == true) {
-        if (mFullscreen)
-            SDL_SetWindowFullscreen(mWindow, SDL_WINDOW_FULLSCREEN_DESKTOP);
-        else
-            SDL_SetWindowFullscreen(mWindow, 0);
-    }
-}
-
-void WindowSDL::setMousegrab(bool grab) {
-    mMousegrab = grab;
-
-    if (mInit == true) {
-        if (mMousegrab) {
-            SDL_SetRelativeMouseMode(SDL_TRUE);
-        } else {
-            SDL_SetRelativeMouseMode(SDL_FALSE);
-            SDL_ShowCursor(1);
-        }
-    }
-}
+glm::vec2 WindowSDL::size(DEFAULT_WIDTH, DEFAULT_HEIGHT);
+bool WindowSDL::fullscreen = false;
+bool WindowSDL::mousegrab = false;
+bool WindowSDL::textinput = false;
+SDL_Window* WindowSDL::window = nullptr;
+SDL_GLContext WindowSDL::context = nullptr;
+SDL_GameController* WindowSDL::controller = nullptr;
 
 int WindowSDL::initialize() {
-    assert(mInit == false);
-
     if (SDL_Init(SUBSYSTEMS_USED) != 0) {
         std::cout << "SDL_Init Error: " << SDL_GetError() << std::endl;
         return -1;
     }
 
     int flags = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE;
-    if (mFullscreen)
+    if (fullscreen)
         flags |= SDL_WINDOW_FULLSCREEN;
 
     if ((SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8) != 0)
@@ -103,45 +50,27 @@ int WindowSDL::initialize() {
         return -2;
     }
 
-    mWindow = SDL_CreateWindow(VERSION, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
-                               mWidth, mHeight, flags);
-    if (mWindow == nullptr) {
+    window = SDL_CreateWindow(VERSION, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
+                              size.x, size.y, flags);
+    if (!window) {
         std::cout << "SDL_CreateWindow Error: " << SDL_GetError() << std::endl;
         return -3;
     }
 
-    mGLContext = SDL_GL_CreateContext(mWindow);
-    if (mGLContext == nullptr) {
+    context = SDL_GL_CreateContext(window);
+    if (!context) {
         std::cout << "SDL_GL_CreateContext Error: " << SDL_GetError() << std::endl;
         return -4;
     }
 
-    mInit = true;
-    setSize(mWidth, mHeight);
-    setMousegrab(mMousegrab);
+    setMousegrab(mousegrab);
+    setTextInput(textinput);
 
     if (SDL_NumJoysticks() == 0) {
         getLog() << "No Joystick found!" << Log::endl;
         return 0;
     }
 
-    //! \todo Provide a way for user-defined controller mappings
-    /*
-        SDL_GameControllerAddMapping("341a0000000000000208000000000000,"
-                                     "USB GAMEPAD 8116,"
-                                     "a:b0,x:b2,start:b7,back:b6,leftstick:b8,rightstick:b9,"
-                                     "leftshoulder:b4,rightshoulder:b5,"
-                                     "dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,"
-                                     "leftx:a0,lefty:a1,rightx:a3,righty:a2,"
-                                     "lefttrigger:,b:b1,y:b3,lefttrigger:a4,righttrigger:a4");
-        SDL_GameControllerAddMapping("4c050000000000006802000000000000,"
-                                     "PLAYSTATION(R)3 Controller,"
-                                     "a:b14,b:b13,y:b12,x:b15,start:b3,guide:b16,back:b0,"
-                                     "leftstick:b1,rightstick:b2,leftshoulder:b10,"
-                                     "rightshoulder:b11,dpup:b4,dpleft:b7,dpdown:b6,dpright:b5,"
-                                     "leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b8,righttrigger:b9");
-    */
-
     for (int i = 0; i < SDL_NumJoysticks(); i++) {
         if (SDL_IsGameController(i)) {
             controller = SDL_GameControllerOpen(i);
@@ -158,6 +87,7 @@ int WindowSDL::initialize() {
                      << "\" is no controller!" << Log::endl;
         }
     }
+
     return 0;
 }
 
@@ -165,8 +95,6 @@ void WindowSDL::eventHandling() {
     SDL_Event event;
     KeyboardButton button;
 
-    assert(mInit == true);
-
     while (SDL_PollEvent(&event)) {
         switch (event.type) {
             case SDL_CONTROLLERAXISMOTION:
@@ -530,7 +458,7 @@ void WindowSDL::eventHandling() {
 
             case SDL_WINDOWEVENT:
                 if (event.window.event == SDL_WINDOWEVENT_RESIZED)
-                    setSize(event.window.data1, event.window.data2);
+                    setSize(glm::vec2(event.window.data1, event.window.data2));
                 break;
 
             case SDL_QUIT:
@@ -542,18 +470,65 @@ void WindowSDL::eventHandling() {
     UI::eventsFinished();
 }
 
-void WindowSDL::setTextInput(bool on) {
-    assert(mInit == true);
+void WindowSDL::swapBuffers() {
+    SDL_GL_SwapWindow(window);
+}
+
+void WindowSDL::shutdown() {
+    if (context) {
+        SDL_GL_DeleteContext(context);
+        context = nullptr;
+    }
+
+    if (controller) {
+        SDL_GameControllerClose(controller);
+        controller = nullptr;
+    }
+
+    if (window) {
+        SDL_DestroyWindow(window);
+        SDL_QuitSubSystem(SUBSYSTEMS_USED);
+        SDL_Quit();
+        window = nullptr;
+    }
+}
+
+void WindowSDL::setSize(glm::vec2 s) {
+    assert((s.x > 0) && (s.y > 0));
+
+    size = s;
+    if (window)
+        SDL_SetWindowSize(window, size.x, size.y);
+}
+
+void WindowSDL::setFullscreen(bool f) {
+    fullscreen = f;
+    if (window) {
+        if (fullscreen) {
+            SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
+        } else {
+            SDL_SetWindowFullscreen(window, 0);
+        }
+    }
+}
+
+void WindowSDL::setMousegrab(bool g) {
+    mousegrab = g;
+    if (window) {
+        if (mousegrab) {
+            SDL_SetRelativeMouseMode(SDL_TRUE);
+        } else {
+            SDL_SetRelativeMouseMode(SDL_FALSE);
+            SDL_ShowCursor(1);
+        }
+    }
+}
 
-    mTextInput = on;
-    if (mTextInput)
+void WindowSDL::setTextInput(bool t) {
+    textinput = t;
+    if (textinput)
         SDL_StartTextInput();
     else
         SDL_StopTextInput();
 }
 
-void WindowSDL::swapBuffersGL() {
-    assert(mInit == true);
-    SDL_GL_SwapWindow(mWindow);
-}
-