Support for Room Sprites

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20140117 ]
+    * Updated imgui, fix for Logging to Clipboard included.
+    * Sprites and SpriteSequences are now stored independently in World.
+    * Added support for Room Sprites displaying.
+    * Can now toggle display of Room geometry, models and sprites.
+    * Room list is now displayed in reverse. This _fixes_ some transparency issues.
+
     [ 20140111 ]
     * Enabled back face culling --> triangles now oriented correctly
     * Game is now completely static

include/Log.h

 
     static LogLevel& get(int level);
     static unsigned long size() { return wholeLog.size(); }
-    static LogEntry getEntry(unsigned long i) { return wholeLog.at(i); }
+    static LogEntry& getEntry(unsigned long i) { return wholeLog.at(i); }
 
   private:
     static LogLevel logs[LOG_COUNT];

include/Room.h

 
     unsigned int getFlags() { return flags; }
 
-    unsigned long sizePortals();
-    Portal& getPortal(unsigned long index);
-    void addPortal(Portal* p);
+    void addSprite(RoomSprite* s) { sprites.emplace_back(s); }
+    void addModel(StaticModel* s) { models.emplace_back(s); }
+    void addSector(Sector* s) { sectors.emplace_back(s); }
+    void addLight(Light* l) { lights.emplace_back(l); }
 
-    unsigned long sizeSectors();
-    Sector& getSector(unsigned long index);
-    void addSector(Sector* s);
+    void addPortal(Portal* p) { portals.emplace_back(p); }
+    unsigned long sizePortals() { return portals.size(); }
+    Portal& getPortal(unsigned long index) { return *portals.at(index); }
 
-    unsigned long sizeModels();
-    StaticModel& getModel(unsigned long index);
-    void addModel(StaticModel* s);
+    static void setShowBoundingBox(bool s) { showBoundingBox = s; }
+    static bool getShowBoundingBox() { return showBoundingBox; }
 
-    unsigned long sizeLights();
-    Light& getLight(unsigned long index);
-    void addLight(Light* l);
+    static void setShowRoomModels(bool s) { showRoomModels = s; }
+    static bool getShowRoomModels() { return showRoomModels; }
 
-    unsigned long sizeSprites();
-    Sprite& getSprite(unsigned long index);
-    void addSprite(Sprite* s);
+    static void setShowRoomSprites(bool s) { showRoomSprites = s; }
+    static bool getShowRoomSprites() { return showRoomSprites; }
 
-    static void setShowBoundingBox(bool s) { showBoundingBox = s; }
-    static bool getShowBoundingBox() { return showBoundingBox; }
+    static void setShowRoomGeometry(bool s) { showRoomGeometry = s; }
+    static bool getShowRoomGeometry() { return showRoomGeometry; }
 
   private:
     glm::vec3 pos;
     int numXSectors;
     int numZSectors;
 
-    std::vector<std::unique_ptr<Sprite>> sprites;
+    std::vector<std::unique_ptr<RoomSprite>> sprites;
     std::vector<std::unique_ptr<StaticModel>> models;
     std::vector<std::unique_ptr<Portal>> portals;
     std::vector<std::unique_ptr<Sector>> sectors;
     std::vector<std::unique_ptr<Light>> lights;
 
     static bool showBoundingBox;
+    static bool showRoomModels;
+    static bool showRoomSprites;
+    static bool showRoomGeometry;
 };
 
 #endif

include/RoomData.h

 
 // --------------------------------------
 
