Fixed window resizing and initial camera offset.

ChangeLog.md

     * Now storing screenshots in PNG format
     * Updated imgui
     * Fixed StaticMesh Y-offset (position Y needed to be flipped)
+    * Draw Camera position along with view frustum
+    * _Fixed_ Camera position Y offset
+    * Window resizing working properly again
 
     [ 20141228 ]
     * Room Bounding Boxes are now visualized in Wireframe mode (again).

include/Camera.h

 #include <glm/vec3.hpp>
 #include <glm/mat4x4.hpp>
 #include <glm/gtc/quaternion.hpp>
+#include <glm/gtc/type_precision.hpp>
 
 #include "RoomData.h"
 
 class Camera {
   public:
-
     static void reset();
     static bool update();
+    static void setSize(glm::i32vec2 s);
 
     static void handleAction(ActionEvents action, bool isFinished);
     static void handleMouseMotion(int x, int y);
     static void handleControllerAxis(float value, KeyboardButton axis);
     static void handleControllerButton(KeyboardButton button, bool released);
 
-    static void setPosition(glm::vec3 p) { pos = p; }
-    static glm::vec3 getPosition() { return pos; }
+    //! \fixme The Y axis seems to be the source of all evil?
+    static void setPosition(glm::vec3 p) { pos = glm::vec3(p.x, -p.y, p.z); }
+    static glm::vec3 getPosition() { return glm::vec3(pos.x, -pos.y, pos.z); }
 
     static glm::vec2 getRotation();
     static glm::mat4 getProjectionMatrix() { return projection; }
     static void calculateFrustumPlanes();
 
     static glm::vec3 pos;
+    static glm::vec3 drawPos;
     static glm::quat quaternion;
     static glm::vec3 posSpeed;
     static glm::vec2 rotSpeed;
-    static glm::vec2 lastSize;
     static glm::mat4 projection;
     static glm::mat4 view;
     static float rotationDeltaX, rotationDeltaY;

include/Log.h

 #include <vector>
 #include <glm/vec2.hpp>
 #include <glm/vec3.hpp>
+#include <glm/gtc/type_precision.hpp>
 
 class Log {
   public:
         return (*this) << v.x << " " << v.y;
     }
 
+    Log& operator<< (const glm::i32vec2& v) {
+        return (*this) << v.x << " " << v.y;
+    }
+
     Log& operator<< (const glm::vec3& v) {
         return (*this) << v.x << " " << v.y << " " << v.z;
     }

include/Mesh.h

          const std::vector<IndexedColoredRectangle>& coloredRectangles,
          const std::vector<IndexedColoredRectangle>& coloredTriangles);
     void prepare();
-    void display(glm::mat4 model, glm::mat4 view, glm::mat4 projection);
+    void display(glm::mat4 MVP);
 
   private:
     std::vector<unsigned short> indices;

include/Render.h

 #define _RENDER_H_
 
 #include <vector>
+#include <glm/vec2.hpp>
 #include <glm/vec4.hpp>
+#include <glm/gtc/type_precision.hpp>
 
 #include "Room.h"
 #include "TextureManager.h"
 
 enum class RenderMode {
-    Disabled,
     LoadScreen,
     Solid,
     Wireframe,

include/Room.h

 class Room {
   public:
     Room(glm::vec3 _pos, BoundingBox* _bbox, RoomMesh* _mesh, unsigned int f,
-         int a, int x, int z)
-        : pos(_pos), bbox(_bbox), mesh(_mesh), flags(f), alternateRoom(a),
-          numXSectors(x), numZSectors(z) { }
+         int a, int x, int z);
 
     void prepare() { mesh->prepare(); }
-    void display(glm::mat4 view, glm::mat4 projection);
+    void display(glm::mat4 VP);
 
     bool isWall(unsigned long sector);
     long getSector(float x, float z, float* floor, float* ceiling);
 
   private:
     glm::vec3 pos;
+    glm::mat4 model;
     std::unique_ptr<BoundingBox> bbox;
     std::unique_ptr<RoomMesh> mesh;
 
     unsigned int flags;
+    int alternateRoom;
     int numXSectors;
     int numZSectors;
-    int alternateRoom;
 
     std::vector<std::unique_ptr<Sprite>> sprites;
     std::vector<std::unique_ptr<StaticModel>> models;

include/RoomData.h

 
 #include <memory>
 #include <vector>
+#include <glm/mat4x4.hpp>
 #include <glm/vec3.hpp>
 
 class BoundingBox {
 
 class StaticModel {
   public:
-    StaticModel(glm::vec3 p, float a, int i) : pos(p), angle(a), id(i), cache(-1) { }
-    void display(glm::mat4 view, glm::mat4 projection);
+    StaticModel(glm::vec3 pos, float angle, int i);
+    void display(glm::mat4 VP);
 
   private:
-    glm::vec3 pos;
-    float angle;
     int id;
     int cache;
+    glm::mat4 model;
 };
 
 // --------------------------------------

include/RoomMesh.h

              const std::vector<IndexedRectangle>& rectangles,
              const std::vector<IndexedRectangle>& triangles);
     void prepare();
-    void display(glm::mat4 model, glm::mat4 view, glm::mat4 projection);
+    void display(glm::mat4 MVP);
 
   private:
     std::vector<unsigned short> indices;

include/StaticMesh.h

   public:
     StaticMesh(int i, int m, BoundingBox* b1, BoundingBox* b2)
         : id(i), mesh(m), bbox1(b1), bbox2(b2) { }
-    void display(glm::mat4 model, glm::mat4 view, glm::mat4 projection);
+    void display(glm::mat4 MVP);
 
     int getID() { return id; }
 

include/UI.h

 #include <list>
 #include <memory>
 #include <tuple>
+#include <glm/vec2.hpp>
+#include <glm/gtc/type_precision.hpp>
 
 class ImDrawList;
 
     static void eventsFinished();
     static void display();
     static void shutdown();
+    static void setSize(glm::i32vec2 s);
 
     static void setVisible(bool v);
     static bool isVisible();

include/system/Window.h

 #include <glm/vec2.hpp>
 #include <glm/vec3.hpp>
 #include <glm/vec4.hpp>
+#include <glm/gtc/type_precision.hpp>
 
 #include "Shader.h"
 
     static void swapBuffers();
     static void shutdown();
 
-    static void setSize(glm::vec2 s);
-    static glm::vec2 getSize();
+    static void setSize(glm::i32vec2 s);
+    static glm::i32vec2 getSize();
 
     static void setFullscreen(bool f);
     static bool getFullscreen();

include/system/WindowGLFW.h

 #ifndef _WINDOW_GLFW_H_
 #define _WINDOW_GLFW_H_
 
+#include <glm/vec2.hpp>
+#include <glm/gtc/type_precision.hpp>
+
 #include <GLFW/glfw3.h>
 
 class WindowGLFW {
     static void swapBuffers();
     static void shutdown();
 
-    static void setSize(glm::vec2 s);
-    static glm::vec2 getSize() { return size; }
+    static void setSize(glm::i32vec2 s);
+    static glm::i32vec2 getSize() { return size; }
 
     static void setFullscreen(bool f);
     static bool getFullscreen() { return fullscreen; }
 
     static KeyboardButton convertAsciiButton(int key);
 
-    static glm::vec2 size;
+    static glm::i32vec2 size;
     static bool fullscreen;
     static bool mousegrab;
     static bool textinput;

include/system/WindowSDL.h

 #define _WINDOW_SDL_H_
 
 #include <glm/vec2.hpp>
+#include <glm/gtc/type_precision.hpp>
 
 #include "SDL.h"
 
     static void swapBuffers();
     static void shutdown();
 
-    static void setSize(glm::vec2 s);
-    static glm::vec2 getSize() { return size; }
+    static void setSize(glm::i32vec2 s);
+    static glm::i32vec2 getSize() { return size; }
 
     static void setFullscreen(bool f);
     static bool getFullscreen() { return fullscreen; }
     static bool getTextInput() { return textinput; }
 
   private:
-    static glm::vec2 size;
+    static glm::i32vec2 size;
     static bool fullscreen;
     static bool mousegrab;
     static bool textinput;

src/Camera.cpp

 const static glm::vec3 dirUnit(0.0f, 0.0f, -1.0f);
 
 glm::vec3 Camera::pos(0.0f, 0.0f, 0.0f);
+glm::vec3 Camera::drawPos(0.0f, 0.0f, 0.0f);
 glm::quat Camera::quaternion(glm::vec3(0.0f, 0.0f, 0.0f));
 glm::vec3 Camera::posSpeed(0.0f, 0.0f, 0.0f);
 glm::vec2 Camera::rotSpeed(0.0f, 0.0f);
-glm::vec2 Camera::lastSize(0.0f, 0.0f);
 glm::mat4 Camera::projection(1.0f);
 glm::mat4 Camera::view(1.0f);
 float Camera::rotationDeltaX = 0.75f;
 
 void Camera::reset() {
     pos = glm::vec3(0.0f, 0.0f, 0.0f);
+    drawPos = 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);
+
+    setSize(Window::getSize());
+}
+
+void Camera::setSize(glm::i32vec2 s) {
+    //! \fixme TODO instead of mirroring the Y axis in the shader, scale with -1 here
+    projection = glm::perspective(fov, float(s.x) / float(s.y), nearDist, farDist);
 }
 
 void Camera::handleAction(ActionEvents action, bool isFinished) {
 }
 
 bool Camera::update() {
-    glm::vec2 size(Window::getSize());
-
-    if (lastSize != size) {
-        //! \fixme TODO instead of mirroring the Y axis in the shader, scale with -1 here
-        projection = glm::perspective(fov, size.x / size.y, nearDist, farDist);
-        lastSize = size;
-    }
-
     if ((!dirty) && equal(posSpeed, 0.0f) && equal(rotSpeed, 0.0f))
         return false;
 
     planes[RIGHT].set(frustumVertices[NBR], frustumVertices[NTR], frustumVertices[FBR]);
     planes[NEAR].set(frustumVertices[NTL], frustumVertices[NTR], frustumVertices[NBR]);
     planes[FAR].set(frustumVertices[FTR], frustumVertices[FTL], frustumVertices[FBL]);
+
+    drawPos = getPosition();
 }
 
 bool Camera::boxInFrustum(BoundingBox b) {
     }
 
     Window::drawGL(verts, cols, inds, MVP);
+
+    verts.clear();
+    cols.clear();
+    inds.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);
 }
 