+class RoomSprite {
+  public:
+    RoomSprite(glm::vec3 p, int s) : pos(p), sprite(s) { }
+    void display(glm::mat4 VP);
+
+  private:
+    glm::vec3 pos;
+    int sprite;
+};
+
+// --------------------------------------
+
 class Portal {
   public:
     Portal(int adj, glm::vec3 n, glm::vec3 v1, glm::vec3 v2, glm::vec3 v3,

include/Sprite.h

 #ifndef _SPRITE_H_
 #define _SPRITE_H_
 
-#include <cstdint>
-
-#include "loader/Loader.h"
+#include "system/Shader.h"
 
 class Sprite {
   public:
-    Sprite(uint16_t tile, uint8_t x, uint8_t y, uint16_t width, uint16_t height);
-    void display();
-    void display(float x, float y, float w, float h);
+    Sprite(int tile, int x, int y, int width, int height);
+    void display(glm::mat4 MVP);
 
   private:
-    float vertex[4][3];
-    float texel[4][2];
-    //float pos[3];
-    //float radius; //!< \fixme yeah, I know (I don't? --xythobuz)
     int texture;
+    ShaderBuffer vertices, uvs;
 };
 
 class SpriteSequence {
   public:
-    SpriteSequence(int32_t objectID);
-    void add(Sprite s);
-
-    unsigned long size();
-    Sprite& get(unsigned long index);
+    SpriteSequence(int objectID, int offset, int size)
+        : id(objectID), start(offset), length(size) { }
 
   private:
-    int32_t id;
-    std::vector<Sprite> sprites;
+    int id;
+    int start;
+    int length;
 };
 
 #endif

include/World.h

     unsigned long sizeRoom();
     Room& getRoom(unsigned long index);
 
-    void addSprite(SpriteSequence* sprite);
+    void addSprite(Sprite* sprite);
     unsigned long sizeSprite();
-    SpriteSequence& getSprite(unsigned long index);
+    Sprite& getSprite(unsigned long index);
+
+    void addSpriteSequence(SpriteSequence* sprite);
+    unsigned long sizeSpriteSequence();
+    SpriteSequence& getSpriteSequence(unsigned long index);
 
     void addEntity(Entity* entity);
     unsigned long sizeEntity();
 
   private:
     std::vector<std::unique_ptr<Room>> mRooms;
-    std::vector<std::unique_ptr<SpriteSequence>> mSprites;
+    std::vector<std::unique_ptr<Sprite>> mSprites;
+    std::vector<std::unique_ptr<SpriteSequence>> mSpriteSequences;
     std::vector<std::unique_ptr<Entity>> mEntities;
     std::vector<std::unique_ptr<SkeletalModel>> mModels;
     std::vector<std::unique_ptr<StaticMesh>> mStaticMeshes;

src/Console.cpp

         else if (logToFile)
             ImGui::LogToFile();
         for (unsigned long i = 0; i < Log::size(); i++) {
-            auto entry = Log::getEntry(i);
+            auto& entry = Log::getEntry(i);
 
             assert(entry.level < LOG_COUNT);
             if (!visibleLogs[entry.level]) {

src/Render.cpp

  * \author xythobuz
  */
 
+#include <fstream>
 #include <sstream>
 
 #include "global.h"
     glm::mat4 view = Camera::getViewMatrix();
     glm::mat4 VP = projection * view;
 
-    for (auto r : roomList) {
-        r->display(VP);
+    for (int r = roomList.size() - 1; r >= 0; r--) {
+        roomList.at(r)->display(VP);
     }
 
     if (displayViewFrustum)
         if (ImGui::Checkbox("StaticMesh##bbox", &showBoundingBox2)) {
             StaticMesh::setShowBoundingBox(showBoundingBox2);
         }
+
+        ImGui::Separator();
+        ImGui::Text("Renderable Objects:");
+        bool showRoomGeometry = Room::getShowRoomGeometry();
+        if (ImGui::Checkbox("Room Geometry##render", &showRoomGeometry)) {
+            Room::setShowRoomGeometry(showRoomGeometry);
+        }
+        ImGui::SameLine();
+        bool showRoomModels = Room::getShowRoomModels();
+        if (ImGui::Checkbox("Room Models##render", &showRoomModels)) {
+            Room::setShowRoomModels(showRoomModels);
+        }
+        ImGui::SameLine();
+        bool showRoomSprites = Room::getShowRoomSprites();
+        if (ImGui::Checkbox("Room Sprites##render", &showRoomSprites)) {
+            Room::setShowRoomSprites(showRoomSprites);
+        }
+
+        ImGui::Separator();
+        if (ImGui::Button("New Splash##render")) {
+            TextureManager::initializeSplash();
+        }
     }
 }
 

src/Room.cpp

 #include <glm/gtx/intersect.hpp>
 
 bool Room::showBoundingBox = false;
+bool Room::showRoomModels = true;
+bool Room::showRoomSprites = true;
+bool Room::showRoomGeometry = true;
 
 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),
 void Room::display(glm::mat4 VP) {
     glm::mat4 MVP = VP * model;
 
-    mesh->display(MVP);
+    if (showRoomGeometry)
+        mesh->display(MVP);
 
-    for (auto& m : models) {
-        m->display(VP);
+    if (showRoomModels) {
+        for (auto& m : models) {
+            m->display(VP);
+        }
+    }
+
+    if (showRoomSprites) {
+        for (auto& s : sprites) {
+            s->display(VP);
+        }
     }
 
     if (showBoundingBox)
     return -1;
 }
 
-// --------------------------------------
-
-unsigned long Room::sizePortals() {
-    return portals.size();
-}
-
-Portal& Room::getPortal(unsigned long index) {
-    assert(index < portals.size());
-    return *portals.at(index);
-}
-
-void Room::addPortal(Portal* p) {
-    portals.emplace_back(p);
-}
-
-unsigned long Room::sizeSectors() {
-    return sectors.size();
-}
-
-Sector& Room::getSector(unsigned long index) {
-    assert(index < sectors.size());
-    return *sectors.at(index);
-}
-
-void Room::addSector(Sector* s) {
-    sectors.emplace_back(s);
-}
-
-unsigned long Room::sizeModels() {
-    return models.size();
-}
-
-StaticModel& Room::getModel(unsigned long index) {
-    assert(index < models.size());
-    return *models.at(index);
-}
-
-void Room::addModel(StaticModel* s) {
-    models.emplace_back(s);
-}
-
-unsigned long Room::sizeLights() {
-    return lights.size();
-}
-
-Light& Room::getLight(unsigned long index) {
-    assert(index < lights.size());
-    return *lights.at(index);
-}
-
-void Room::addLight(Light* l) {
-    lights.emplace_back(l);
-}
-
-unsigned long Room::sizeSprites() {
-    return sprites.size();
-}
-
-Sprite& Room::getSprite(unsigned long index) {
-    assert(index < sprites.size());
-    return *sprites.at(index);
-}
-
-void Room::addSprite(Sprite* s) {
-    sprites.emplace_back(s);
-}
-

src/RoomData.cpp

  */
 
 #include "global.h"
+#include "Camera.h"
 #include "World.h"
 #include "system/Shader.h"
 #include "RoomData.h"
 
 // ----------------------------------------------------------------------------
 
+void RoomSprite::display(glm::mat4 VP) {
+    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), Camera::getRotation().x, glm::vec3(0.0f, 1.0f, 0.0f));
+    glm::mat4 model = translate * rotate;
+
+    getWorld().getSprite(sprite).display(VP * model);
+}
+
+// ----------------------------------------------------------------------------
+
 void Light::getPos(float p[4]) {
     p[0] = pos[0];
     p[1] = pos[1];

src/Sprite.cpp

 #include "TextureManager.h"
 #include "Sprite.h"
 
-SpriteSequence::SpriteSequence(int32_t objectID) {
-    id = objectID;
-}
-
-void SpriteSequence::add(Sprite s) {
-    sprites.push_back(s);
-}
-
-unsigned long SpriteSequence::size() {
-    return sprites.size();
-}
-
-Sprite& SpriteSequence::get(unsigned long index) {
-    assert(index < sprites.size());
-    return sprites.at(index);
-}
-
-// ----------------------------------------------------------------------------
-
-Sprite::Sprite(uint16_t tile, uint8_t x, uint8_t y, uint16_t width, uint16_t height) {
-    /*!
-     * \fixme TODO Can't do translation/visibility-check when rendering here.
-     * We don't know xyz of this Sprite because it could be used by
-     * different items at other coordinates in the world.
-     * Do translation/visibility-check at item/room level.
-     */
-
-    const float scale = 4.0f;
-    const float texelScale = 256.0f;
+const static float scale = 4.0f;
+const static float texelScale = 256.0f;
+const static int texelOffset = 2;
 
+Sprite::Sprite(int tile, int x, int y, int width, int height) : texture(tile) {
     width >>= 8;
     height >>= 8;
+
     int width2 = (int)(width * scale);
     int height2 = (int)(height * scale);
 
-    vertex[0][0] = -width2 / 2.0f;
-    vertex[1][0] = -width2 / 2.0f;
-    vertex[2][0] = width2 / 2.0f;
-    vertex[3][0] = width2 / 2.0f;
-
-    vertex[0][1] = 0;
-    vertex[1][1] = -height2;
-    vertex[2][1] = -height2;
-    vertex[3][1] = 0;
-
-    vertex[0][2] = 0;
-    vertex[1][2] = 0;
-    vertex[2][2] = 0;
-    vertex[3][2] = 0;
-
-    texel[3][0] = (float)(x + width) / texelScale;
-    texel[3][1] = (float)(y + height) / texelScale;
-
-    texel[2][0] = (float)(x + width) / texelScale;
-    texel[2][1] = (float)(y) / texelScale;
-
-    texel[1][0] = (float)(x) / texelScale;
-    texel[1][1] = (float)(y) / texelScale;
-
-    texel[0][0] = (float)(x) / texelScale;
-    texel[0][1] = (float)(y + height) / texelScale;
-
-    texture = tile;
-    //radius = width2 / 2.0f;
+    std::vector<glm::vec2> uv;
+    uv.emplace_back(float(x + texelOffset) / texelScale, float(y + height) / texelScale);
+    uv.emplace_back(float(x + texelOffset) / texelScale, float(y + texelOffset) / texelScale);
+    uv.emplace_back(float(x + width) / texelScale, float(y + texelOffset) / texelScale);
+    uv.emplace_back(float(x + width) / texelScale, float(y + height) / texelScale);
+    uv.emplace_back(uv.at(0));
+    uv.emplace_back(uv.at(2));
+
+    std::vector<glm::vec3> vert;
+    vert.emplace_back(float(-width2) / 2.0f, 0.0f, 0.0f);
+    vert.emplace_back(float(-width2) / 2.0f, float(-height2), 0.0f);
+    vert.emplace_back(float(width2) / 2.0f, float(-height2), 0.0f);
+    vert.emplace_back(float(width2) / 2.0f, 0.0f, 0.0f);
+    vert.emplace_back(vert.at(0));
+    vert.emplace_back(vert.at(2));
+
+    vertices.bufferData(vert);
+    uvs.bufferData(uv);
 }
 
-void Sprite::display() {
-    /*
-    //if (!Render::isVisible(pos[0], pos[1], pos[2], radius))
-    //    return;
-
-    glPushMatrix();
-    //glTranslated(pos[0], pos[1], pos[2]);
-
-    // Sprites must always face camera, because they have no depth =)
-    glRotated(glm::degrees(Camera::getRadianYaw()), 0, 1, 0);
-
-    switch (Render::getMode()) {
-        // No vertex lighting on sprites, as far as I see in specs
-        // So just draw normal texture, no case 2
-        case RenderMode::Solid:
-            glBegin(GL_TRIANGLE_STRIP);
-            glColor3f(texel[0][0], texel[0][1], 0.5);
-            glVertex3fv(vertex[0]);
-
-            glColor3f(texel[1][0], texel[1][1], 0.5);
-            glVertex3fv(vertex[1]);
-
-            glColor3f(texel[3][0], texel[3][1], 0.5);
-            glVertex3fv(vertex[3]);
-
-            glColor3f(texel[2][0], texel[2][1], 0.5);
-            glVertex3fv(vertex[2]);
-            glEnd();
-            break;
-        case RenderMode::Wireframe:
-            glColor3ubv(CYAN);
-            glBegin(GL_LINE_LOOP);
-            glVertex3fv(vertex[0]);
-            glVertex3fv(vertex[1]);
-            glVertex3fv(vertex[2]);
-            glVertex3fv(vertex[3]);
-            glEnd();
-            glColor3ubv(WHITE);
-            break;
-        default:
-            getTextureManager().bindTextureId(texture);
-
-            glBegin(GL_TRIANGLE_STRIP);
-            glTexCoord2fv(texel[0]);
-            glVertex3fv(vertex[0]);
-            glTexCoord2fv(texel[1]);
-            glVertex3fv(vertex[1]);
-            glTexCoord2fv(texel[3]);
-            glVertex3fv(vertex[3]);
-            glTexCoord2fv(texel[2]);
-            glVertex3fv(vertex[2]);
-            glEnd();
-    }
-
-    glPopMatrix();
-    */
-}
-
-void Sprite::display(float x, float y, float w, float h) {
-    /*
-    float z = 0.0f;
-
-    getTextureManager().bindTextureId(texture);
-
-    glBegin(GL_QUADS);
-
-    glTexCoord2fv(texel[1]);
-    glVertex3f(x, y, z);
-
-    glTexCoord2fv(texel[2]);
-    glVertex3f(x + w, y, z);
-
-    glTexCoord2fv(texel[3]);
-    glVertex3f(x + w, y + h, z);
-
-    glTexCoord2fv(texel[0]);
-    glVertex3f(x, y + h, z);
-
-    glEnd();
-    */
+void Sprite::display(glm::mat4 MVP) {
+    Shader::drawGL(vertices, uvs, texture, MVP);
 }
 

src/TextureManager.cpp

         mTextureIdsSystem.push_back(id);
     }
 
-    return 0;
-}
-
-int TextureManager::initializeSplash() {
     unsigned char* image = generateColorTexture(WHITE, 32, 32, 32);
     int res = loadBufferSlot(image, 32, 32, ColorMode::RGBA, 32, TextureStorage::SYSTEM, TEXTURE_WHITE,
                              false);
         return -1;
     }
 
+    return 0;
+}
+
+int TextureManager::initializeSplash() {
     Folder f(RunTime::getPakDir());
     std::vector<File> files;
     f.findRecursiveFilesEndingWith(files, ".pcx");

src/World.cpp

     return *mRooms.at(index);
 }
 
-void World::addSprite(SpriteSequence* sprite) {
-    mSprites.emplace_back(std::unique_ptr<SpriteSequence>(sprite));
+void World::addSprite(Sprite* sprite) {
+    mSprites.emplace_back(std::unique_ptr<Sprite>(sprite));
 }
 
 unsigned long World::sizeSprite() {
     return mSprites.size();
 }
 
-SpriteSequence& World::getSprite(unsigned long index) {
+Sprite& World::getSprite(unsigned long index) {
     assert(index < mSprites.size());
     return *mSprites.at(index);
 }
 
+void World::addSpriteSequence(SpriteSequence* sprite) {
+    mSpriteSequences.emplace_back(std::unique_ptr<SpriteSequence>(sprite));
+}
+
+unsigned long World::sizeSpriteSequence() {
+    return mSpriteSequences.size();
+}
+
+SpriteSequence& World::getSpriteSequence(unsigned long index) {
+    assert(index < mSpriteSequences.size());
+    return *mSpriteSequences.at(index);
+}
+
 void World::addEntity(Entity* entity) {
     mEntities.emplace_back(std::unique_ptr<Entity>(entity));
 }

src/deps/imgui/imgui.cpp

-// ImGui library v1.20
+// ImGui library v1.21 wip
 // See ImGui::ShowTestWindow() for sample code.
 // Read 'Programmer guide' below for notes on how to setup ImGui in your codebase.
 // Get latest version at https://github.com/ocornut/imgui
  - window: fix resize grip rendering scaling along with Rounding style setting
  - window: autofit feedback loop when user relies on any dynamic layout (window width multiplier, column). maybe just clearly drop manual autofit?
  - window: add a way for very transient windows (non-saved, temporary overlay over hundreds of objects) to "clean" up from the global window list. 
+ - window: allow resizing of child windows (possibly given min/max for each axis?)
+ - window: resizing from any sides? + mouse cursor directives for app.
  - widgets: switching from "widget-label" to "label-widget" would make it more convenient to integrate widgets in trees
  - widgets: clip text? hover clipped text shows it in a tooltip or in-place overlay
- - widgets: IsItemHovered() returns true even if mouse is active on another widget (e.g. dragging outside of sliders). Maybe not a sensible default? Add parameter or alternate function?
- - main: make IsHovered() more consistent for various type of widgets, widgets with multiple components, etc. also effectively IsHovered() region sometimes differs from hot region, e.g tree nodes
- - main: make IsHovered() info stored in a stack? so that 'if TreeNode() { Text; TreePop; } if IsHovered' return the hover state of the TreeNode?
+ - main: IsItemHovered() returns true even if mouse is active on another widget (e.g. dragging outside of sliders). Maybe not a sensible default? Add parameter or alternate function?
+ - main: IsItemHovered() make it more consistent for various type of widgets, widgets with multiple components, etc. also effectively IsHovered() region sometimes differs from hot region, e.g tree nodes
+ - main: IsItemHovered() info stored in a stack? so that 'if TreeNode() { Text; TreePop; } if IsHovered' return the hover state of the TreeNode?
  - scrollbar: use relative mouse movement when first-clicking inside of scroll grab box.
  - scrollbar: make the grab visible and a minimum size for long scroll regions
 !- input number: very large int not reliably supported because of int<>float conversions.
  - input number: use mouse wheel to step up/down
  - input number: non-decimal input.
  - layout: horizontal layout helper (github issue #97)
- - layout: clean up the InputFloatN/SliderFloatN/ColorEdit4 horrible layout code. item width should include frame padding.
+ - layout: clean up the InputFloatN/SliderFloatN/ColorEdit4 layout code. item width should include frame padding.
  - columns: separator function or parameter that works within the column (currently Separator() bypass all columns)
  - columns: declare column set (each column: fixed size, %, fill, distribute default size among fills)
  - columns: columns header to act as button (~sort op) and allow resize/reorder
  - file selection widget -> build the tool in our codebase to improve model-dialog idioms (may or not lead to ImGui changes)
  - slider: allow using the [-]/[+] buttons used by InputFloat()/InputInt()
  - slider: initial absolute click is imprecise. change to relative movement slider? hide mouse cursor, allow more precise input using less screen-space.
- - text edit: clean up the horrible mess caused by converting UTF-8 <> wchar
+ - text edit: clean up the mess caused by converting UTF-8 <> wchar
  - text edit: centered text for slider or input text to it matches typical positioning.
  - text edit: flag to disable live update of the user buffer. 
  - text edit: field resize behavior - field could stretch when being edited? hover tooltip shows more text?
  - text edit: add multi-line text edit
  - settings: write more decent code to allow saving/loading new fields
  - settings: api for per-tool simple persistent data (bool,int,float) in .ini file
+ - style: checkbox: padding for "active" color should be a multiplier of the 
+ - style: colorbox not always square?
  - log: LogButtons() options for specifying depth and/orhiding depth slider
  - log: have more control over the log scope (e.g. stop logging when leaving current tree node scope)
  - log: be able to right-click and log a window or tree-node into tty/file/clipboard / generalized context menu?
  - tooltip: move to fit within screen (e.g. when mouse cursor is right of the screen).
  - clipboard: automatically transform \n into \n\r or equivalent for higher compatibility on windows
  - portability: big-endian test/support (github issue #81)
- - examples: add History support in the demo console application (pertinent to github issue #68).
+ - misc: rounded triangle fail to draw correctly on OpenGL3 example.
  - misc: provide a way to compile out the entire implementation while providing a dummy API (e.g. #define IMGUI_DUMMY_IMPL)
  - misc: double-clicking on title bar to minimize isn't consistent, perhaps move to single-click on left-most collapse icon?
- - style editor: add a button to output C code.
+ - style editor: color child window height expressed in multiple of line height.
  - optimization/render: use indexed rendering to reduce vertex data cost (for remote/networked imgui)
  - optimization/render: move clip-rect to vertex data? would allow merging all commands
  - optimization/render: merge command-lists with same clip-rect into one even if they aren't sequential? (as long as in-between clip rectangle don't overlap)?
- - optimization/render: font exported by bmfont is not tight fit on vertical axis, incur unneeded pixel-shading cost.
  - optimization: turn some the various stack vectors into statically-sized arrays
  - optimization: better clipping for multi-component widgets
  - optimization: specialize for height based clipping first (assume widgets never go up + height tests before width tests?)
 {
     Alpha                   = 1.0f;             // Global alpha applies to everything in ImGui
     WindowPadding           = ImVec2(8,8);      // Padding within a window
-    WindowMinSize           = ImVec2(48,48);    // Minimum window size
+    WindowMinSize           = ImVec2(32,32);    // Minimum window size
     WindowRounding          = 9.0f;             // Radius of window corners rounding. Set to 0.0f to have rectangular windows
     FramePadding            = ImVec2(4,3);      // Padding within a framed rectangle (used by most widgets)
+    FrameRounding           = 0.0f;             // Radius of frame corners rounding. Set to 0.0f to have rectangular frames (used by most widgets).
     ItemSpacing             = ImVec2(8,4);      // Horizontal and vertical spacing between widgets/lines
     ItemInnerSpacing        = ImVec2(4,4);      // Horizontal and vertical spacing between within elements of a composed widget (e.g. a slider and its label)
     TouchExtraPadding       = ImVec2(0,0);      // Expand bounding box for touch-based system where touch position is not accurate enough (unnecessary for mouse inputs). Unfortunately we don't sort widgets so priority on overlap will always be given to the first widget running. So dont grow this too much!
 
 //-----------------------------------------------------------------------------
 
+// On some platform vsnprintf() takes va_list by reference and modifies it. 
+// va_copy is the 'correct' way to copy a va_list but Visual Studio prior to 2013 doesn't have it.
+#ifndef va_copy
+#define va_copy(dest, src) (dest = src)
+#endif
+
 // Helper: Text buffer for logging/accumulating text
 void ImGuiTextBuffer::appendv(const char* fmt, va_list args)
 {
+    va_list args_copy;
+    va_copy(args_copy, args);
+
     int len = vsnprintf(NULL, 0, fmt, args);         // FIXME-OPT: could do a first pass write attempt, likely successful on first pass.
     if (len <= 0)
         return;
+
     const size_t write_off = Buf.size();
+    const size_t needed_sz = write_off + (size_t)len;
     if (write_off + (size_t)len >= Buf.capacity())
-        Buf.reserve(Buf.capacity() * 2);
+    {
+        const size_t double_capacity = Buf.capacity() * 2;
+        Buf.reserve(needed_sz > double_capacity ? needed_sz : double_capacity);
+    }
 
-    Buf.resize(write_off + (size_t)len);
-    ImFormatStringV(&Buf[write_off] - 1, (size_t)len+1, fmt, args);
+    Buf.resize(needed_sz);
+    ImFormatStringV(&Buf[write_off] - 1, (size_t)len+1, fmt, args_copy);
 }
 
 void ImGuiTextBuffer::append(const char* fmt, ...)
     const int tree_depth = (window->DC.TreeDepth - g.LogStartDepth);
     while (true)
     {
+        // Split the string. Each new line (after a '\n') is followed by spacing corresponding to the current depth of our log entry.
         const char* line_end = text_remaining;
         while (line_end < text_end)
             if (*line_end == '\n')
 
 void ImGui::BeginTooltip()
 {
-    ImGui::Begin("##Tooltip", NULL, ImVec2(0,0), 0.9f, ImGuiWindowFlags_NoTitleBar|ImGuiWindowFlags_NoMove|ImGuiWindowFlags_NoResize|ImGuiWindowFlags_NoSavedSettings|ImGuiWindowFlags_Tooltip);
+    ImGuiState& g = GImGui;
+    ImGuiWindowFlags window_flags = ImGuiWindowFlags_NoTitleBar|ImGuiWindowFlags_NoMove|ImGuiWindowFlags_NoResize|ImGuiWindowFlags_NoSavedSettings|ImGuiWindowFlags_AlwaysAutoResize|ImGuiWindowFlags_Tooltip;
+    ImGui::Begin("##Tooltip", NULL, ImVec2(0,0), g.Style.Colors[ImGuiCol_TooltipBg].w, window_flags);
 }
 
 void ImGui::EndTooltip()
     g.CurrentWindow = window;
 
     // Process SetNextWindow***() calls
+    bool window_pos_set_by_api = false;
     if (g.SetNextWindowPosCond)
     {
         const ImVec2 backup_cursor_pos = window->DC.CursorPos;
         ImGui::SetWindowPos(g.SetNextWindowPosVal, g.SetNextWindowPosCond);
         window->DC.CursorPos = backup_cursor_pos;
+        window_pos_set_by_api = true;
         g.SetNextWindowPosCond = 0;
     }
     if (g.SetNextWindowSizeCond)
 
         // New windows appears in front
         if (window->LastFrameDrawn < current_frame - 1)
-        {
             FocusWindow(window);
-            if ((window->Flags & ImGuiWindowFlags_Tooltip) != 0)
-            {
-                // Hide for 1 frame while resizing
-                window->AutoFitFrames = 2;
-                window->AutoFitOnlyGrows = false;
-                window->Visible = false;
-            }
-        }
 
         window->LastFrameDrawn = current_frame;
         window->ClipRectStack.resize(0);
             }
         }
 
-        // Tooltips always follow mouse
-        if ((window->Flags & ImGuiWindowFlags_Tooltip) != 0)
+        // Tooltips always follows mouse
+        if (!window_pos_set_by_api && (window->Flags & ImGuiWindowFlags_Tooltip) != 0)
         {
             window->PosFloat = g.IO.MousePos + ImVec2(32,16) - style.FramePadding*2;
         }
 
         // Clamp into view
-        if (!(window->Flags & ImGuiWindowFlags_ChildWindow))
+        if (!(window->Flags & ImGuiWindowFlags_ChildWindow) && !(window->Flags & ImGuiWindowFlags_Tooltip))
         {
-            const ImVec2 pad = ImVec2(window->FontSize()*2.0f, window->FontSize()*2.0f);
+            const ImVec2 pad = ImVec2(window->FontSize()*2.0f, window->FontSize()*2.0f); // FIXME: Parametrize of clarify this behavior.
             if (g.IO.DisplaySize.x > 0.0f && g.IO.DisplaySize.y > 0.0f) // Ignore zero-sized display explicitly to avoid losing positions if a window manager reports zero-sized window when initializing or minimizing.
             {
                 window->PosFloat = ImMax(window->PosFloat + window->Size, pad) - window->Size;
                 window->PosFloat = ImMin(window->PosFloat, ImVec2(g.IO.DisplaySize.x, g.IO.DisplaySize.y) - pad);
             }
-            window->SizeFull = ImMax(window->SizeFull, pad);
+            window->SizeFull = ImMax(window->SizeFull, style.WindowMinSize);
         }
         window->Pos = ImVec2((float)(int)window->PosFloat.x, (float)(int)window->PosFloat.y);
 
-        // Default item width
+        // Default item width. Make it proportional to window size if window manually resizes
         if (window->Size.x > 0.0f && !(window->Flags & ImGuiWindowFlags_Tooltip) && !(window->Flags & ImGuiWindowFlags_AlwaysAutoResize))
             window->ItemWidthDefault = (float)(int)(window->Size.x * 0.65f);
         else
             ImU32 resize_col = 0;
             if ((window->Flags & ImGuiWindowFlags_Tooltip) != 0)
             {
-                // Tooltip always resize
-                if (window->AutoFitFrames > 0)
-                {
-                    window->SizeFull = window->SizeContentsFit + style.WindowPadding - ImVec2(0.0f, style.ItemSpacing.y);
-                }
+                // Tooltip always resize. We keep the spacing symmetric on both axises for aesthetic purpose.
+                const ImVec2 size_auto_fit = window->SizeContentsFit + style.WindowPadding - ImVec2(0.0f, style.ItemSpacing.y);
+                window->SizeFull = size_auto_fit;
             }
             else
             {
                 }
                 else if (!(window->Flags & ImGuiWindowFlags_NoResize))
                 {
-                    // Resize grip
+                    // Manual resize grip
                     const ImGuiAabb resize_aabb(window->Aabb().GetBR()-ImVec2(18,18), window->Aabb().GetBR());
                     const ImGuiID resize_id = window->GetID("##RESIZE");
                     bool hovered, held;
 
                     if (g.HoveredWindow == window && held && g.IO.MouseDoubleClicked[0])
                     {
-                        // Manual auto-fit
+                        // Manual auto-fit when double-clicking
                         window->SizeFull = size_auto_fit;
                         window->Size = window->SizeFull;
                         if (!(window->Flags & ImGuiWindowFlags_NoSavedSettings))
                     }
                 }
 
-                // Update aabb immediately so that the rendering below isn't one frame late
+                // Update aabb immediately so that rendering right below us isn't one frame late
                 title_bar_aabb = window->TitleBarAabb();
             }
 
             {
                 if ((window->Flags & ImGuiWindowFlags_ComboBox) != 0)
                     window->DrawList->AddRectFilled(window->Pos, window->Pos+window->Size, window->Color(ImGuiCol_ComboBg, fill_alpha), 0);
+                else if ((window->Flags & ImGuiWindowFlags_Tooltip) != 0)
+                    window->DrawList->AddRectFilled(window->Pos, window->Pos+window->Size, window->Color(ImGuiCol_TooltipBg, fill_alpha), style.WindowRounding);
                 else
                     window->DrawList->AddRectFilled(window->Pos, window->Pos+window->Size, window->Color(ImGuiCol_WindowBg, fill_alpha), style.WindowRounding);
             }
     {
     case ImGuiStyleVar_Alpha: return &g.Style.Alpha;
     case ImGuiStyleVar_WindowRounding: return &g.Style.WindowRounding;
+    case ImGuiStyleVar_FrameRounding: return &g.Style.FrameRounding;
     case ImGuiStyleVar_TreeNodeSpacing: return &g.Style.TreeNodeSpacing;
     }
     return NULL;
     case ImGuiCol_ScrollbarGrabHovered: return "ScrollbarGrabHovered";
     case ImGuiCol_ScrollbarGrabActive: return "ScrollbarGrabActive";
     case ImGuiCol_ComboBg: return "ComboBg";
-    case ImGuiCol_CheckHovered: return "CheckBgHovered";
-    case ImGuiCol_CheckActive: return "CheckBgActive";
-    case ImGuiCol_CheckMark: return "CheckSelected";
+    case ImGuiCol_CheckHovered: return "CheckHovered";
+    case ImGuiCol_CheckActive: return "CheckActive";
+    case ImGuiCol_CheckMark: return "CheckMark";
     case ImGuiCol_SliderGrab: return "SliderGrab";
     case ImGuiCol_SliderGrabActive: return "SliderGrabActive";
     case ImGuiCol_Button: return "Button";
     window->FontWindowScale = scale;
 }
 
+// NB: internally we store CursorPos in absolute screen coordinates because it is more convenient.
+// Conversion happens as we pass the value to user, but it makes our naming convention dodgy. May want to rename 'DC.CursorPos'.
 ImVec2 ImGui::GetCursorPos()
 {
     ImGuiWindow* window = GetCurrentWindow();
     return window->DC.CursorPos;
 }
 
+void ImGui::SetCursorScreenPos(const ImVec2& screen_pos)
+{
+    ImGuiWindow* window = GetCurrentWindow();
+    window->DC.CursorPos = screen_pos;
+}
+
 void ImGui::SetScrollPosHere()
 {
     ImGuiWindow* window = GetCurrentWindow();
 
     // Render
     const ImU32 col = window->Color((hovered && held) ? ImGuiCol_ButtonActive : hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button);
-    RenderFrame(bb.Min, bb.Max, col);
+    RenderFrame(bb.Min, bb.Max, col, true, style.FrameRounding);
 
     if (size.x < text_size.x || size.y < text_size.y)
         PushClipRect(ImVec4(bb.Min.x+style.FramePadding.x, bb.Min.y+style.FramePadding.y, bb.Max.x, bb.Max.y-style.FramePadding.y));        // Allow extra to draw over the horizontal padding to make it visible that text doesn't fit
     if (display_frame)
     {
         // Framed type
-        RenderFrame(bb.Min, bb.Max, col, true);
+        RenderFrame(bb.Min, bb.Max, col, true, style.FrameRounding);
         RenderCollapseTriangle(bb.Min + style.FramePadding, opened, 1.0f, true);
         if (g.LogEnabled)
         {
     }
 
     ItemSize(bb);
-    RenderFrame(frame_bb.Min, frame_bb.Max, window->Color(ImGuiCol_FrameBg));
+    RenderFrame(frame_bb.Min, frame_bb.Max, window->Color(ImGuiCol_FrameBg), true, style.FrameRounding);
 
     // Process clicking on the slider
     if (g.ActiveId == id)
             scale_max = v_max;
     }
 
-    RenderFrame(frame_bb.Min, frame_bb.Max, window->Color(ImGuiCol_FrameBg));
+    RenderFrame(frame_bb.Min, frame_bb.Max, window->Color(ImGuiCol_FrameBg), true, style.FrameRounding);
 
     int res_w = ImMin((int)graph_size.x, values_count);
     if (plot_type == ImGuiPlotType_Lines)
     if (pressed)
         *v = !(*v);
 
-    RenderFrame(check_bb.Min, check_bb.Max, window->Color((held && hovered) ? ImGuiCol_CheckActive : hovered ? ImGuiCol_CheckHovered : ImGuiCol_FrameBg));
+    RenderFrame(check_bb.Min, check_bb.Max, window->Color((held && hovered) ? ImGuiCol_CheckActive : hovered ? ImGuiCol_CheckHovered : ImGuiCol_FrameBg), true, style.FrameRounding);
     if (*v)
     {
         const float check_sz = ImMin(check_bb.GetWidth(), check_bb.GetHeight());
         const float pad = check_sz < 8.0f ? 1.0f : check_sz < 13.0f ? 2.0f : 3.0f;
-        window->DrawList->AddRectFilled(check_bb.Min+ImVec2(pad,pad), check_bb.Max-ImVec2(pad,pad), window->Color(ImGuiCol_CheckMark));
+        window->DrawList->AddRectFilled(check_bb.Min+ImVec2(pad,pad), check_bb.Max-ImVec2(pad,pad), window->Color(ImGuiCol_CheckMark), style.FrameRounding);
     }
 
     if (g.LogEnabled)
         }
     }
     
-    RenderFrame(frame_bb.Min, frame_bb.Max, window->Color(ImGuiCol_FrameBg), true);
+    RenderFrame(frame_bb.Min, frame_bb.Max, window->Color(ImGuiCol_FrameBg), true, style.FrameRounding);
 
     const ImVec2 font_off_up = ImVec2(0.0f,window->FontSize()+1.0f);    // FIXME: those offsets are part of the style or font API
     const ImVec2 font_off_dn = ImVec2(0.0f,2.0f);
     const bool hovered = IsHovered(frame_bb, id);
 
     bool value_changed = false;
-    RenderFrame(frame_bb.Min, frame_bb.Max, window->Color(ImGuiCol_FrameBg));
-    RenderFrame(ImVec2(frame_bb.Max.x-arrow_size, frame_bb.Min.y), frame_bb.Max, window->Color(hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button));
+    RenderFrame(frame_bb.Min, frame_bb.Max, window->Color(ImGuiCol_FrameBg), true, style.FrameRounding);
+    RenderFrame(ImVec2(frame_bb.Max.x-arrow_size, frame_bb.Min.y), frame_bb.Max, window->Color(hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button), true, style.FrameRounding);	// FIXME-ROUNDING
     RenderCollapseTriangle(ImVec2(frame_bb.Max.x-arrow_size, frame_bb.Min.y) + style.FramePadding, true);
 
     if (*current_item >= 0 && *current_item < items_count)
         return false;
 
     const ImGuiStyle& style = g.Style;
+    const ImGuiID id = window->GetID("##colorbutton");
     const float square_size = window->FontSize();
     const ImGuiAabb bb(window->DC.CursorPos, window->DC.CursorPos + ImVec2(square_size + style.FramePadding.x*2, square_size + (small_height ? 0 : style.FramePadding.y*2)));
     ItemSize(bb);
     if (ClipAdvance(bb))
         return false;
 
-    const bool hovered = IsHovered(bb, 0);
-    const bool pressed = hovered && g.IO.MouseClicked[0];
-    RenderFrame(bb.Min, bb.Max, window->Color(col), outline_border);
+    bool hovered, held;
+    bool pressed = ButtonBehaviour(bb, id, &hovered, &held, true);
+    RenderFrame(bb.Min, bb.Max, window->Color(col), outline_border, style.FrameRounding);
 
     if (hovered)
     {
     const float square_sz = (window->FontSize() + style.FramePadding.x * 2.0f);
 
     ImGuiColorEditMode edit_mode = window->DC.ColorEditMode;
-    if (edit_mode == ImGuiColorEditMode_UserSelect)
+    if (edit_mode == ImGuiColorEditMode_UserSelect || edit_mode == ImGuiColorEditMode_UserSelectShowButton)
         edit_mode = g.ColorEditModeStorage.GetInt(id, 0) % 3;
 
     float fx = col[0];
     }
 
     ImGui::SameLine(0, (int)style.ItemInnerSpacing.x);
-    ImGui::ColorButton(col_display);
+    if (ImGui::ColorButton(col_display))
+    {
+        // Don't set local copy of 'edit_mode' right away!
+        g.ColorEditModeStorage.SetInt(id, (edit_mode + 1) % 3);
+    }
 
-    if (window->DC.ColorEditMode == ImGuiColorEditMode_UserSelect)
+    if (window->DC.ColorEditMode == ImGuiColorEditMode_UserSelectShowButton)
     {
         ImGui::SameLine(0, (int)style.ItemInnerSpacing.x);
         const char* button_titles[3] = { "RGB", "HSV", "HEX" };
         ImGui::SliderFloat2("WindowPadding", (float*)&style.WindowPadding, 0.0f, 20.0f, "%.0f");
         ImGui::SliderFloat("WindowRounding", &style.WindowRounding, 0.0f, 16.0f, "%.0f");
         ImGui::SliderFloat2("FramePadding", (float*)&style.FramePadding, 0.0f, 20.0f, "%.0f");
+        ImGui::SliderFloat("FrameRounding", &style.FrameRounding, 0.0f, 16.0f, "%.0f");
         ImGui::SliderFloat2("ItemSpacing", (float*)&style.ItemSpacing, 0.0f, 20.0f, "%.0f");
         ImGui::SliderFloat2("ItemInnerSpacing", (float*)&style.ItemInnerSpacing, 0.0f, 20.0f, "%.0f");
         ImGui::SliderFloat2("TouchExtraPadding", (float*)&style.TouchExtraPadding, 0.0f, 10.0f, "%.0f");
         ImGui::RadioButton("HSV", &edit_mode, ImGuiColorEditMode_HSV);
         ImGui::SameLine();
         ImGui::RadioButton("HEX", &edit_mode, ImGuiColorEditMode_HEX);
+        //ImGui::Text("Tip: Click on colored square to change edit mode.");
 
         static ImGuiTextFilter filter;
         filter.Draw("Filter colors", 200);
                 if (data->EventKey == ImGuiKey_UpArrow)
                 {
                     if (HistoryPos == -1)
-                        HistoryPos = History.size() - 1;
+                        HistoryPos = (int)(History.size() - 1);
                     else if (HistoryPos > 0)
                         HistoryPos--;
                 }
                 {
                     ImFormatString(data->Buf, data->BufSize, "%s", (HistoryPos >= 0) ? History[HistoryPos] : "");
                     data->BufDirty = true;
-                    data->CursorPos = data->SelectionStart = data->SelectionEnd = strlen(data->Buf);
+                    data->CursorPos = data->SelectionStart = data->SelectionEnd = (int)strlen(data->Buf);
                 }
             }
         }

src/deps/imgui/imgui.h

-// ImGui library v1.20
+// ImGui library v1.21 wip
 // See .cpp file for commentary.
 // See ImGui::ShowTestWindow() for sample code.
 // Read 'Programmer guide' in .cpp for notes on how to setup ImGui in your codebase.
     IMGUI_API void          SetCursorPos(const ImVec2& pos);                                    // "
     IMGUI_API void          SetCursorPosX(float x);                                             // "
     IMGUI_API void          SetCursorPosY(float y);                                             // "
-    IMGUI_API ImVec2        GetCursorScreenPos();                                               // cursor position in screen space
+    IMGUI_API ImVec2        GetCursorScreenPos();                                               // cursor position in absolute screen coordinates (0..io.DisplaySize)
+    IMGUI_API void          SetCursorScreenPos(const ImVec2& pos);                              // cursor position in absolute screen coordinates (0..io.DisplaySize)
     IMGUI_API void          AlignFirstTextHeightToWidgets();                                    // call once if the first item on the line is a Text() item and you want to vertically lower it to match subsequent (bigger) widgets.
     IMGUI_API float         GetTextLineSpacing();
     IMGUI_API float         GetTextLineHeight();
     ImGuiStyleVar_WindowPadding,     // ImVec2
     ImGuiStyleVar_WindowRounding,    // float
     ImGuiStyleVar_FramePadding,      // ImVec2
+    ImGuiStyleVar_FrameRounding,     // float
     ImGuiStyleVar_ItemSpacing,       // ImVec2
     ImGuiStyleVar_ItemInnerSpacing,  // ImVec2
     ImGuiStyleVar_TreeNodeSpacing,   // float
 // Enumeration for ColorEditMode()
 enum ImGuiColorEditMode_
 {
-    ImGuiColorEditMode_UserSelect = -1,
+    ImGuiColorEditMode_UserSelect = -2,
+    ImGuiColorEditMode_UserSelectShowButton = -1,
     ImGuiColorEditMode_RGB = 0,
     ImGuiColorEditMode_HSV = 1,
     ImGuiColorEditMode_HEX = 2
     ImVec2      WindowMinSize;              // Minimum window size
     float       WindowRounding;             // Radius of window corners rounding. Set to 0.0f to have rectangular windows
     ImVec2      FramePadding;               // Padding within a framed rectangle (used by most widgets)
+    float       FrameRounding;              // Radius of frame corners rounding. Set to 0.0f to have rectangular frame (used by most widgets).
     ImVec2      ItemSpacing;                // Horizontal and vertical spacing between widgets/lines
     ImVec2      ItemInnerSpacing;           // Horizontal and vertical spacing between within elements of a composed widget (e.g. a slider and its label)
     ImVec2      TouchExtraPadding;          // Expand bounding box for touch-based system where touch position is not accurate enough (unnecessary for mouse inputs). Unfortunately we don't sort widgets so priority on overlap will always be given to the first widget running. So dont grow this too much!
     ImVector<char>      Buf;
 
     ImGuiTextBuffer()   { Buf.push_back(0); }
-    ~ImGuiTextBuffer()  { clear(); }
+    ~ImGuiTextBuffer()  { }
     const char*         begin() const { return &Buf.front(); }
     const char*         end() const { return &Buf.back(); }      // Buf is zero-terminated, so end() will point on the zero-terminator
     size_t              size() const { return Buf.size()-1; }
-    bool                empty() { return Buf.empty(); }
+    bool                empty() { return size() >= 1; }
     void                clear() { Buf.clear(); Buf.push_back(0); }
     IMGUI_API void      append(const char* fmt, ...);
     IMGUI_API void      appendv(const char* fmt, va_list args);

src/loader/LoaderTR2.cpp

 
     loadExternalSoundFile(f);
 
-    return 0; // TODO Not finished with implementation!
+    return 0;
 }
 
 // ---- Textures ----
         }
 
         uint16_t numSprites = file.readU16();
+        std::vector<RoomSprite*> roomSprites;
         for (unsigned int s = 0; s < numSprites; s++) {
             uint16_t vertex = file.readU16(); // Index into vertex list
             uint16_t sprite = file.readU16(); // Index into sprite list
 
-            // TODO store sprites somewhere
+            auto& v = vertices.at(vertex);
+            roomSprites.push_back(new RoomSprite(glm::vec3(v.x, v.y, v.z) + pos, sprite));
         }
 
         uint16_t numPortals = file.readU16();
         for (auto m : staticModels)
             room->addModel(m);
 
+        for (auto s : roomSprites)
+            room->addSprite(s);
+
         getWorld().addRoom(room);
 
         // Sanity check
 
 void LoaderTR2::loadSprites() {
     uint32_t numSpriteTextures = file.readU32();
-    std::vector<Sprite> sprites;
     for (unsigned int s = 0; s < numSpriteTextures; s++) {
         uint16_t tile = file.readU16();
         uint8_t x = file.readU8();
         int16_t rightSide = file.read16();
         int16_t bottomSide = file.read16();
 
-        sprites.emplace_back(tile, x, y, width, height);
+        Sprite* sp = new Sprite(tile, x, y, width, height);
+        getWorld().addSprite(sp);
     }
 
     uint32_t numSpriteSequences = file.readU32();
         assert(offset >= 0);
         assert((offset + (negativeLength * -1)) <= numSpriteTextures);
 
-        SpriteSequence* ss = new SpriteSequence(objectID);
-        for (int i = 0; i < (negativeLength * -1); i++) {
-            ss->add(sprites.at(offset + i));
-        }
-        getWorld().addSprite(ss);
+        SpriteSequence* ss = new SpriteSequence(objectID, offset, (negativeLength * -1));
+        getWorld().addSpriteSequence(ss);
     }
 
     if ((numSpriteTextures > 0) || (numSpriteSequences > 0))
     }
 
     uint32_t numMeshPointers = file.readU32();
-
     for (unsigned int i = 0; i < numMeshPointers; i++) {
         uint32_t meshPointer = file.readU32();
 

src/system/Shader.cpp

 void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& colors, glm::mat4 MVP,
                     unsigned int mode, Shader& shader) {
     assert(vertices.getSize() == colors.getSize());
+    if (mode == GL_TRIANGLES)
+        assert((vertices.getSize() % 3) == 0)
 
     shader.use();
     shader.loadUniform(0, MVP);
 void Shader::drawGL(ShaderBuffer& vertices, ShaderBuffer& colors, ShaderBuffer& indices,
                     glm::mat4 MVP, unsigned int mode, Shader& shader) {
     assert(vertices.getSize() == colors.getSize());
+    if (mode == GL_TRIANGLES)
+        assert((indices.getSize() % 3) == 0)
 
     shader.use();
     shader.loadUniform(0, MVP);