src/Game.cpp

             Render::setMode(RenderMode::Texture);
 
             Camera::setPosition(glm::vec3(getLara().getPos(0),
-                                          getLara().getPos(1) + 1024.0f,
+                                          getLara().getPos(1) - 1024.0f,
                                           getLara().getPos(2)));
         }
     } else {

src/Mesh.cpp

     colors = std::move(col);
 }
 
-void Mesh::display(glm::mat4 model, glm::mat4 view, glm::mat4 projection) {
-    glm::mat4 MVP = projection * view * model;
-
+void Mesh::display(glm::mat4 MVP) {
     if (indices.size() > 0) {
         unsigned int indexStart = 0;
         unsigned int indexPos = 1;

src/Render.cpp

 #include "utils/strings.h"
 #include "Render.h"
 
-RenderMode Render::mode = RenderMode::Disabled;
+RenderMode Render::mode = RenderMode::LoadScreen;
 std::vector<Room*> Render::roomList;
 bool Render::displayViewFrustum = false;
 
 void Render::setMode(RenderMode m) {
     mode = m;
     switch (mode) {
-        case RenderMode::Disabled:
-            break;
         case RenderMode::Solid:
         case RenderMode::Wireframe:
             //glClearColor(PURPLE[0] / 256.0f, PURPLE[1] / 256.0f,
         drawTexture(0.0f, 0.0f, Window::getSize().x, Window::getSize().y,
                     color, TEXTURE_SPLASH, TextureManager::TextureStorage::SYSTEM);
         return;
-    } else if (mode == RenderMode::Disabled) {
-        return;
     }
 
     if (mode == RenderMode::Wireframe) {
     if (Camera::update()) {
         clearRoomList();
         buildRoomList(-2); // TODO cache room
-        std::cout << "Rendering " << roomList.size() << "/"
-                  << getWorld().sizeRoom() << " rooms..." << std::endl;
     }
 
     glm::mat4 projection = Camera::getProjectionMatrix();
     glm::mat4 view = Camera::getViewMatrix();
+    glm::mat4 VP = projection * view;
 
     for (auto r : roomList) {
-        r->display(view, projection);
+        r->display(VP);
     }
 
     if (displayViewFrustum)
-        Camera::displayFrustum(projection * view);
+        Camera::displayFrustum(VP);
 
     if (mode == RenderMode::Wireframe) {
         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
                 return;
             }
         }
-        std::cout << "Camera not found!" << std::endl;
         buildRoomList(-1);
     } else if (room == -1) {
         // Check visibility for all rooms!
     Window::drawTextGL(vertices, uvs, color, texture);
 }
 
-static const int modeStringCount = 5;
+static const int modeStringCount = 4;
 static const char* modeStrings[modeStringCount] = {
-    "Disable", "Splash", "Texture", "Wireframe", "Solid"
+    "Splash", "Texture", "Wireframe", "Solid"
 };
 
 void Render::displayUI() {
-    if (ImGui::CollapsingHeader("Render Settings")) {
+    if (ImGui::CollapsingHeader("Render Settings##render")) {
         int item = 0;
-        if (mode == RenderMode::LoadScreen)
+        if (mode == RenderMode::Texture)
             item = 1;
-        else if (mode == RenderMode::Texture)
-            item = 2;
         else if (mode == RenderMode::Wireframe)
-            item = 3;
+            item = 2;
         else if (mode == RenderMode::Solid)
-            item = 4;
+            item = 3;
         if (ImGui::Combo("Mode", &item, modeStrings, modeStringCount)) {
             if (item == 0)
-                mode = RenderMode::Disabled;
-            else if (item == 1)
                 mode = RenderMode::LoadScreen;
-            else if (item == 2)
+            else if (item == 1)
                 mode = RenderMode::Texture;
-            else if (item == 3)
+            else if (item == 2)
                 mode = RenderMode::Wireframe;
-            else if (item == 4)
+            else if (item == 3)
                 mode = RenderMode::Solid;
         }
 
         bool updateViewFrustum = Camera::getUpdateViewFrustum();
-        if (ImGui::Checkbox("Update Frustum##runtime", &updateViewFrustum)) {
+        if (ImGui::Checkbox("Update Frustum##render", &updateViewFrustum)) {
             Camera::setUpdateViewFrustum(updateViewFrustum);
         }
         ImGui::SameLine();
-        ImGui::Checkbox("Show Frustum##runtime", &displayViewFrustum);
+        ImGui::Checkbox("Show Frustum##render", &displayViewFrustum);
     }
 }
 

src/Room.cpp

 #include "Room.h"
 #include "TextureManager.h"
 
-void Room::display(glm::mat4 view, glm::mat4 projection) {
-    glm::mat4 model = glm::translate(glm::mat4(1.0f), glm::vec3(pos[0], pos[1], pos[2]));
-    mesh->display(model, view, projection);
+Room::Room(glm::vec3 _pos, BoundingBox* _bbox, RoomMesh* _mesh, unsigned int f,
+           int a, int x, int z) : pos(_pos), bbox(_bbox), mesh(_mesh), flags(f),
+                                  alternateRoom(a), numXSectors(x), numZSectors(z) {
+    model = glm::translate(glm::mat4(1.0f), pos);
+}
+
+void Room::display(glm::mat4 VP) {
+    glm::mat4 MVP = VP * model;
+
+    mesh->display(MVP);
 
     for (auto& m : models) {
-        m->display(view, projection);
+        m->display(VP);
     }
 
     if (Render::getMode() == RenderMode::Wireframe)
-        bbox->display(projection * view, glm::vec3(0.0f, 1.0f, 0.0f), glm::vec3(1.0f, 0.0f, 1.0f));
+        bbox->display(VP, glm::vec3(0.0f, 1.0f, 0.0f), glm::vec3(1.0f, 0.0f, 1.0f));
 }
 
 bool Room::isWall(unsigned long sector) {

src/RoomData.cpp

 
 // ----------------------------------------------------------------------------
 
-void StaticModel::display(glm::mat4 view, glm::mat4 projection) {
+StaticModel::StaticModel(glm::vec3 pos, float angle, int i) : id(i), cache(-1) {
+    glm::mat4 translate = glm::translate(glm::mat4(1.0f), glm::vec3(pos.x, -pos.y, pos.z));
+    glm::mat4 rotate = glm::rotate(glm::mat4(1.0f), angle, glm::vec3(0.0f, 1.0f, 0.0f));
+    model = translate * rotate;
+}
+
+void StaticModel::display(glm::mat4 VP) {
     if (cache < 0) {
         for (int i = 0; i < getWorld().sizeStaticMesh(); i++) {
             if (getWorld().getStaticMesh(i).getID() == id) {
         assert(cache >= 0);
     }
 
-    glm::mat4 translate = glm::translate(glm::mat4(1.0f), glm::vec3(pos.x, -pos.y, pos.z));
-    glm::mat4 rotate = glm::rotate(glm::mat4(1.0f), angle, glm::vec3(0.0f, 1.0f, 0.0f));
-    glm::mat4 model = translate * rotate;
-    getWorld().getStaticMesh(cache).display(model, view, projection);
+    getWorld().getStaticMesh(cache).display(VP * model);
 }
 
 // ----------------------------------------------------------------------------

src/RoomMesh.cpp

     textures = std::move(tex);
 }
 
-void RoomMesh::display(glm::mat4 model, glm::mat4 view, glm::mat4 projection) {
-    glm::mat4 MVP = projection * view * model;
-
+void RoomMesh::display(glm::mat4 MVP) {
     if (indices.size() > 0) {
         unsigned int indexStart = 0;
         unsigned int indexPos = 1;

src/StaticMesh.cpp

 #include "World.h"
 #include "StaticMesh.h"
 
-void StaticMesh::display(glm::mat4 model, glm::mat4 view, glm::mat4 projection) {
-    getWorld().getMesh(mesh).display(model, view, projection);
+void StaticMesh::display(glm::mat4 MVP) {
+    getWorld().getMesh(mesh).display(MVP);
 
     if (Render::getMode() == RenderMode::Wireframe) {
-        bbox1->display(projection * view * model,
-                       glm::vec3(1.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
-        bbox2->display(projection * view * model,
-                       glm::vec3(1.0f, 0.0f, 1.0f), glm::vec3(0.0f, 0.0f, 1.0f));
+        bbox1->display(MVP, glm::vec3(1.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
+        bbox2->display(MVP, glm::vec3(1.0f, 0.0f, 1.0f), glm::vec3(0.0f, 0.0f, 1.0f));
     }
 }
 

src/UI.cpp

 std::list<std::tuple<int, int, int, int>> UI::motionEvents;
 std::list<std::tuple<int, int>> UI::scrollEvents;
 
+void UI::setSize(glm::i32vec2 s) {
+    ImGuiIO& io = ImGui::GetIO();
+    io.DisplaySize = ImVec2(s.x, s.y);
+}
+
 int UI::initialize() {
     iniFilename = RunTime::getBaseDir() + "/imgui.ini";
     logFilename = RunTime::getBaseDir() + "/imgui_log.txt";

src/commands/CommandRender.cpp

  */
 
 #include "global.h"
-#include "Game.h"
 #include "Log.h"
 #include "Render.h"
 #include "commands/CommandRender.h"
     getLog() << "  solid" << Log::endl;
     getLog() << "  texture" << Log::endl;
     getLog() << "  titlescreen" << Log::endl;
-    getLog() << "  disabled" << Log::endl;
 
 }
 
 int CommandMode::execute(std::istream& args) {
-    if (!getGame().isLoaded()) {
-        getLog() << "Load a level to set the mode!" << Log::endl;
-        return -1;
-    }
-
     std::string s;
     args >> s;
 
     } else if (s == "titlescreen") {
         Render::setMode(RenderMode::LoadScreen);
         getLog() << "Titlescreen mode" << Log::endl;
-    } else if (s == "disabled") {
-        Render::setMode(RenderMode::Disabled);
-        getLog() << "Disabled mode" << Log::endl;
     } else {
         getLog() << "Invalid use of mode command (" << s << ")!" << Log::endl;
         return -2;

src/main.cpp

 #include <memory>
 
 #include "global.h"
+#include "Camera.h"
 #include "Exception.h"
 #include "Game.h"
 #include "Log.h"
     }
 
     getLog() << "Starting " << VERSION << Log::endl;
+    Camera::setSize(Window::getSize());
     getMenu().setVisible(true);
     systemTimerReset();
     RunTime::setRunning(true);

src/system/Window.cpp

  */
 
 #include "global.h"
+#include "Camera.h"
 #include "Log.h"
+#include "UI.h"
 #include "utils/strings.h"
 #include "system/Window.h"
 
 #endif
 }
 
-void Window::setSize(glm::vec2 s) {
+void Window::setSize(glm::i32vec2 s) {
 #ifdef USING_SDL
     WindowSDL::setSize(s);
 #elif defined(USING_GLFW)
     WindowGLFW::setSize(s);
 #endif
+
+    UI::setSize(s);
+    Camera::setSize(s);
+    glViewport(0, 0, s.x, s.y);
 }
 
-glm::vec2 Window::getSize() {
-    glm::vec2 ret(-1, -1);
+glm::i32vec2 Window::getSize() {
+    glm::i32vec2 ret(-1, -1);
 #ifdef USING_SDL
     ret = WindowSDL::getSize();
 #elif defined(USING_GLFW)

src/system/WindowGLFW.cpp

 #include "Log.h"
 #include "RunTime.h"
 #include "UI.h"
+#include "system/Window.h"
 #include "utils/strings.h"
 #include "system/WindowGLFW.h"
 
-glm::vec2 WindowGLFW::size(DEFAULT_WIDTH, DEFAULT_HEIGHT);
+glm::i32vec2 WindowGLFW::size(DEFAULT_WIDTH, DEFAULT_HEIGHT);
 bool WindowGLFW::fullscreen = false;
 bool WindowGLFW::mousegrab = false;
 bool WindowGLFW::textinput = false;
     }
 }
 
-void WindowGLFW::setSize(glm::vec2 s) {
+void WindowGLFW::setSize(glm::i32vec2 s) {
     assert((s.x > 0) && (s.y > 0));
     if (window) {
         if ((size.x != s.x) || (size.y != s.y)) {
 }
 
 void WindowGLFW::sizeCallback(GLFWwindow* w, int width, int height) {
-    size = glm::vec2(width, height);
+    size = glm::i32vec2(width, height);
+    Window::setSize(size);
 }
 
 void WindowGLFW::cursorCallback(GLFWwindow* w, double xpos, double ypos) {

src/system/WindowSDL.cpp

 #include "Log.h"
 #include "RunTime.h"
 #include "UI.h"
+#include "system/Window.h"
 #include "utils/strings.h"
 #include "system/WindowSDL.h"
 
 #define SUBSYSTEMS_USED (SDL_INIT_VIDEO | SDL_INIT_EVENTS | SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER)
 
-glm::vec2 WindowSDL::size(DEFAULT_WIDTH, DEFAULT_HEIGHT);
+glm::i32vec2 WindowSDL::size(DEFAULT_WIDTH, DEFAULT_HEIGHT);
 bool WindowSDL::fullscreen = false;
 bool WindowSDL::mousegrab = false;
 bool WindowSDL::textinput = false;
                 break;
 
             case SDL_WINDOWEVENT:
-                if (event.window.event == SDL_WINDOWEVENT_RESIZED)
-                    setSize(glm::vec2(event.window.data1, event.window.data2));
+                if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
+                    size = glm::i32vec2(event.window.data1, event.window.data2);
+                    Window::setSize(size);
+                }
                 break;
 
             case SDL_QUIT:
     }
 }
 
-void WindowSDL::setSize(glm::vec2 s) {
+void WindowSDL::setSize(glm::i32vec2 s) {
     assert((s.x > 0) && (s.y > 0));
-
+    if (window) {
+        if ((s.x != size.x) || (s.y != size.y)) {
+            SDL_SetWindowSize(window, size.x, size.y);
+        }
+    }
     size = s;
-    if (window)
-        SDL_SetWindowSize(window, size.x, size.y);
 }
 
 void WindowSDL::setFullscreen(bool f) {