Moving to OpenGL 3.3 core. Depending on GLM. Removed old level reader, old math lib.

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20141215 ]
+    * Rewrote GL code for the Font implementations, ImGUI and the Main Menu
+
+    [ 20141214 ]
+    * Removed math, Matrix, Quaternion, Vec3, ViewVolume
+
+    [ 20141213 ]
+    * Completely removed old TombRaider level reader (so only unfinished TR2 compatibility now)
+    * Now creating OpenGL 3.3 Core Profile Context, so absolutely _nothing_ works right now!
+    * Now depending on GLM lib
+
     [ 20141207 ]
     * LoaderTR2 now also loads all important parts of the Room structures
     * Started work on new Mesh implementation used with LoaderTR2

README.md

 # OpenRaider
 
-[![Build Status](https://travis-ci.org/xythobuz/OpenRaider.svg?branch=master)](https://travis-ci.org/xythobuz/OpenRaider)
+[![Build Status](https://travis-ci.org/xythobuz/OpenRaider.svg?branch=loader)](https://travis-ci.org/xythobuz/OpenRaider)
+
+__This is the development branch of OpenRaider! Currently in the process of moving to OpenGL 3.3...__
 
 This is a fork of the [OpenRaider](http://openraider.sourceforge.net) Open Source implementation of the classic Tomb Raider Game Engine. The original project was abandoned in 2003.
 
 * C++11 compiler
 * cmake
 * OpenGL
+* GLM
 * zlib
 * SDL2
 * SDL2-TTF (optional, needed if you want to use TTF fonts)
 
 On Mac OS X 10.9 with [XCode](https://developer.apple.com/xcode/) and [MacPorts](http://www.macports.org) installed, the following should be enough to get all dependencies that are available as port:
 
-    sudo port install cmake zlib libsdl2 libsdl2_ttf
+    sudo port install cmake zlib glm libsdl2 libsdl2_ttf
 
 A similar command for the package manager of your favorite Linux Distribution should do the trick.
 
 * [GetGitRevisionDescription.cmake](https://github.com/rpavlik/cmake-modules/blob/master/GetGitRevisionDescription.cmake)
 * [GetGitRevisionDescription.cmake.in](https://github.com/rpavlik/cmake-modules/blob/master/GetGitRevisionDescription.cmake.in)
 * [FindFreeGLUT](https://github.com/PDAL/PDAL/blob/master/cmake/modules/FindFreeGLUT.cmake)
+* [FindGLM] (https://github.com/g-truc/glm/blob/master/util/FindGLM.cmake)
 
 See the respective files in `cmake` for their licensing.
 

cmake/FindGLM.cmake

+# FindGLM - attempts to locate the glm matrix/vector library.
+#
+# This module defines the following variables (on success):
+#   GLM_INCLUDE_DIRS  - where to find glm/glm.hpp
+#   GLM_FOUND         - if the library was successfully located
+#
+# It is trying a few standard installation locations, but can be customized
+# with the following variables:
+#   GLM_ROOT_DIR      - root directory of a glm installation
+#                       Headers are expected to be found in either:
+#                       <GLM_ROOT_DIR>/glm/glm.hpp           OR
+#                       <GLM_ROOT_DIR>/include/glm/glm.hpp
+#                       This variable can either be a cmake or environment
+#                       variable. Note however that changing the value
+#                       of the environment varible will NOT result in
+#                       re-running the header search and therefore NOT
+#                       adjust the variables set by this module.
+
+#=============================================================================
+# Copyright 2012 Carsten Neumann
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+# default search dirs
+SET(_glm_HEADER_SEARCH_DIRS
+    "/usr/include"
+    "/usr/local/include")
+
+# check environment variable
+SET(_glm_ENV_ROOT_DIR "$ENV{GLM_ROOT_DIR}")
+
+IF(NOT GLM_ROOT_DIR AND _glm_ENV_ROOT_DIR)
+    SET(GLM_ROOT_DIR "${_glm_ENV_ROOT_DIR}")
+ENDIF(NOT GLM_ROOT_DIR AND _glm_ENV_ROOT_DIR)
+
+# put user specified location at beginning of search
+IF(GLM_ROOT_DIR)
+    SET(_glm_HEADER_SEARCH_DIRS "${GLM_ROOT_DIR}"
+                                "${GLM_ROOT_DIR}/include"
+                                 ${_glm_HEADER_SEARCH_DIRS})
+ENDIF(GLM_ROOT_DIR)
+
+# locate header
+FIND_PATH(GLM_INCLUDE_DIR "glm/glm.hpp"
+    PATHS ${_glm_HEADER_SEARCH_DIRS})
+
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(GLM DEFAULT_MSG
+    GLM_INCLUDE_DIR)
+
+IF(GLM_FOUND)
+    SET(GLM_INCLUDE_DIRS "${GLM_INCLUDE_DIR}")
+
+    MESSAGE(STATUS "GLM_INCLUDE_DIR = ${GLM_INCLUDE_DIR}")
+ENDIF(GLM_FOUND)

cmake/travis_install_linux.sh

 #!/bin/bash
 
-sudo apt-get -qq -y install libsdl2-dev libsdl2-ttf-dev libalut-dev libpng12-dev zlib1g-dev cmake
+sudo apt-get -qq -y install libsdl2-dev libsdl2-ttf-dev libalut-dev libpng12-dev zlib1g-dev cmake glm
 
 if [ "$CC" = "gcc" ]; then sudo apt-get install gcc-4.8; fi
 if [ "$CXX" = "g++" ]; then sudo apt-get install g++-4.8; fi

cmake/travis_install_mac.sh

 #!/bin/bash
 
-brew install sdl2 sdl2_ttf freealut
+brew install sdl2 sdl2_ttf freealut glm
 

include/Camera.h

  * \file include/Camera.h
  * \brief Camera class
  *
- * \author Mongoose
  * \author xythobuz
  */
 
 #ifndef _CAMERA_H_
 #define _CAMERA_H_
 
-#include "math/Quaternion.h"
+#include "glm/vec3.hpp"
+#include "glm/mat4x4.hpp"
 
-/*!
- * \brief Commands for interactive camera control
- */
-enum camera_command {
-    CAMERA_ROTATE_RIGHT,
-    CAMERA_ROTATE_LEFT,
-    CAMERA_ROTATE_UP,
-    CAMERA_ROTATE_DOWN
-};
-
-/*!
- * \brief Camera class
- */
 class Camera {
   public:
-    /*!
-     * \brief Constructs an object of Camera
-     */
-    Camera();
-
-    /*!
-     * \brief Get the target currently looked at
-     * \param target where the target will be stored
-     */
-    void getTarget(float target[3]);
-
-    /*!
-     * \brief Get angle/yaw of camera
-     * \returns theta angle/yaw of camera
-     */
-    float getRadianYaw() { return mTheta; }
+    static void handleMouseMotion(int x, int y);
+    static glm::mat4 getViewMatrix();
 
-    /*!
-     * \brief Get angle/pitch of camera
-     * \returns phi angle/pitch of camera
-     */
-    float getRadianPitch() { return mTheta2; }
+    static float getRadianPitch() { return thetaX; }
+    static float getRadianYaw() { return thetaY; }
 
-    /*!
-     * \brief Set current position
-     * \param pos new position
-     */
-    void setPosition(float pos[3]);
+    static void setPosition(glm::vec3 p) { pos = p; }
+    static glm::vec3 getPosition() { return pos; }
 
-    void setSensitivityX(float sens) { mRotationDeltaX = sens; }
+    static void setSensitivityX(float sens) { rotationDeltaX = sens; }
+    static float getSensitivityX() { return rotationDeltaX; }
 
-    float getSensitivityX() { return mRotationDeltaX; }
-
-    void setSensitivityY(float sens) { mRotationDeltaY = sens; }
-
-    float getSensitivityY() { return mRotationDeltaY; }
-
-    /*!
-     * \brief Updates view target
-     */
-    void update();
-
-    /*!
-     * \brief Sends interactive command to camera
-     * \param cmd valid camera command
-     */
-    void command(enum camera_command cmd);
+    static void setSensitivityY(float sens) { rotationDeltaY = sens; }
+    static float getSensitivityY() { return rotationDeltaY; }
 
   private:
-
-    void rotate(float angle, float x, float y, float z);
-
-    Quaternion mQ;         //!< Quaternion for rotation
-    float mPos[4];         //!< Location in 3 space (aka eye)
-    float mTarget[4];      //!< Postition we're looking at
-    float mViewDistance;   //!< Distance from target
-    float mTheta;          //!< View angle Y
-    float mTheta2;         //!< View angle Z
-    float mRotationDeltaX; //!< Horizontal mouse sensitivity
-    float mRotationDeltaY; //!< Vertical mouse sensitivity
+    static glm::vec3 pos;
+    static float thetaX, thetaY;
+    static float rotationDeltaX, rotationDeltaY;
 };
 
-Camera& getCamera();
-
 #endif
+

include/Entity.h

 #define _ENTITY_H_
 
 #include "SkeletalModel.h"
-#include "TombRaider.h"
 
 class Entity {
   public:
 
     Entity(float p[3], float a[3], int id, long r, unsigned int model);
 
-    Entity(TombRaider& tr, unsigned int index, unsigned int i, unsigned int model);
-
-    bool operator<(Entity& o);
-    static bool compare(Entity* a, Entity* b);
     void display();
     void move(char movement);
     void print();

include/Game.h

 #include <vector>
 
 #include "Entity.h"
-#include "TombRaider.h"
 
 class Game {
   public:
     std::string levelName;
     bool mLoaded;
 
-    TombRaider mTombRaider;
-
     long mLara;
 };
 

include/Mesh.h

 #ifndef _MESH_H_
 #define _MESH_H_
 
-#include "math/Vec3.h"
+#include "glm/vec3.hpp"
 
 /*!
  * \brief OpenGL Mesh
   public:
 
     struct rectangle_t {
-        Vec3 a, b, c, d;
+        glm::vec3 a, b, c, d;
         uint16_t texture;
         float red, green, blue;
 
-        rectangle_t(Vec3 _a, Vec3 _b, Vec3 _c, Vec3 _d, uint16_t t,
+        rectangle_t(glm::vec3 _a, glm::vec3 _b, glm::vec3 _c, glm::vec3 _d, uint16_t t,
                     float re = 0.0f, float gr = 0.0f, float bl = 0.0f)
             : a(_a), b(_b), c(_c), d(_d), texture(t), red(re), green(gr), blue(bl) { }
     };
     void drawAlpha();
     void drawSolid();
 
-    void addTexturedRectangle(Vec3 a, Vec3 b, Vec3 c, Vec3 d, uint16_t textile);
-    void addTexturedTriangle(Vec3 a, Vec3 b, Vec3 c, uint16_t textile);
+    void addTexturedRectangle(glm::vec3 a, glm::vec3 b, glm::vec3 c, glm::vec3 d, uint16_t textile);
+    void addTexturedTriangle(glm::vec3 a, glm::vec3 b, glm::vec3 c, uint16_t textile);
 
-    void addColoredRectangle(Vec3 a, Vec3 b, Vec3 c, Vec3 d, float re, float gr, float bl);
-    void addColoredTriangle(Vec3 a, Vec3 b, Vec3 c, float re, float gr, float bl);
+    void addColoredRectangle(glm::vec3 a, glm::vec3 b, glm::vec3 c, glm::vec3 d, float re, float gr,
+                             float bl);
+    void addColoredTriangle(glm::vec3 a, glm::vec3 b, glm::vec3 c, float re, float gr, float bl);
 
-    void addNormal(Vec3 n);
+    void addNormal(glm::vec3 n);
 
     std::vector<rectangle_t> texturedRectangles;
     std::vector<rectangle_t> coloredRectangles;
     std::vector<rectangle_t> texturedTriangles;
     std::vector<rectangle_t> coloredTriangles;
-    std::vector<Vec3> normals;
+    std::vector<glm::vec3> normals;
 
 
     // Old API

include/Render.h

 #ifndef _RENDER_H_
 #define _RENDER_H_
 
-#include <vector>
+#include "glm/vec4.hpp"
 
-#include "Room.h"
 #include "TextureManager.h"
-#include "ViewVolume.h"
 
-/*!
- * \brief OpenRaider Renderer class
- */
+enum class RenderMode {
+    Disabled,
+    LoadScreen,
+    Solid,
+    Wireframe,
+    Texture
+};
+
 class Render {
   public:
+    static RenderMode getMode();
+    static void setMode(RenderMode m);
 
-    typedef enum {
-        modeDisabled,
-        modeLoadScreen,
-        modeVertexLight,
-        modeSolid,
-        modeWireframe,
-        modeTexture
-    } RenderMode;
-
-    typedef enum {
-        fRoomAlpha              = (1 << 0),
-        fEntityModels           = (1 << 1),
-        fFog                    = (1 << 2),
-        fGL_Lights              = (1 << 3),
-        fRenderPonytail         = (1 << 4),
-        fAnimateAllModels       = (1 << 5),
-        // fMultiTexture           = (1 << 6), //! \todo Whats up with Multitexture stuff? Where is it needed?
-    } RenderFlags;
-
-    /*!
-     * \brief Constructs an object of Render
-     */
-    Render();
-
-    /*!
-     * \brief Deconstructs an object of Render
-     */
-    ~Render();
-
-    /*!
-     * \brief Makes a screenshot, writes to disk
-     * \param filenameBase basename of file to be written
-     */
-    void screenShot(const char* filenameBase);
-
-    /*!
-     * \brief Gets current rendering mode
-     * \returns current RenderMode
-     * \fixme Don't return enum as int?!
-     */
-    int getMode();
-
-    /*!
-     * Removes current world/entity/etc geometry
-     */
-    void ClearWorld();
-
-    /*!
-     * \brief Clears bitflags, changes state of renderer in some way
-     * \param flags RenderFlags to clear (ORed)
-     * \fixme use enum not integer as parameter?!
-     */
-    void clearFlags(unsigned int flags);
-
-    /*!
-     * \brief Sets bitflags, changes state of renderer in some way
-     * \param flags RenderFlags to set (ORed)
-     * \fixme use enum not integer as parameter?!
-     */
-    void setFlags(unsigned int flags);
-
-    void setMode(int n);
-
-    /*!
-     * \brief Renders a single game frame
-     */
-    void display();
-
-    void setSkyMesh(int index, bool rot);
-
-    unsigned int getFlags();
-
-    /*!
-     * \brief Check if a point is in the View Volume
-     * \param x X coordinate
-     * \param y Y coordinate
-     * \param z Z coordinate
-     * \returns true if point is visible
-     */
-    bool isVisible(float x, float y, float z);
-
-    /*!
-     * \brief Check if a sphere is in the View Volume
-     * \param x X coordinate of center of sphere
-     * \param y Y coordinate of center of sphere
-     * \param z Z coordinate of center of sphere
-     * \param radius radius of sphere
-     * \returns true if sphere is visible
-     */
-    bool isVisible(float x, float y, float z, float radius);
+    static void display();
 
-    bool isVisible(BoundingBox& box);
+    static void screenShot(const char* filenameBase);
 
-    float getDistToSphereFromNear(float x, float y, float z, float radius);
-
-    void debugDisplayTexture(int texture = -1,
-                             TextureManager::TextureStorage s = TextureManager::TextureStorage::GAME,
-                             float x = 0.0f, float y = 0.0f, float w = 256.0f, float h = 256.0f);
-
-    void debugDisplayTextile(int texture = -1,
-                             float x = 0.0f, float y = 0.0f, float w = 64.0f, float h = 64.0f);
-
-    void debugDisplaySprite(int sprite = -1, int offset = 0,
-                            float x = 0.0f, float y = 0.0f, float w = 128.0f, float h = 128.0f);
+    static void drawTexture(float x, float y, float w, float h, glm::vec4 color,
+                            unsigned int texture, TextureManager::TextureStorage s);
 
   private:
-
-    void drawTexture(float x, float y, float w, float h,
-                     unsigned int texture, TextureManager::TextureStorage s);
-
-    void drawTextile(float x, float y, float w, float h, unsigned int textile);
-
-    void drawSprite(float x, float y, float w, float h, unsigned int sprite, unsigned int offset);
-
-    static void lightRoom(Room& room);
-
-    void drawLoadScreen();
-
-    /*!
-     * \brief Build a visible room list starting at index
-     * \param index valid room index where to start the list
-     */
-    void newRoomRenderList(int index);
-
-    /*!
-     * \brief Build a visible room list starting from room and
-     * only considers its linked rooms and their linked rooms.
-     * \param room First room in list
-     */
-    void buildRoomRenderList(Room& room);
-
-    /*!
-     * \brief Renders Sky domes/boxes/etc by scaling factor.
-     *
-     * Texture must be initialized.
-     * \param scale correct scale for map size
-     */
-    void drawSkyMesh(float scale);
-
-    /*!
-     * \brief Updates View Volume. Call once per render frame.
-     */
-    void updateViewVolume();
-
-    std::vector<Room*> mRoomRenderList;
-
-    ViewVolume mViewVolume; //!< View Volume for frustum culling
-
-    unsigned int mFlags;                  //!< Rendering flags
-    unsigned int mMode;                   //!< Rendering mode
-    int mLock;
-    int mSkyMesh;                         //!< Skymesh model id
-    bool mSkyMeshRotation;                //!< Should Skymesh be rotated?
-
-    int debugTexture, debugTextile, debugSprite, debugSpriteOffset;
-    TextureManager::TextureStorage debugTextureStorage;
-    float debugX, debugY, debugW, debugH;
+    static RenderMode mode;
 };
 
-Render& getRender();
-
 #endif
+

include/Room.h

 #include <vector>
 #include "Mesh.h"
 #include "Sprite.h"
-#include "TombRaider.h"
 #include "RoomData.h"
 
 typedef enum {
 
 class Room {
   public:
-    Room(TombRaider& tr, unsigned int index);
-
     Room(float p[3] = nullptr, unsigned int f = 0, unsigned int x = 0, unsigned int z = 0);
     ~Room();
 
     void addSprite(Sprite* s);
 
   private:
-    void sortModels();
-
     unsigned int flags;
     unsigned int numXSectors;
     unsigned int numZSectors;

include/RoomData.h

 #ifndef _ROOM_DATA_H_
 #define _ROOM_DATA_H_
 
+#include "glm/vec3.hpp"
+
 #include <vector>
 #include <memory>
-#include "math/Matrix.h"
-#include "TombRaider.h"
 
 class BoundingBox {
   public:
         typeDirectional = 3  //!< Directional light
     } LightType;
 
-    Light(TombRaider& tr, unsigned int room, unsigned int index);
-
     void getPos(float p[4]);
     void getDir(float d[3]);
     float getAtt();
 
 class StaticModel {
   public:
-    StaticModel(TombRaider& tr, unsigned int room, unsigned int i);
     void display();
 
-    // Compares distance to ViewVolume for depth sorting
-    bool operator<(const StaticModel& other);
-    static bool compare(StaticModel* a, StaticModel* b);
-
   private:
     int index;
     float yaw;
 
 class Portal {
   public:
-    Portal(float vert[4][3], float norm[3], int adj);
-    Portal(TombRaider& tr, unsigned int room, unsigned int index, Matrix& transform);
+    Portal(glm::vec3 vert[4], float norm[3], int adj);
 
     void getVertices(float vert[4][3]);
     int getAdjoiningRoom();
 class Sector {
   public:
     Sector(float f, float c, bool w) : floor(f), ceiling(c), wall(w) { }
-    Sector(TombRaider& tr, unsigned int room, unsigned int index);
     float getFloor();
     float getCeiling();
     bool isWall();

include/SkeletalModel.h

 
 #include <vector>
 
-#include "TombRaider.h"
-
 class BoneTag {
   public:
     BoneTag(int m, float o[3], float r[3], char f);
-
-    BoneTag(TombRaider& tr, unsigned int index, unsigned int j, unsigned int* l,
-            unsigned int frame_offset);
     void display();
 
     void getOffset(float o[3]);
 class BoneFrame {
   public:
     BoneFrame(float p[3]);
-
-    BoneFrame(TombRaider& tr, unsigned int index, unsigned int frame_offset);
     ~BoneFrame();
 
     void getPosition(float p[3]);
 class AnimationFrame {
   public:
     AnimationFrame(char r);
-
-    AnimationFrame(TombRaider& tr, unsigned int index, int a, unsigned int* frame_offset,
-                   int frame_step);
     ~AnimationFrame();
 
     unsigned long size();
 class SkeletalModel {
   public:
     SkeletalModel(int i);
-
-    SkeletalModel(TombRaider& tr, unsigned int index, int objectId);
     ~SkeletalModel();
     void display(unsigned long aframe, unsigned long bframe);
 

include/Sprite.h

 #include <cstdint>
 
 #include "loader/Loader.h"
-#include "TombRaider.h"
 
 class Sprite {
   public:
     Sprite(uint16_t tile, uint8_t x, uint8_t y, uint16_t width, uint16_t height);
-
-    Sprite(TombRaider& tr, unsigned int room, unsigned int index);
-
-    Sprite(TombRaider& tr, unsigned int item, unsigned int sequence, unsigned int index) :
-        Sprite((tr.Sprite() + ((tr.SpriteSequence() + sequence)->offset) + index)->tile,
-               (tr.Sprite() + ((tr.SpriteSequence() + sequence)->offset) + index)->x,
-               (tr.Sprite() + ((tr.SpriteSequence() + sequence)->offset) + index)->y,
-               (tr.Sprite() + ((tr.SpriteSequence() + sequence)->offset) + index)->width,
-               (tr.Sprite() + ((tr.SpriteSequence() + sequence)->offset) + index)->height) { }
-
     void display();
     void display(float x, float y, float w, float h);
 
     SpriteSequence(int32_t objectID);
     void add(Sprite s);
 
-    SpriteSequence(TombRaider& tr, unsigned int item, unsigned int sequence);
-    ~SpriteSequence();
-
     unsigned long size();
     Sprite& get(unsigned long index);
 
   private:
     int32_t id;
     std::vector<Sprite> sprites;
-
-    std::vector<Sprite*> oldsprites;
 };
 
 #endif

include/StaticMesh.h

 #define _STATIC_MODEL_H_
 
 #include <vector>
-#include "TombRaider.h"
 
 class TexturedTriangle {
   public:
 class StaticMesh {
   public:
     StaticMesh(int id, int mesh);
-
-    StaticMesh(TombRaider& tr, unsigned int index);
     ~StaticMesh();
     void display();
     float getRadius();

include/TextureManager.h

 #include <cstdint>
 #include <vector>
 
-#include "math/Vec3.h"
-
 // These are loaded into TextureStorage::SYSTEM by initialize()!
 #define TEXTURE_WHITE 0
 #define TEXTURE_SPLASH 1
     ~TextureTile();
 
     void add(TextureTileVertex* t);
-    bool isTriangle();
-    void display(float x, float y, float w, float h, float z);
 
-    void displayTriangle(Vec3 a, Vec3 b, Vec3 c);
-    void displayRectangle(Vec3 a, Vec3 b, Vec3 c, Vec3 d);
+    void displayTriangle(float a[3], float b[3], float c[3]);
+    void displayRectangle(float a[3], float b[3], float c[3], float d[3]);
 
   private:
-    void displayTriangle(float x, float y, float w, float h, float z);
-    void displayRectangle(float x, float y, float w, float h, float z);
-
     uint16_t attribute;
     uint16_t texture;
     std::vector<TextureTileVertex*> vertices;
 class TextureManager {
   public:
 
+    enum class ColorMode {
+        RGB,
+        RGBA,
+        ARGB,
+        BGR,
+        BGRA
+    };
+
     enum class TextureStorage {
         GAME,
         SYSTEM
     ~TextureManager();
 
     int initialize();
+    int initializeSplash();
 
     void clear();
 
      * \brief Binds the texture for use in GL
      * \param n valid texture index
      * \param s Which TextureStorage should be accessed
+     * \param unit Which GL texture unit should be used
      */
-    void bindTextureId(unsigned int n, TextureStorage s = TextureStorage::GAME);
+    void bindTextureId(unsigned int n, TextureStorage s = TextureStorage::GAME, unsigned int unit = 0);
 
     /*!
      * \brief Loads Buffer as texture
      * \param filter if the texture should be mipmap filtered
      * \returns texture ID or < 0 on error
      */
-    int loadBufferSlot(unsigned char* image,
-                       unsigned int width, unsigned int height,
-                       ColorMode mode, unsigned int bpp,
+    int loadBufferSlot(unsigned char* image = nullptr,
+                       unsigned int width = 256, unsigned int height = 256,
+                       ColorMode mode = ColorMode::RGBA, unsigned int bpp = 32,
                        TextureStorage s = TextureStorage::GAME,
                        int slot = -1, bool filter = true);
 

include/TombRaider.h

-/*!
- * \file include/TombRaider.h
- * \brief Loads maps, meshes, textures...
- *
- * \todo WARNING: No endian routines as of yet
- * \author Mongoose
- */
-
-#ifndef _TOMBRAIDER_H_
-#define _TOMBRAIDER_H_
-
-#include <cstdint>
-#include <cstdio>
-
-#include "TombRaiderData.h"
-
-/*!
- * \brief Loads maps, meshes, textures...
- */
-class TombRaider {
-  public:
-
-    /*!
-     * \brief Constructs an object of TombRaider
-     */
-    TombRaider();
-
-    /*!
-     * \brief Deconstructs an object of TombRaider
-     */
-    ~TombRaider();
-
-    ////////////////////////////////////////
-    // Wash me -- not part of cleaned API //
-    ////////////////////////////////////////
-
-    int NumRooms();
-
-    int NumMoveables();
-
-    int NumTextures();
-
-    /*!
-     * \brief Get number of _special_ textures/images
-     * \returns number of special textures/images
-     */
-    int NumSpecialTextures();
-
-    int NumAnimations();
-
-    unsigned int NumFrames();
-
-    int NumStaticMeshes();
-
-    int NumSpriteSequences();
-
-    int NumItems();
-
-    tr2_version_type Engine();
-
-    unsigned short* Frame();
-
-    tr2_animation_t* Animation();
-
-    tr2_item_t* Item();
-
-    tr2_box_t* Box();
-
-    tr2_mesh_t* Mesh();
-
-    /*!
-     * \brief Get number of animations for a moveable
-     * \param moveable_index valid moveable id
-     * \returns number of animations for specified moveable
-     */
-    int getNumAnimsForMoveable(int moveable_index);
-
-    tr2_staticmesh_t* StaticMesh();
-
-    tr2_moveable_t* Moveable();
-
-    tr2_meshtree_t* MeshTree();
-
-    /*!
-     * \brief Get the sprites
-     * \returns the sprite array
-     */
-    tr2_sprite_texture_t* Sprite();
-
-    tr2_sprite_sequence_t* SpriteSequence();
-
-    /*!
-     * \brief Get copies of texture and it's bumpmap
-     * \param texture valid textile index
-     * \param image will be set to texture if found, or NULL
-     * \param bumpmap will be set to bumpmap if found, or NULL
-     */
-    void Texture(int texture, unsigned char** image, unsigned char** bumpmap);
-
-    //unsigned int* Palette16();
-    //unsigned char* Palette8();
-
-    tr2_room_t* Room();
-
-    /*!
-     * \brief Loads TombRaider 1-5 pak into memory
-     * and does some processing.
-     * \param filename points to valid TombRaider pak
-     * \returns 0 on success, < 0 on error
-     * \sa TombRaider::loadTR5()
-     */
-    int Load(const char* filename);
-
-    /*!
-     * \brief Compute rotation angles from moveable animation data
-     * \param frame moveable animation data
-     * \param frame_offset moveable animation data
-     * \param angle_offset moveable animation data
-     * \param x will be set to computed angle
-     * \param y will be set to computed angle
-     * \param z will be set to computed angle
-     */
-    void computeRotationAngles(unsigned short** frame,
-                               unsigned int* frame_offset,
-                               unsigned int* angle_offset,
-                               float* x, float* y, float* z);
-
-    /*!
-     * \brief Returns computed UV in u and v
-     * \param st object texture vert, its coordinates are added to the pixels and divided by 255.0
-     * \param u will contain calculated x value
-     * \param v will contain calculated y value
-     */
-    void computeUV(tr2_object_texture_vert_t* st, float* u, float* v);
-
-    void getColor(int index, float color[4]);
-
-    tr2_version_type getEngine();
-
-    /*!
-     * \brief Get the collision sphere for a mesh
-     * \param meshIndex mesh index
-     * \param center will be filled with center coordinates, not NULL
-     * \param radius will be filled with radius, not NULL
-     */
-    void getMeshCollisionInfo(unsigned int meshIndex,
-                              float center[3], float* radius);
-
-    /*!
-     * \brief Get SIGNED mesh count (TR encoded < 0 errors)
-     * \returns signed mesh count
-     */
-    int getMeshCount();
-
-    /*!
-     * \brief This method is made to let you fill arrays or
-     * create single faces. There may be an allocatin version that
-     * passes back arrays later.
-     * Returns Quads/Rects as 2 triangles,
-     * because returning quads would be too trivial :)
-     * \param meshIndex mesh index
-     * \param faceIndex face index
-     * \param index allocated RGBA
-     * \param color allocated RGBA
-     * \fixme This method interface may change later
-     */
-    void getMeshColoredRectangle(unsigned int meshIndex,
-                                 unsigned int faceIndex,
-                                 int index[6], float color[4]);
-
-    /*!
-     * \brief This method is made to let you fill arrays or
-     * create single faces. There may be an allocating version that
-     * passes back arrays later.
-     * \param meshIndex mesh index
-     * \param faceIndex face index
-     * \param index allocated RGBA
-     * \param color allocated RGBA
-     * \fixme This method interface may change later
-     */
-    void getMeshColoredTriangle(unsigned int meshIndex,
-                                unsigned int faceIndex,
-                                int index[3], float color[4]);
-
-    /*!
-     * \brief This method is made to let you fill arrays or
-     * create single faces. There may be an allocatin version that
-     * passes back arrays later.
-     * Returns Quads/Rects as 2 triangles,
-     * because returning quads would be too trivial :)
-     * \param meshIndex mesh index
-     * \param faceIndex face index
-     * \param index allocated
-     * \param st allocated
-     * \param texture allocated
-     * \param transparency allocated
-     * \fixme This method interface may change later
-     */
-    void getMeshTexturedRectangle(unsigned int meshIndex,
-                                  unsigned int faceIndex,
-                                  int index[6], float st[12], int* texture,
-                                  unsigned short* transparency);
-
-    /*!
-     * \brief This method is made to let you fill arrays or
-     * create single faces. There may be an allocatin version that
-     * passes back arrays later.
-     * \param meshIndex mesh index
-     * \param faceIndex face index
-     * \param index allocated
-     * \param st allocated
-     * \param texture allocated
-     * \param transparency allocated
-     * \fixme This method interface may change later
-     */
-    void getMeshTexturedTriangle(unsigned int meshIndex,
-                                 unsigned int faceIndex,
-                                 int index[3], float st[6], int* texture,
-                                 unsigned short* transparency);
-
-    /*!
-     * \brief Get face counts for a given mesh.
-     *
-     * \todo This method interface may change later...
-     * \param meshIndex mesh index
-     * \returns number of textured triangles in mesh
-     */
-    int getMeshTexturedTriangleCount(unsigned int meshIndex);
-
-    /*!
-     * \brief Get face counts for a given mesh.
-     * \param meshIndex mesh index
-     * \returns number of colored triangles in mesh
-     */
-    int getMeshColoredTriangleCount(unsigned int meshIndex);
-
-    /*!
-     * \brief Get face counts for a given mesh.
-     * \param meshIndex mesh index
-     * \returns number of textured rectangles in mesh
-     */
-    int getMeshTexturedRectangleCount(unsigned int meshIndex);
-
-    /*!
-     * \brief Get face counts for a given mesh.
-     * \returns number if colored rectangles in mesh
-     */
-    int getMeshColoredRectangleCount(unsigned int meshIndex);
-
-    /*!
-     * \brief Get vertex, normal and color arrays for a mesh
-     * \param meshIndex mesh index
-     * \param vertexCount will be set to length of vertex array
-     * \param verts will be set to allocated vertex array (XYX)
-     * \param normalCount will be set to length of normal array
-     * \param norms will be set to allocated normal array (IJK)
-     * \param colorCount will be set to length of color array
-     * \param colors will be set to allocated color array (I)
-     */
-    void getMeshVertexArrays(unsigned int meshIndex,
-                             unsigned int* vertexCount, float** verts,
-                             unsigned int* normalCount, float** norms,
-                             unsigned int* colorCount, float** colors);
-
-    /*!
-     * \brief Get a single collision box from room (unified)
-     * \param roomIndex room index
-     * \param index index of box in room
-     * \param xyzA will contain first corner of box
-     * \param xyzB will contain second corner of box
-     * \param xyzC will contain third corner of box
-     * \param xyzD will contain fourth corner of box
-     * \returns 0 on success, < 0 on error
-     */
-    int getRoomBox(unsigned int roomIndex, unsigned int index,
-                   float* xyzA, float* xyzB, float* xyzC, float* xyzD);
-
-    /*!
-     * \brief Get number of collision boxes in room (unified)
-     * \param roomIndex room index
-     * \returns number of collision boxes in room
-     */
-    unsigned int getRoomBoxCount(unsigned int roomIndex);
-
-    void getRoomInfo(unsigned int index,
-                     unsigned int* flags, float pos[3],
-                     float bboxMin[3], float bboxMax[3]);
-
-    /*!
-     * \brief Get a single light from a room (unified)
-     * \param roomIndex valid room index
-     * \param index valid light index in room
-     * \param pos allocated, will contain position
-     * \param color allocated, will contain color
-     * \param dir allocated, will contain direction
-     * \param attenuation will contain attenuation
-     * \param cutoffAngle will contain cutoff angle
-     * \param type will contain type
-     * \param flags will contain flags
-     * \returns 0 on success, < 0 on error
-     */
-    int getRoomLight(unsigned int roomIndex, unsigned int index,
-                     float pos[4], float color[4], float dir[3],
-                     float* attenuation, float* cutoffAngle,
-                     unsigned int* type, unsigned int* flags);
-
-    /*!
-     * \brief Get number of lights in room (unified)
-     * \param roomIndex room index
-     * \returns number of lights in room
-     */
-    unsigned int getRoomLightCount(unsigned int roomIndex);
-
-    /*!
-     * \brief Get a single model info from a room
-     * \param roomIndex valid room index
-     * \param index valid model index in room
-     * \param modelIndex will contain starting mesh
-     * \param pos will contain pos
-     * \param yaw will contain yaw angle
-     * \returns 0 on success, < 0 on error
-     */
-    int getRoomModel(unsigned int roomIndex, unsigned int index,
-                     int* modelIndex, float pos[3], float* yaw);
-
-    /*!
-     * \brief Get number of room models in room (unified)
-     * \param roomIndex room index
-     * \returns number of room models in room
-     */
-    unsigned int getRoomModelCount(unsigned int roomIndex);
-
-    /*!
-     * \brief Get a single portal from room (unified)
-     * \param roomIndex valid room index
-     * \param index valid portal index in room
-     * \param adjoiningRoom will contain adjoining room index
-     * \param normal allocated, will contain normal vector
-     * \param vertices allocated, will contain vertices
-     * \returns 0 on success, < 0 on error
-     */
-    int getRoomPortal(unsigned int roomIndex, unsigned int index,
-                      int* adjoiningRoom, float normal[3], float vertices[12]);
-
-    /*!
-     * \brief Get number of portals from room (unified)
-     * \param roomIndex room index
-     * \returns number of portals from room
-     */
-    unsigned int getRoomPortalCount(unsigned int roomIndex);
-
-    /*!
-     * \brief Get rectangle data with texCoords for non-matching
-     * vertex/uv for each vertex in TombRaider room (unified)
-     * \param roomIndex valid room index
-     * \param rectangleIndex rectangle index in room
-     * \param indices will contain indices
-     * \param texCoords will contain texCoords
-     * \param texture will contain texture
-     * \param flags will contain flags
-     */
-    void getRoomRectangle(unsigned int roomIndex, unsigned int rectangleIndex,
-                          unsigned int* indices, float* texCoords, int* texture,
-                          unsigned int* flags);
-
-    /*!
-     * \brief Get number of rectangles from room (unified)
-     * \param roomIndex room index
-     * \returns number of rectangles from room
-     */
-    unsigned int getRoomRectangleCount(unsigned int roomIndex);
-
-    /*!
-     * \brief Get a single sector from room (unified)
-     * \param roomIndex room index
-     * \param index sector index
-     * \param flags will contain flags
-     * \param ceiling will contain ceiling
-     * \param floor will contain floor
-     * \param floorDataIndex will contain floor data index
-     * \param boxIndex will contain boxIndex
-     * \param roomBelow will contain roomBelow
-     * \param roomAbove will contain roomAbove
-     * \return 0 on success, < 0 on error
-     */
-    int getRoomSector(unsigned int roomIndex, unsigned int index,
-                      unsigned int* flags, float* ceiling, float* floor,
-                      int* floorDataIndex, int* boxIndex,
-                      int* roomBelow, int* roomAbove);
-
-    /*!
-     * \brief Get number of sectors in room (unified)
-     * \param roomIndex room index
-     * \param zSectorsCount will contain width of sector list
-     * \param xSectorsCount will contain height of sector list
-     * \returns number of sectors in room
-     */
-    unsigned int getRoomSectorCount(unsigned int roomIndex,
-                                    unsigned int* zSectorsCount,
-                                    unsigned int* xSectorsCount);
-
-    void getRoomSprite(unsigned int roomIndex, unsigned int index,
-                       float scale, int* texture,
-                       float* pos, float* vertices, float* texcoords);
-
-    /*!
-     * \brief Get number of sprites in room (unified)
-     * \param roomIndex room index
-     * \returns number of sprites in room
-     */
-    unsigned int getRoomSpriteCount(unsigned int roomIndex);
-
-    /*!
-     * \brief Gets triangle data with texCoords for non-matching
-     * vertex/uv for each vertex in TombRaider room (unified)
-     * \param roomIndex room index
-     * \param triangleIndex triangle index
-     * \param indices will contain indices
-     * \param texCoords will contain texCoords
-     * \param texture will contain texture
-     * \param flags will contain flags
-     */
-    void getRoomTriangle(unsigned int roomIndex, unsigned int triangleIndex,
-                         unsigned int* indices, float* texCoords, int* texture,
-                         unsigned int* flags);
-
-    /*!
-     * \brief Gets triangle data with texCoords for non-matching
-     * vertex/uv for each vertex in TombRaider room.
-     *
-     * This is used with vertices, colors, etc. to do partial array
-     * rendering, since the texcoords will never match vertives
-     * (Tomb Raider is textile based).
-     * \param index room index
-     * \param textureOffset texture offset
-     * \param count will contain count
-     * \param indices will contain indices
-     * \param texCoords will contain texCoords
-     * \param textures will contain textures
-     * \param flags will contain flags
-     */
-    void getRoomTriangles(unsigned int index, int textureOffset,
-                          unsigned int* count, unsigned int** indices,
-                          float** texCoords, int** textures,
-                          unsigned int** flags);
-
-    /*!
-     * \brief Gets triangle data with duplicated vertex/color/normal
-     * data for each face vertex to match the textile based texcoords.
-     *
-     * This uses more memory, but lets you do direct array rendering
-     * with OpenGL, D3D, etc.
-     * \param roomIndex room index
-     * \param textureOffset texture offset
-     * \param count will contain count
-     * \param indices will contain indices
-     * \param vertices will contain vertices
-     * \param texCoords will contain texCoords
-     * \param colors will contain colors
-     * \param textures will contain textures
-     * \param flags will contain flags
-     */
-    void getRoomTriangles(unsigned int roomIndex, int textureOffset,
-                          unsigned int* count,
-                          unsigned int** indices, float** vertices,
-                          float** texCoords, float** colors,
-                          int** textures, unsigned int** flags);
-
-    /*!
-     * \brief Get number of triangles from room (unified)
-     * \param roomIndex room index
-     * \returns number of triangles from room
-     */
-    unsigned int getRoomTriangleCount(unsigned int roomIndex);
-
-    /*!
-     * \brief Gets vertex position and color
-     * \param roomIndex room index
-     * \param vertexIndex vertex index
-     * \param xyz will contain vertex position, has to be allocated
-     * \param rgba will contain vertex color, has to be allocated
-     */
-    void getRoomVertex(unsigned int roomIndex, unsigned int vertexIndex,
-                       float* xyz, float* rgba);
-
-    /*!
-     * \brief Get allocated vertex and color arrays and their element counts (unified)
-     * \param roomIndex valid room index
-     * \param vertexCount will contain vertex array length
-     * \param vertices will contain vertex array
-     * \param normalCount will contain normal array length
-     * \param normals will contain normal array
-     * \param colorCount will contain color array length
-     * \param colors will contain color array
-     */
-    void getRoomVertexArrays(unsigned int roomIndex,
-                             unsigned int* vertexCount, float** vertices,
-                             unsigned int* normalCount, float** normals,
-                             unsigned int* colorCount, float** colors);
-
-    /*!
-     * \brief Get number of lights in room (unified)
-     * \param roomIndex room index
-     * \returns number of lights in room
-     */
-    unsigned int getRoomVertexCount(unsigned int roomIndex);
-
-    /*!
-     * \brief Get sky mesh ID
-     * \returns moveable id of sky mesh or -1 if none
-     */
-    int getSkyModelId();
-
-    /*!
-     * \brief Get a copy of a sound sample and its byte size
-     * \param index sound sample index
-     * \param bytes will contain byte size of sound sample
-     * \param data will contain sound sample
-     */
-    void getSoundSample(unsigned int index,
-                        unsigned int* bytes, unsigned char** data);
-
-    /*!
-     * \brief Get number of loaded sound samples
-     * \returns number of sound samples loaded
-     */
-    unsigned int getSoundSamplesCount();
-
-    /*!
-     * \brief Check if a mesh is valid
-     * \param index mesh index (?)
-     * \returns true if mesh is valid
-     */
-    bool isMeshValid(int index);
-
-    /*!
-     * \brief Check if a room is valid (TRC support)
-     * \param index room index
-     * \returns true if room is valid
-     */
-    bool isRoomValid(int index);
-
-    /*!
-     * \brief Load an external sound pak for TR2 and TR3
-     * \param filename pak to load
-     * \returns < 0 on error
-     */
-    int loadSFX(const char* filename);
-
-    void reset();
-
-  private:
-
-    void extractMeshes(unsigned char* mesh_data,
-                       unsigned int num_mesh_pointers,
-                       unsigned int* mesh_pointers);
-
-    int Fread(void* buffer, size_t size, size_t count, FILE* f);
-
-    /*!
-     * \brief Get a copy of the sound samples
-     * \param bytes will contain size of sound samples
-     * \param data will contain sound samples themselves
-     */
-    void getRiffData(unsigned int* bytes, unsigned char** data);
-
-    /*!
-     * \brief Get a copy of a TR4 sound sample
-     * \param index sound sample index
-     * \param bytes will contain length of sound sample
-     * \param data will contain sound sample itself
-     */
-    void getRiffDataTR4(unsigned int index,
-                        unsigned int* bytes, unsigned char** data);
-
-    /*!
-     * \brief Get an array of offsets for a contiguous RIFF data stream in chunks.
-     *
-     * Offsets will be allocated with enough space to hold expected
-     * number of offsets. (Should be known number, otherwise not all RIFFs
-     * will be parsed.)
-     * \param riffData riff data
-     * \param riffDataBytes length of riff data
-     * \param offsets will contain offsets
-     * \param numOffsets known number
-     * \returns number of RIFFs found
-     */
-    int getRiffOffsets(unsigned char* riffData, unsigned int riffDataBytes,
-                       unsigned int** offsets, unsigned int numOffsets);
-
-    /*!
-     * \brief Makes a 32bit RGBA image from a textile.
-     *
-     * This handles all selection and conversion, including
-     * alpha layering flags, now.
-     * \param texture valid index into textile list
-     * \returns 32bit RGBA image or NULL on error
-     */
-    unsigned char* getTexTile(int texture);
-
-    /*!
-     * \brief Loads a TR5 pak into memory.
-     * \param f valid FILE
-     * \returns 0 on success, < 0 on error
-     */
-    int loadTR5(FILE* f);
-
-    static void print(const char* methodName, const char* s, ...) __attribute__((format(printf, 2, 3)));
-
-    void printDebug(const char* methodName, const char* s, ...) __attribute__((format(printf, 3, 4)));
-
-    bool mDebug;                           //!< Debug output toggle
-    unsigned int mPakVersion;              //!< TombRaider pak file header version
-    tr2_version_type mEngineVersion;       //!< TombRaider engine version
-    tr2_colour_t _palette8[256];           //!< 8-bit palette
-    unsigned int _palette16[256];          //!< 16-bit palette
-    unsigned int _num_textiles;            //!< Total number of texture tiles
-    unsigned short  _num_room_textures;    //!< Num textures only for room use?
-    unsigned short _num_misc_textures;     //!< Num of textures for misc use?
-    unsigned short _num_bump_map_textures; //!< Num of textures that are bump map, texture pairs
-    tr2_textile8_t* _textile8;             //!< 8-bit (palettised) textiles
-    tr2_textile16_t* _textile16;           //!< 16-bit (ARGB) textiles
-    tr2_textile32_t* _textile32;           //!< 32-bit (BGRA) textiles
-    unsigned int _num_tex_special;         //!< Special textures and bump maps count
-    unsigned char* _tex_special;           //!< Special textures and bump maps
-    unsigned int _unknown_t;               //!< 32-bit unknown (always 0 in real TR2 levels)
-    unsigned short _num_rooms;             //!< Number of rooms in this level
-    tr2_room_t* _rooms;                    //!< List of rooms (TR1,TR2,TR3,TR4)
-    tr5_room_t* mRoomsTR5;                 //!< Rooms ( TR5 / TRC ) Only
-    unsigned int _num_floor_data;          //!< Num of words of floor data this level
-    unsigned short* _floor_data;           //!< Floor data
-    int mMeshCount;                        //!< Number of meshes this level
-    tr2_mesh_t* mMeshes;                   //!< list of meshes
-    unsigned int _num_animations;          //!< number of animations this level
-    tr2_animation_t* _animations;          //!< list of animations
-    unsigned int _num_state_changes;       //!< number of structures(?) this level
-    tr2_state_change_t* _state_changes;    //!< list of structures
-    unsigned int _num_anim_dispatches;     //!< number of ranges(?) this level
-    tr2_anim_dispatch_t* _anim_dispatches; //!< list of ranges
-    unsigned int _num_anim_commands;       //!< number of Bone1s this level
-    tr2_anim_command_t* _anim_commands;    //!< list of Bone1s
-    unsigned int _num_mesh_trees;          //!< number of Bone2s this level
-    tr2_meshtree_t* _mesh_trees;           //!< list of Bone2s
-    unsigned int _num_frames;              //!< num of words of frame data this level
-    unsigned short* _frames;               //!< frame data
-    unsigned int _num_moveables;           //!< number of moveables this level
-    tr2_moveable_t* _moveables;            //!< list of moveables
-
-    uint32_t numMoveablesTR5;
-    tr5_moveable_t* moveablesTR5;
-
-    uint32_t numAnimationsTR5;
-    tr5_animation_t* animationsTR5;
-
-    uint32_t numObjectTexturesTR5;
-    tr5_object_texture_t* objectTexturesTR5;
-
-    uint32_t numCinematicFramesTR5;
-    tr5_cinematic_frame_t* cinematicFramesTR5;
-
-    uint32_t numFlyByCamerasTR5;
-    tr5_flyby_camera_t* flyByCamerasTR5;
-
-    unsigned int _num_static_meshes;        //!< number of static meshes this level
-    tr2_staticmesh_t* _static_meshes;       //!< static meshes
-    unsigned int _num_object_textures;      //!< number of object textures this level
-    tr2_object_texture_t* _object_textures; //!< list of object textures
-
-    unsigned int _num_sprite_textures;        //!< num of sprite textures this level
-    tr2_sprite_texture_t* _sprite_textures;   //!< list of sprite textures
-    unsigned int _num_sprite_sequences;       //!< num of sprite sequences this level
-    tr2_sprite_sequence_t* _sprite_sequences; //!< sprite sequence data
-    int  _num_cameras;                        //!< Number of Cameras
-    tr2_camera_t*  _cameras;                  //!< cameras
-    int  _num_sound_sources;                  //!< Number of Sounds
-    tr2_sound_source_t* _sound_sources;       //!< sounds
-    int  _num_boxes;                          //!< Number of Boxes
-    tr2_box_t* _boxes;                        /*!< boxes - looks like
-                                               * struct { unsigned short value[4]; }
-                                               * - value[0..2] might be a vector;
-                                               * value[3] seems to be index into
-                                               * Overlaps[] */
-    int  _num_overlaps;                       //!< Number of Overlaps
-    short*  _overlaps;                        /*!< Overlaps -
-                                               * looks like ushort; 0x8000 is flag
-                                               * of some sort appears to be an
-                                               * offset into Boxes[] and/or
-                                               * Boxes2[] */
-    short*  _zones;                           //!< Boxes2
-    int  _num_animated_textures;              //!< Number of AnimTextures
-    short*  _animated_textures;               //!< Animtextures
-    int  _num_items;                          //!< Number of Items
-    tr2_item_t* _items;                       //!< Items
-    unsigned char*  _light_map;               //!< Colour-light maps
-    unsigned int _num_cinematic_frames;       //!< Number of cut-scene frames
-    tr2_cinematic_frame_t* _cinematic_frames; //!< Cut-scene frames
-    short  _num_demo_data;                    //!< Number of Demo Data
-    unsigned char*  _demo_data;               //!< Demo data
-    float mRoomVertexLightingFactor;
-    float mTexelScale;
-
-    // Sound data
-    short*  mSoundMap;                   //!< Sound map
-    int  mNumSoundDetails;               //!< Number of SampleModifiers
-    tr2_sound_details_t* mSoundDetails;  //!< Sample modifiers
-    int  mNumSampleIndices;              //!< Number of Sample Indices
-    int*  mSampleIndices;                //!< Sample indices
-    unsigned int* mSampleIndicesTR5;
-    bool mRiffAlternateLoaded;           //!< Is a TR2,TR3 SFX loaded?
-    unsigned int* mRiffAlternateOffsets; //!< After parsing this will
-    //!< hold byte offsets for TR2,TR3
-    //!< RIFFs in the buffered SFX
-    int mRiffDataSz;                     //!< Byte size of a loaded SFX
-    unsigned char* mRiffData;            //!< SFX RIFF data in chunks
-    unsigned int mNumTR4Samples;
-    unsigned char** mTR4Samples;
-    unsigned int* mTR4SamplesSz;
-
-    // For packed Fread emu/wrapper
-    unsigned char*
-    mCompressedLevelData;     //!< Buffer used to emulate fread with uncompressed libz data
-    unsigned int mCompressedLevelDataOffset; //!< Offset into buffer
-    unsigned int mCompressedLevelSize;       //!< Size of buffer
-    tr_fread_mode_t mFreadMode;              //!< Fread mode file|buffer
-};
-
-#endif
-

include/ViewVolume.h

-/*!
- * \file include/ViewVolume.h
- * \brief Viewing Volume for culling use
- *
- * \author Mongoose
- */
-
-#ifndef _VIEWVOLUME_H_
-#define _VIEWVOLUME_H_
-
-#include "math/Matrix.h"
-
-/*!
- * \brief Viewing Volume for culling use
- */
-class ViewVolume {
-  public:
-
-    /*!
-     * \brief Sides of the view volume
-     */
-    enum ViewVolumeSide {
-        rightSide  = 0, //!< Right
-        leftSide   = 1, //!< Left
-        bottomSide = 2, //!< Bottom
-        topSide    = 3, //!< Top
-        farSide    = 4, //!< Back
-        nearSide   = 5  //!< Front
-    };
-
-    /*!
-     * \brief Planes of the view volume
-     */
-    enum ViewVolumePlane {
-        planeA = 0, //!< X value of normal
-        planeB = 1, //!< Y value of normal
-        planeC = 2, //!< Z value of normal
-        planeD = 3  //!< Distance to origin
-    };
-
-    /*!
-     * \brief Constructs an object of ViewVolume
-     */
-    ViewVolume();
-
-    /*!
-     * \brief Check if point is in view volume
-     * \param x X coordinate of point
-     * \param y Y coordinate of point
-     * \param z Z coordinate of point
-     * \returns true if point in view volume
-     */
-    bool isPointInFrustum(float x, float y, float z);
-
-    /*!
-     * \brief Check if bounding sphere is in view volume
-     * \param x X coordinate of a valid abstract sphere
-     * \param y Y coordinate of a valid abstract sphere
-     * \param z Z coordinate of a valid abstract sphere
-     * \param radius radius of a valid abstract sphere
-     * \returns true if abstract sphere in view volume
-     */
-    bool isSphereInFrustum(float x, float y, float z, float radius);
-
-    /*!
-     * \brief Check if bounding box is in view volume
-     * \param min minimum point of valid abstract bounding box
-     * \param max maximum point of valid abstract bounding box
-     * \returns true if abstract bounding box in view volume
-     */
-    bool isBboxInFrustum(float min[3], float max[3]);
-
-    /*!
-     * \brief Distance to Bounding sphere
-     * \param x X coordinate of a valid abstract sphere
-     * \param y Y coordinate of a valid abstract sphere
-     * \param z Z coordinate of a valid abstract sphere
-     * \param radius radius of a valid abstract sphere
-     * \returns distance to abstract sphere bounding volume
-     */
-    float getDistToSphereFromNear(float x, float y, float z, float radius);
-
-    /*!
-     * \brief Distance to Bounding box
-     * \param min minimum point of a valid abstract bounding box
-     * \param max maximum point of a valid abstract bounding box
-     * \returns distance to abstract box bounding volume
-     */
-    float getDistToBboxFromNear(const float min[3], const float max[3]);
-
-    /*!
-     * \brief Get a copy of the view volume
-     * \param frustum where frustum will be stored
-     */
-    void getFrustum(float frustum[6][4]);
-
-    /*!
-     * \brief Get a copy of a given plane in view volume
-     * \param p side
-     * \param plane wher plane will be stored
-     */
-    void getPlane(ViewVolumeSide p, float plane[4]);
-
-    /*!
-     * \brief Updates view volume for this frame.
-     * \param proj new projection matrix
-     * \param mdl new model matrix
-     */
-    void updateFrame(float proj[16], float mdl[16]);
-
-    /*!
-     * \brief Updates view volume for this frame.
-     *
-     * Model & Projection Matrices must be set.
-     */
-    void updateFrame();
-
-    /*!
-     * \brief Set this class' model matrix
-     * \param mdl new model matrix
-     */
-    void setModel(float mdl[16]);
-
-    /*!
-     * \brief Set this class' projection matrix
-     * \param proj new projection matrix
-     */
-    void setProjection(float proj[16]);
-
-  private:
-
-    /*!
-     * \brief Computes clipping matrix.
-     *
-     * Model & Projection matrices must be set!
-     */
-    void updateClip();
-
-    /*!
-     * \brief Computes planes of frustum.
-     *
-     * Model, Projection & Clip matrices must be set!
-     */
-    void updateFrustum();
-
-    Matrix mProjection;   //!< Projection matrix
-    Matrix mModel;        //!< Model matrix
-    Matrix mClip;         //!< Clipping matrix
-    float mFrustum[6][4]; //!< View volume
-};
-
-#endif

include/commands/CommandAnimate.h

-/*!
- * \file include/commands/CommandAnimate.h
- * \brief Animate Command interface
- *
- * \author xythobuz
- */
-
-#ifndef _COMMAND_ANIMATE_H_
-#define _COMMAND_ANIMATE_H_
-
-#include "commands/Command.h"
-
-class CommandAnimate : public Command {
-  public:
-    virtual std::string name();
-    virtual std::string brief();
-    virtual void printHelp();
-    virtual int execute(std::istream& args);
-};
-
-#endif
-

include/commands/CommandRender.h

     virtual int execute(std::istream& args);
 };
 
-class CommandRenderflag : public Command {
-  public:
-    virtual std::string name();
-    virtual std::string brief();
-    virtual void printHelp();
-    virtual int execute(std::istream& args);
-
-  private:
-    int stringToFlag(std::string flag);
-};
-
 #endif
 

include/global.h

 
 void renderFrame();
 
-// Supported pixelmap color formats
-enum ColorMode {
-    GREYSCALE,
-    RGB,
-    RGBA,
-    ARGB,
-    BGR,
-    BGRA
-};
-
 // Colors used where ever needed
 const unsigned char BLACK[]  = {   0,   0,   0, 255 };
 const unsigned char GREY[]   = { 128, 128, 128, 255 };
     unknownKey // Should always be at the end
 } KeyboardButton;
 
-// Visual C++ does not understand __attribute__
-#ifdef _MSC_VER
-#define __attribute__(x)
-#endif
-
-//! \todo Replace NULL usage with nullptr
-#ifndef NULL
-#define NULL nullptr
-#endif
-
 // Globally include OpenGL header
 #ifdef __APPLE__
-#include <OpenGL/gl.h>
+#include <OpenGL/gl3.h>
 #else
 #ifdef _WIN32
 #include <windows.h>
 #endif
-#include <GL/gl.h>
-#include <GL/glext.h>
+#include <GL/gl3.h>
 #endif
 
 // If available, use our own assert that prints the call stack

include/math/Matrix.h

-/*!
- * \file include/math/Matrix.h
- * \brief 3D Matrix
- *
- * \author Mongoose
- */
-
-#ifndef _MATH_MATRIX_H_
-#define _MATH_MATRIX_H_
-
-#include "math/math.h"
-#include "math/Quaternion.h"
-#include "math/Vec3.h"
-
-
-/*!
- * \brief 3D Matrix
- *
- * Multidim map for row order encoding
- *
- *     ///////////////////////////////////////////////
- *     // 0,0 - 0;   0,1 - 1;   0,2 - 2;   0,3 - 3  //
- *     // 1,0 - 4;   1,1 - 5;   1,2 - 6;   1,3 - 7  //
- *     // 2,0 - 8;   2,1 - 9;   2,2 - 10;  2,3 - 11 //
- *     // 3,0 - 12;  3,1 - 13;  3,2 - 14;  3,3 - 15 //
- *     ///////////////////////////////////////////////
- *
- * Multidim map for column order encoding
- *
- *     ///////////////////////////////////////////////
- *     // 0,0 - 0;   0,1 - 4;   0,2 - 8;   0,3 - 12 //
- *     // 1,0 - 1;   1,1 - 5;   1,2 - 9;   1,3 - 13 //
- *     // 2,0 - 2;   2,1 - 6;   2,2 - 10;  2,3 - 14 //
- *     // 3,0 - 3;   3,1 - 7;   3,2 - 11;  3,3 - 15 //
- *     ///////////////////////////////////////////////
- */
-class Matrix {
-  public:
-
-    /*!
-     * \brief Constructs an object of Matrix
-     */
-    Matrix();
-
-    /*!
-     * \brief Constructs an object of Matrix
-     * \param mat Matrix as data source
-     */
-    Matrix(float mat[16]);
-
-    /*!
-     * \brief Constructs an object of Matrix
-     * \param q Converts and assigns the Quaternion to the Matrix
-     */
-    Matrix(Quaternion& q);
-
-    /*!
-     * \brief Returns this matrix copy
-     * \param mat target
-     */
-    void getMatrix(float mat[16]);
-
-    /*!
-     * \brief Returns this matrix transposed
-     * \param mat target
-     */
-    void getTransposeMatrix(float mat[16]);
-
-    /*!
-     * \brief Returns this matrix inverted
-     * \param mat target
-     */
-    bool getInvert(float mat[16]);
-
-    /*!
-     * \brief Multiplies two matrices
-     * \param a first matrix
-     * \param b second matrix
-     * \returns resultant matrix
-     */
-    static Matrix multiply(const Matrix& a, const Matrix& b);
-
-    /*!
-     * \brief Multiplies v vector and this matrix
-     * \param v vector
-     * \param result where the result will be stored, may be same as v
-     */
-    void multiply4v(float v[4], float result[4]);
-
-    /*!
-     * \brief Multiplies v vector and this matrix
-     * \param v vector
-     * \param result where the result will be stored, may be same as v
-     */
-    void multiply3v(float v[3], float result[3]);
-
-    /*!
-     * \brief Prints matrix values to stdout
-     */
-    void print();
-
-    /*!
-     * \brief Is this matrix the identity matrix?
-     * \returns true if it is identity, false otherwise
-     */
-    bool isIdentity();
-
-    /*!
-     * \brief Multiplies a and this matrix
-     * \param a matrix to multiply with
-     * \returns resultant matrix
-     */
-    Matrix operator *(const Matrix& a);
-
-    /*!
-     * \brief Multiply vector by this matrix
-     * \param v Vector to multiply with
-     * \returns resultant vector (mult)
-     */
-    Vec3 operator *(Vec3 v);
-
-    /*!
-     * \brief Sets to identity matrix
-     */
-    void setIdentity();
-
-    /*!
-     * \brief S et the matrix
-     * \fixme dangerous, scary, boo!
-     * \param mat new matrix
-     */
-    void setMatrix(float mat[16]);
-
-    /*!
-     * \brief Rotate object in 3D space
-     * \param x x rotation in radians
-     * \param y y rotation in radians
-     * \param z z rotation in radians
-     */
-    void rotate(float x, float y, float z);
-
-    /*!
-     * \brief Rotate object in 3D space
-     * \param xyz rotation in radians
-     */
-    void rotate(const float* xyz);
-
-    /*!
-     * \brief Scale object in 3D space
-     * \param x x scaling
-     * \param y y scaling
-     * \param z z scaling
-     */
-    void scale(float x, float y, float z);
-
-    /*!
-     * \brief Scale object in 3D space
-     * \param xyz scaling factors
-     */
-    void scale(const float* xyz);
-
-    /*!
-     * \brief Translate (move) object in 3D space
-     * \param x x translation
-     * \param y y translation
-     * \param z z translation
-     */
-    void translate(float x, float y, float z);
-
-    /*!
-     * \brief Translate (move) object in 3D space
-     * \param xyz translations
-     */
-    void translate(const float* xyz);
-
-    /*!
-     * \brief Transpose this matrix
-     */
-    void transpose();
-
-  private:
-
-    /*!
-     * \brief Copys value from source to dest
-     * \param source source
-     * \param dest destination
-     */
-    static void copy(float source[16], float dest[16]);
-
-    /*!
-     * \brief Multiplies matrices a and b. Neither a or b is also the result.
-     * \param a first matrix
-     * \param b second matrix
-     * \param result wil be set to resultant matrix value
-     */
-    static void multiply(const float a[16], const float b[16], float result[16]);
-
-    float mMatrix[16];
-};
-
-#endif
-

include/math/Quaternion.h

-/*!
- * \file include/math/Quaternion.h
- * \brief Quaternion
- *
- * \author Mongoose
- */
-
-#ifndef _MATH_QUATERNION_H_
-#define _MATH_QUATERNION_H_
-
-#include "math/math.h"
-
-/*!
- * \brief Quaternion
- */
-class Quaternion {
-  public:
-
-    /*!
-     * \brief Constructs an object of Quaternion
-     */
-    Quaternion();
-
-    /*!
-     * \brief Constructs an object of Quaternion
-     * \param w W part of new Quaternion
-     * \param x X part of new Quaternion
-     * \param y Y part of new Quaternion
-     * \param z Z part of new Quaternion
-     */
-    Quaternion(float w, float x, float y, float z);
-
-    /*!
-     * \brief Constructs an object of Quaternion
-     * \param v contents of new Quaternion
-     */
-    Quaternion(float v[4]);
-
-    /*!
-     * \brief Get column order matrix equivalent of this quaternion
-     * \param m where matrix will be stored
-     */
-    void getMatrix(float m[16]);
-
-    /*!
-     * \brief Multiplies this quaternion.
-     *
-     * Use normalize() call for unit quaternion.
-     *
-     * \param q what to multiply this quaternion with
-     * \returns resultant quaternion
-     * \sa Quaternion::normalize()
-     */
-    Quaternion operator *(const Quaternion& q);
-
-    /*!
-     * \brief Divide from this quaternion
-     * \param q what to divide from this quaternion
-     * \returns resultant quaternion
-     */
-    Quaternion operator /(const Quaternion& q);
-
-    /*!
-     * \brief Add to this quaternion
-     * \param q what to add to this quaternion
-     * \returns resultant quaternion
-     */
-    Quaternion operator +(const Quaternion& q);
-
-    /*!
-     * \brief Subtract from this quaternion
-     * \param q what to subtract from this quaternion
-     * \returns resultant quaternion
-     */
-    Quaternion operator -(const Quaternion& q);
-
-    /*!
-     * \brief Compares q to this quaternion
-     * \param q what to compare this quaternion to
-     * \returns true if equal, false otherwise
-     */
-    bool operator ==(const Quaternion& q);
-
-    /*!
-     * \brief Conjugate this quaternion
-     * \returns Conjugate of this quaternion
-     */
-    Quaternion conjugate();
-
-    /*!
-     * \brief Scale this quaternion
-     * \param s scaling factor
-     * \returns Scaled result of this quaternion
-     */
-    Quaternion scale(float s);
-
-    /*!
-     * \brief Inverse this quaternion
-     * \returns inverse of this quaternion
-     */
-    Quaternion inverse();
-
-    /*!
-     * \brief Dot Product of quaternions
-     * \param a first argument to dot product
-     * \param b second argument to dot product
-     * \returns dot product between a and b quaternions
-     */
-    static float dot(Quaternion a, Quaternion b);
-
-    /*!
-     * \brief Magnitude of this quaternion
-     * \returns Magnitude of this quaternion
-     */
-    float magnitude();
-
-    /*!
-     * \brief Interpolates between a and b rotations.
-     *
-     * Using spherical linear interpolation:
-     * `I = (((B . A)^-1)^Time)A`
-     *
-     * \param a first argument for slerp
-     * \param b second argument for slerp
-     * \param time time argument for slerp
-     * \returns resultant quaternion
-     */
-    static Quaternion slerp(Quaternion a, Quaternion b, float time);
-
-    /*!
-     * \brief Sets this quaternion to identity
-     */
-    void setIdentity();
-
-    /*!
-     * \brief Sets this quaternion
-     * \param angle new angle
-     * \param x new X coordinate
-     * \param y new Y coordinate
-     * \param z new Z coordinate
-     */
-    void set(float angle, float x, float y, float z);
-
-    /*!
-     * \brief Normalize this quaternion
-     */
-    void normalize();
-
-    /*!
-     * \brief Set this quaternion
-     * \param q will be copied into this quaternion
-     */
-    void copy(Quaternion q);
-
-    /*!
-     * \brief Sets matrix equivalent of this quaternion
-     * \param m matrix in valid column order
-     */
-    void setByMatrix(float m[16]);
-
-  private:
-
-    /*!
-     * \brief Multiplies two quaternions
-     * \param a first argument to multiplication
-     * \param b second argument to multiplication
-     * \returns resultant quaternion
-     */
-    static Quaternion multiply(Quaternion a, Quaternion b);
-
-    /*!
-     * \brief Divides B from A quaternion
-     * \param a first argument to division
-     * \param b second argument to division
-     * \returns quotient quaternion
-     */
-    static Quaternion divide(Quaternion a, Quaternion b);
-
-    /*!
-     * \brief Adds A and B quaternions
-     * \param a first argument to addition
-     * \param b second argument to addition
-     * \returns resultant quaternion
-     */
-    static Quaternion add(Quaternion a, Quaternion b);
-
-    /*!
-     * \brief Subtracts B from A quaternion
-     * \param a first argument to subtraction
-     * \param b second argument to subtraction
-     * \returns resultant quaternion
-     */
-    static Quaternion subtract(Quaternion a, Quaternion b);
-
-    float mW; //!< Quaternion, W part
-    float mX; //!< Quaternion, X part
-    float mY; //!< Quaternion, Y part
-    float mZ; //!< Quaternion, Z part
-};
-
-#endif
-

include/math/Vec3.h

-/*!
- * \file include/math/Vec3.h
- * \brief 3D Math vector
- *
- * \author xythobuz
- * \author Mongoose
- */
-
-#ifndef _MATH_VEC3_H_
-#define _MATH_VEC3_H_
-
-#include "math/math.h"
-
-class Vec3 {
-  public:
-    Vec3(float _x = 0.0f, float _y = 0.0f, float _z = 0.0f);
-    Vec3(float v[3]);
-
-    float magnitude();
-    void normalize();
-    Vec3 unit();
-
-    Vec3 operator +(const Vec3& v);
-    Vec3 operator -(const Vec3& v);
-    Vec3 operator -();
-    Vec3 operator *(float s);
-    Vec3 operator /(float s);
-    float operator *(const Vec3& v);
-
-    Vec3& operator +=(const Vec3& v);
-    Vec3& operator -=(const Vec3& v);
-    Vec3& operator *=(float s);
-
-    bool operator ==(const Vec3& v);
-    bool operator !=(const Vec3& v);
-
-    float x, y, z;
-
-    // ----------------------------------------------------------
-
-    static float dot(const Vec3& u, const Vec3& v);
-    static Vec3 cross(const Vec3& u, const Vec3& v);
-};
-
-#endif
-

include/math/math.h

-/*!
- *
- * \file include/math/math.h
- * \brief Vector and Matrix math
- *
- * \author Mongoose
- * \author xythobuz
- */
-
-#ifndef _MATH_MATH_H
-#define _MATH_MATH_H
-
-#ifndef M_PI
-#define OR_PI (3.14159265358979323846f) //!< pi
-#else
-#define OR_PI ((float)M_PI) //!< pi
-#endif
-
-#define OR_RAD_TO_DEG(x) ((x) * (180.0f / OR_PI)) //!< Convert radians to degrees
-#define OR_DEG_TO_RAD(x) ((x) * (OR_PI / 180.0f)) //!< Convert degrees to radians
-
-/*!
- * \brief Compare two floats with an Epsilon.
- * \param a first float
- * \param b second float
- * \returns true if a and b are probably the same.
- */
-bool equalEpsilon(float a, float b);
-
-/*!
- * \brief Calculate Intersection of a line and a polygon
- * \param intersect Where the intersection is stored, if it exists
- * \param p1 First point of line segment
- * \param p2 Second point of line segment
- * \param polygon polygon vertex array (0 to 2 are used)
- * \returns 0 if there is no intersection
- */
-int intersectionLinePolygon(float intersect[3], float p1[3], float p2[3], float polygon[3][3]);
-
-/*!
- * \brief Calculate the length of a line segment / the distance between two points
- * \param a First point
- * \param b Second point
- * \returns distance/length
- */
-float distance(const float a[3], const float b[3]);
-
-/*!
- * \brief Calculates the midpoint between two points / of a line segment
- * \param a First point
- * \param b Second point
- * \param mid Midpoint will be stored here
- */
-void midpoint(const float a[3], const float b[3], float mid[3]);
-
-/*!
- * \brief Calculates a pseudo-random number
- * \param from Lower bound of resulting number
- * \param to Upper bound
- * \returns random number
- */
-float randomNum(float from, float to);
-
-#endif
-

include/system/FontTRLE.h

 #ifndef _FONT_TRLE_H_
 #define _FONT_TRLE_H_
 
+#include "glm/vec2.hpp"
+#include <vector>
+
 /*!
  * \brief Tomb Raider Level Editor Font loader
  */
   private:
     static void setDefaultOffsets();
     static void loadLPS(std::string f);
-    static void writeChar(unsigned int index, unsigned int xDraw, unsigned int yDraw,
-                          float scale, const unsigned char color[4]);
+    static void writeChar(unsigned int index, unsigned int xDraw, unsigned int yDraw, float scale,
+                          std::vector<glm::vec2>& vertices, std::vector<glm::vec2>& uvs);
 
     static bool mFontInit;
     static unsigned int mFontTexture;

include/system/Window.h

 #ifndef _WINDOW_H_
 #define _WINDOW_H_
 
-/*!
- * \brief Windowing interface
- */
+#include "glm/vec2.hpp"
+#include "glm/vec4.hpp"
+
+#include <vector>
+
+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;
+};
+
 class Window {
   public:
 
     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() { return mFullscreen; }
+    virtual bool getFullscreen();
 
     virtual void setMousegrab(bool grab) = 0;
-
-    virtual bool getMousegrab() { return mMousegrab; }
+    virtual bool getMousegrab();
 
     virtual int initialize() = 0;
 
     virtual void eventHandling() = 0;
 
     virtual void setTextInput(bool on) = 0;
-
-    virtual bool getTextInput() { return mTextInput; }
+    virtual bool getTextInput();
 
     virtual void swapBuffersGL() = 0;
 
-    virtual unsigned int getWidth() { return mWidth; }
-
-    virtual unsigned int getHeight() { return mHeight; }
-
-    virtual int initializeGL();
-
-    virtual void resizeGL();
+    static int initializeGL();
+    static void shutdownGL();
+    static void resizeGL();
 
-    virtual void glEnter2D();
-
-    virtual void glExit2D();
-
-    static void lookAt(float eyeX, float eyeY, float eyeZ,
-                       float lookAtX, float lookAtY, float lookAtZ,
-                       float upX, float upY, float upZ);
+    static void drawTextGL(std::vector<glm::vec2>& vertices, std::vector<glm::vec2>& uvs,
+                           glm::vec4 color, unsigned int texture);
 
   protected:
     bool mInit;
     bool mTextInput;
     unsigned int mWidth;
     unsigned int mHeight;
+
+  private:
+    static Shader textShader;
+    static const char* textShaderVertex;
+    static const char* textShaderFragment;
+
+    static Shader imguiShader;
+    static const char* imguiShaderVertex;
+    static const char* imguiShaderFragment;
+
+    static unsigned int vertexArrayID;
+
+    friend class UI;
 };
 
 Window& getWindow();

include/utils/pcx.h

 #ifndef _UTILS_PCX_H_
 #define _UTILS_PCX_H_
 
+#include "TextureManager.h"
+
 /*!
  * \brief Check if a file is a valid PCX image
  * \param filename path of file to read
  * \returns 0 on success
  */
 int pcxLoad(const char* filename, unsigned char** image,
-            unsigned int* width, unsigned int* height, ColorMode* mode, unsigned int* bpp);
+            unsigned int* width, unsigned int* height,
+            TextureManager::ColorMode* mode, unsigned int* bpp);
 
 #endif
 

include/utils/png.h

 #ifndef _UTILS_PNG_H_
 #define _UTILS_PNG_H_
 
+#include "TextureManager.h"
+
 /*!
  * \brief Check if a file is a valid PNG image
  * \param filename path of file to read
  * \returns 0 on success
  */
 int pngLoad(const char* filename, unsigned char** image,
-            unsigned int* width, unsigned int* height, ColorMode* mode, unsigned int* bpp);
+            unsigned int* width, unsigned int* height,
+            TextureManager::ColorMode* mode, unsigned int* bpp);
 
 /*!
  * \brief Create a PNG image file from an RGBA buffer
  * \returns 0 on success
  */
 int pngSave(const char* filename, unsigned char* image,
-            unsigned int width, unsigned int height, ColorMode mode, unsigned int bpp);
+            unsigned int width, unsigned int height,
+            TextureManager::ColorMode mode, unsigned int bpp);
 
 #endif
 

include/utils/tga.h

 /*!
  * \brief Load a TGA image from file
  * \param filename path to file
- * \param image Where the pixmap will be stored (or NULL)
+ * \param image Where the pixmap will be stored (or nullptr)
  * \param width where the width will be stored
  * \param height where the height will be stored
  * \param type where the type will be stored (tga_type_t)

src/CMakeLists.txt

     add_definitions (${PNG_DEFINITIONS})
 endif (PNG_FOUND)
 
+# Add GLM Library
+find_package (GLM REQUIRED)
+if (GLM_FOUND)
+    include_directories (SYSTEM  ${GLM_INCLUDE_DIRS})
+endif (GLM_FOUND)
+
 #################################################################
 
 # Set Source files
 set (SRCS ${SRCS} "Sprite.cpp")
 set (SRCS ${SRCS} "StaticMesh.cpp")
 set (SRCS ${SRCS} "TextureManager.cpp")
-set (SRCS ${SRCS} "TombRaider.cpp")
 set (SRCS ${SRCS} "UI.cpp")
-set (SRCS ${SRCS} "ViewVolume.cpp")
 set (SRCS ${SRCS} "World.cpp")
 
 # Select available Sound library
 add_subdirectory ("commands")
 add_subdirectory ("deps")
 add_subdirectory ("loader")
-add_subdirectory ("math")
 add_subdirectory ("system")
 add_subdirectory ("utils")
 
 add_library (OpenRaider_all OBJECT ${SRCS})
 add_executable (OpenRaider MACOSX_BUNDLE ${RESRCS}
     $<TARGET_OBJECTS:OpenRaider_all> $<TARGET_OBJECTS:OpenRaider_commands>
-    $<TARGET_OBJECTS:OpenRaider_deps> $<TARGET_OBJECTS:OpenRaider_math>
-    $<TARGET_OBJECTS:OpenRaider_utils> $<TARGET_OBJECTS:OpenRaider_loader>
-    $<TARGET_OBJECTS:OpenRaider_system>
+    $<TARGET_OBJECTS:OpenRaider_deps> $<TARGET_OBJECTS:OpenRaider_loader>
+    $<TARGET_OBJECTS:OpenRaider_utils> $<TARGET_OBJECTS:OpenRaider_system>
 )
 
 #################################################################

src/Camera.cpp

  * \author xythobuz
  */
 
+#include "glm/gtc/matrix_transform.hpp"
+
 #include "global.h"
-#include <cmath>
-#include "math/Matrix.h"
 #include "Camera.h"
 
-Camera::Camera() {
-    mViewDistance = 14.0f;
-    mRotationDeltaX = 1.0f;
-    mRotationDeltaY = 1.0f;
-    mTheta = 0.0f;
-    mTheta2 = 0.0f;
-
-    mPos[0] = 0.0f;
-    mPos[1] = 0.0f;
-    mPos[2] = 0.0f;
-
-    mTarget[0] = 0.0f;
-    mTarget[1] = 0.0f;
-    mTarget[2] = mViewDistance;
-
-    mQ.setIdentity();
-}
-
-void Camera::getTarget(float target[3]) {
-    target[0] = mTarget[0];
-    target[1] = mTarget[1];
-    target[2] = mTarget[2];
-}
-
-void Camera::setPosition(float pos[3]) {
-    mPos[0] = pos[0];
-    mPos[1] = pos[1];
-    mPos[2] = pos[2];
-}
-
-void Camera::update() {
-    mTarget[0] = (mViewDistance * std::sin(mTheta)) + mPos[0];
-    mTarget[1] = (mViewDistance * std::sin(mTheta2)) + mPos[1]; // + height_offset;
-    mTarget[2] = (mViewDistance * std::cos(mTheta)) + mPos[2];
-}
-
-void Camera::rotate(float angle, float x, float y, float z) {
-    Quaternion t, n;
-    float look[4] = { 0.0f, 0.0f, -1.0f, 1.0f };
-
-    t.set(angle, x, y, z);
-    n = mQ * t;
-    n.normalize();
-
-    Matrix matrix(n);
-    matrix.multiply4v(look, mTarget);
-
-    for (int i = 0; i < 3; ++i)
-        mTarget[i] += mPos[i];
-
-    mQ = n;
+glm::vec3 Camera::pos(0.0f, 0.0f, 0.0f);
+float Camera::thetaX = glm::pi<float>();
+float Camera::thetaY = 0.0f;
+float Camera::rotationDeltaX = 0.75f;
+float Camera::rotationDeltaY = 0.75f;
+
+void Camera::handleMouseMotion(int x, int y) {
+    while (x > 0) {
+        if (thetaX < (glm::pi<float>() / 2.0f)) {
+            thetaX += rotationDeltaX;
+        }
+        x--;
+    }
+    while (x < 0) {
+        if (thetaX > -(glm::pi<float>() / 2.0f)) {
+            thetaX -= rotationDeltaX;
+        }
+        x++;
+    }
+    while (y > 0) {
+        if (thetaY < (glm::pi<float>() / 2.0f)) {
+            thetaY += rotationDeltaY;
+        }
+        y--;
+    }
+    while (y < 0) {
+        if (thetaY > -(glm::pi<float>() / 2.0f)) {
+            thetaY -= rotationDeltaY;
+        }
+        y++;
+    }
 }
 
-void Camera::command(enum camera_command cmd) {
-    switch (cmd) {
-        case CAMERA_ROTATE_UP:
-            if (mTheta2 < (OR_PI / 2)) {
-                mTheta2 += mRotationDeltaY;
-                rotate(mTheta2, 1.0f, 0.0f, 0.0f);
-            }
-            break;
-
-        case CAMERA_ROTATE_DOWN:
-            if (mTheta2 > -(OR_PI / 2)) {
-                mTheta2 -= mRotationDeltaY;
-                rotate(mTheta2, 1.0f, 0.0f, 0.0f);
-            }
-            break;
-
-        case CAMERA_ROTATE_RIGHT:
-            mTheta += mRotationDeltaX;
-            rotate(mTheta, 0.0f, 1.0f, 0.0f);
-            break;
-
-        case CAMERA_ROTATE_LEFT:
-            mTheta -= mRotationDeltaX;
-            rotate(mTheta, 0.0f, 1.0f, 0.0f);
-            break;
-    }
+glm::mat4 Camera::getViewMatrix() {
+    glm::vec3 dir(
+        glm::cos(thetaY) * glm::sin(thetaX),
+        glm::sin(thetaY),
+        glm::cos(thetaY) * glm::cos(thetaX)
+    );
+    glm::vec3 right(
+        glm::sin(thetaX - glm::pi<float>() / 2.0f),
+        0.0f,
+        glm::cos(thetaX - glm::pi<float>() / 2.0f)
+    );
+    glm::vec3 up = glm::cross(right, dir);
+    return glm::lookAt(pos, pos + dir, up);
 }
 

src/Console.cpp

 }
 
 void Console::display() {
-    if (ImGui::Begin("Console", NULL, ImVec2(600, 400), -1.0f)) {
+    if (ImGui::Begin("Console", nullptr, ImVec2(600, 400), -1.0f)) {
         if (lastLogLength != getLog().size()) {
             lastLogLength = getLog().size();
             scrollToBottom = true;

src/Entity.cpp

  * \author xythobuz
  */
 
-#include <cmath>
+#include "glm/glm.hpp"
 
 #include "global.h"
 #include "Log.h"
-#include "Render.h"
 #include "World.h"
 #include "Entity.h"
 
-#include "games/TombRaider1.h"
-
 Entity::Entity(float p[3], float a[3], int id, long r, unsigned int model) {
     for (int i = 0; i < 3; i++) {
         pos[i] = p[i];
     state = 0;
 }
 
-Entity::Entity(TombRaider& tr, unsigned int index, unsigned int i, unsigned int model) {
-    tr2_moveable_t* moveable = tr.Moveable();
-    tr2_item_t* item = tr.Item();
-
-    pos[0] = item[i].x;
-    pos[1] = item[i].y;
-    pos[2] = item[i].z;
-    angles[0] = 0;
-    angles[1] = OR_DEG_TO_RAD(((item[i].angle >> 14) & 0x03) * 90.0f);
-    angles[2] = 0;
-    objectId = moveable[index].object_id;
-    moveType = MoveTypeWalk;
-    room = getWorld().getRoomByLocation(pos[0], pos[1], pos[2]);
-    skeletalModel = model;
-    boneFrame = 0;
-    animationFrame = 0;
-    idleAnimation = 0;
-    state = 0;
-}
-
-bool Entity::operator<(Entity& o) {
-    float distA = getRender().getDistToSphereFromNear(pos[0], pos[1], pos[2], 1.0f);
-    float distB = getRender().getDistToSphereFromNear(o.pos[0], o.pos[1], o.pos[2], 1.0f);
-    return (distA < distB);
-}
-
-bool Entity::compare(Entity* a, Entity* b) {
-    return (*b) < (*a);
-}
-
 void Entity::display() {
+    /*
     glPushMatrix();
     glTranslatef(pos[0], pos[1], pos[2]);
-    glRotatef(OR_RAD_TO_DEG(angles[1]), 0, 1, 0);
-    glRotatef(OR_RAD_TO_DEG(angles[0]), 1, 0, 0);
-    //glRotatef(OR_RAD_TO_DEG(angles[2]), 0, 0, 1);
+    glRotatef(glm::degrees(angles[1]), 0, 1, 0);
+    glRotatef(glm::degrees(angles[0]), 1, 0, 0);
+    //glRotatef(glm::degrees(angles[2]), 0, 0, 1);
     getWorld().getSkeletalModel(skeletalModel).display(animationFrame, boneFrame);
     glPopMatrix();
-
-    // Cycle frames
-    if (getRender().getFlags() & Render::fAnimateAllModels) {
-        if (boneFrame < (getModel().get(animationFrame).size() - 1))
-            boneFrame++;
-        else
-            boneFrame = 0;
-    }
+    */
 }
 
 void Entity::move(char movement) {
              << ")" << Log::endl
              << "  " << pos[0] << "x " << pos[1] << "y " << pos[2] << "z"
              << Log::endl
-             << "  " << OR_RAD_TO_DEG(angles[1]) << " Yaw" << Log::endl;
+             << "  " << glm::degrees(angles[1]) << " Yaw" << Log::endl;
 }
 
 SkeletalModel& Entity::getModel() {

src/Game.cpp

 #include "World.h"
 #include "utils/strings.h"
 
-#include "games/TombRaider1.h"
-
-#ifdef MULTITEXTURE
-std::map<int, int> gMapTex2Bump;
-#endif
-
 Game::Game() {
     mLoaded = false;
     mLara = -1;
 
 int Game::initialize() {
     // Enable Renderer
-    getRender().setMode(Render::modeLoadScreen);
+    Render::setMode(RenderMode::LoadScreen);
 
     return 0;
 }
 
 void Game::display() {
-    getRender().display();
+    Render::display();
 }
 
 void Game::destroy() {
     mLoaded = false;
     mLara = -1;
-    getRender().setMode(Render::modeLoadScreen);
+    Render::setMode(RenderMode::LoadScreen);
 
     getWorld().destroy();
-    getRender().ClearWorld();
     Sound::clear(); // Remove all previously loaded sounds
     SoundManager::clear();
     getTextureManager().clear();
 
 int Game::loadLevel(const char* level) {
     destroy();
-
     levelName = level;
-
     getLog() << "Loading " << levelName << Log::endl;
-
-    int error = 0;
     auto loader = Loader::createLoader(level);
     if (loader) {
         // First Loader test
         getLog() << "Trying to load using new loader..." << Log::endl;
-        error = loader->load(level);
+        int error = loader->load(level);
         if (error != 0) {
             getLog() << "Error while trying new loader (" << error << ")..." << Log::endl;
             destroy();
+            return -2;
         } else {
             SoundManager::prepareSources();
 
                 getLog() << "Can't find Lara entity in level?!" << Log::endl;
             } else {
                 mLoaded = true;
-                //getRender().setMode(Render::modeVertexLight);
+                //Render::setMode(RenderMode::Texture);
             }
 
             UI::setVisible(true);
+            return 0;
         }
+    } else {
+        getLog() << "No suitable loader for this level!" << Log::endl;
+        return -1;
     }
-
-    if ((!loader) || (error != 0)) {
-        getLog() << "Falling back to old level loader..." << Log::endl;
-        error = mTombRaider.Load(levelName.c_str());
-        if (error != 0)
-            return error;
-
-        // If required, load the external sound effect file MAIN.SFX into TombRaider
-        if ((mTombRaider.getEngine() == TR_VERSION_2) || (mTombRaider.getEngine() == TR_VERSION_3)) {
-            std::string tmp(levelName);
-            size_t pos = tmp.rfind('/');
-            tmp.erase(pos + 1);
-            tmp += "MAIN.SFX";
-            error = mTombRaider.loadSFX(tmp.c_str());
-            if (error != 0)
-                getLog() << "Could not load SFX " << tmp << Log::endl;
-            else
-                getLog() << "Loaded external SFX file!" << Log::endl;
-        }
-
-        // Process data
-        processTextures();
-        processRooms();
-        processModels();
-        processSprites();
-        processMoveables();
-        processPakSounds();
-
-        mTombRaider.reset();
-
-        if (mLara == -1) {
-            //! \todo Cutscene support
-            getLog() << "Can't find Lara entity in level pak!" << Log::endl;
-            //destroy();
-            return -1;
-        } else {
-            mLoaded = true;
-            getRender().setMode(Render::modeVertexLight);
-        }
-    }
-
-    return 0;
 }
 
 void Game::handleAction(ActionEvents action, bool isFinished) {
 
 void Game::handleMouseMotion(int xrel, int yrel, int xabs, int yabs) {
     if (mLoaded) {
-        // Move Camera on X Axis
-        if (xrel > 0)
-            while (xrel-- > 0)
-                getCamera().command(CAMERA_ROTATE_RIGHT);
-        else if (xrel < 0)
-            while (xrel++ < 0)
-                getCamera().command(CAMERA_ROTATE_LEFT);
-
-        // Move Camera on Y Axis
-        if (yrel > 0)
-            while (yrel-- > 0)
-                getCamera().command(CAMERA_ROTATE_UP);
-        else if (yrel < 0)
-            while (yrel++ < 0)
-                getCamera().command(CAMERA_ROTATE_DOWN);
+        Camera::handleMouseMotion(xrel, yrel);
 
-        // Fix Laras rotation
+        /*
         float angles[3] = { 0.0f, getCamera().getRadianYaw(), getCamera().getRadianPitch() };
         getLara().setAngles(angles);
+        */
     }
 }
 
     mLara = lara;
 }
 
-void Game::processSprites() {
-    for (int i = 0; i < (mTombRaider.NumItems() - 1); i++) {
-        if ((mTombRaider.Engine() == TR_VERSION_1) && (mTombRaider.Item()[i].intensity1 == -1))
-            continue;
-
-        for (int j = 0; j < mTombRaider.NumSpriteSequences(); j++) {
-            if (mTombRaider.SpriteSequence()[j].object_id == mTombRaider.Item()[i].object_id)
-                getWorld().addSprite(new SpriteSequence(mTombRaider, i, j));
-        }
-    }
-
-    getLog() << "Found " << mTombRaider.NumSpriteSequences() << " sprites." << Log::endl;
-}
-
-void Game::processRooms() {
-    for (int index = 0; index < mTombRaider.NumRooms(); index++)
-        getWorld().addRoom(new Room(mTombRaider, index));
-
-    getLog() << "Found " << mTombRaider.NumRooms() << " rooms." << Log::endl;
-}
-
-void Game::processModels() {
-    for (int index = 0; index < mTombRaider.getMeshCount(); index++)
-        getWorld().addStaticMesh(new StaticMesh(mTombRaider, index));
-
-    getLog() << "Found " << mTombRaider.getMeshCount() << " meshes." << Log::endl;
-}
-
-void Game::processPakSounds() {
-    unsigned char* riff;
-    unsigned int riffSz;
-    //tr2_sound_source_t *sound;
-    //tr2_sound_details_t *detail;
-    //float pos[3];
-    unsigned int i;
-    unsigned long id;
-
-    /* detail
-       short sample;
-       short volume;
-       short sound_range;
-       short flags;         // bits 8-15: priority?, 2-7: number of sound samples
-    // in this group, bits 0-1: channel number
-    */
-
-    for (i = 0; i < mTombRaider.getSoundSamplesCount(); ++i) {
-        mTombRaider.getSoundSample(i, &riffSz, &riff);
-
-        id = Sound::loadBuffer(riff, riffSz);
-
-        //if (((i + 1) == TR_SOUND_F_PISTOL) && (id > 0))
-        //{
-        //m_testSFX = id;
-        //}
-
-        delete [] riff;
-
-        // sound[i].sound_id; // internal sound index
-        // sound[i].flags;  // 0x40, 0x80, or 0xc0
-        //pos[0] = sound[i].x;
-        //pos[1] = sound[i].y;
-        //pos[2] = sound[i].z;
-        //getSound().SourceAt(id, pos);
-    }
-
-    getLog() << "Found " << mTombRaider.getSoundSamplesCount() << " sound samples." << Log::endl;
-}
-
-void Game::processTextures() {
-    unsigned char* image;
-    unsigned char* bumpmap;
-    int i;
-
-    //if ( mTombRaider.getNumBumpMaps())
-    //  gBumpMapStart = mTombRaider.NumTextures();
-
-    for (i = 0; i < mTombRaider.NumTextures(); ++i) {
-        mTombRaider.Texture(i, &image, &bumpmap);
-
-        // Overwrite any previous level textures on load
-        getTextureManager().loadBufferSlot(image, 256, 256,
-                                           RGBA, 32, TextureManager::TextureStorage::GAME, i);
-
-#ifdef MULTITEXTURE
-        gMapTex2Bump[i] = -1;
-#endif
-
-        if (bumpmap) {
-#ifdef MULTITEXTURE
-            gMapTex2Bump[i] = i + mTombRaider.NumTextures();
-#endif
-            getTextureManager().loadBufferSlot(bumpmap, 256, 256,
-                                               RGBA, 32, TextureManager::TextureStorage::GAME,
-                                               i + mTombRaider.NumTextures());
-        }
-
-        if (image)
-            delete [] image;
-
-        if (bumpmap)
-            delete [] bumpmap;
-    }
-
-    getLog() << "Found " << mTombRaider.NumTextures() << " textures." << Log::endl;
-}
-
-void Game::processMoveables() {
-    unsigned int statCount = 0;
-
-    tr2_moveable_t* moveable = mTombRaider.Moveable();
-    tr2_item_t* item = mTombRaider.Item();
-    tr2_sprite_sequence_t* sprite_sequence = mTombRaider.SpriteSequence();
-
-    for (int i = 0; i < mTombRaider.NumItems(); ++i) {
-        int j;
-        int object_id = item[i].object_id;
-
-        // It may not be a moveable, test for sprite
-        if (!(mTombRaider.Engine() == TR_VERSION_1 && item[i].intensity1 == -1)) {
-            for (j = 0; j < (int)mTombRaider.NumSpriteSequences(); ++j) {
-                if (sprite_sequence[j].object_id == object_id)
-                    break;
-            }
-
-            // It's not a moveable, skip sprite
-            if (j < (int)mTombRaider.NumSpriteSequences())
-                continue;
-        }
-
-        for (j = 0; j < (int)mTombRaider.NumMoveables(); ++j) {
-            if ((int)moveable[j].object_id == object_id)
-                break;
-        }
-
-        // It's not a moveable or even a sprite? Skip unknown
-        if (j == (int)mTombRaider.NumMoveables())
-            continue;
-
-        processMoveable(j, i, object_id);
-        statCount++;
-    }
-
-    /*
-    // Get models that aren't items
-    for (int i = 0; i < mTombRaider.NumMoveables(); ++i)
-    {
-        switch ((int)moveable[i].object_id)
-        {
-            case 30:
-            case 2: // Which tr needs this as model again?
-                processMoveable(i, i, (int)moveable[i].object_id);
-                break;
-            default:
-                switch (mTombRaider.Engine())
-                {
-                    case TR_VERSION_1:
-                        switch ((int)moveable[i].object_id)
-                        {
-                            case TombRaider1::LaraMutant:
-                                processMoveable(i, i, (int)moveable[i].object_id);
-                                break;
-                        }
-                        break;
-                    case TR_VERSION_4:
-                        switch ((int)moveable[i].object_id)
-                        {
-                            case TR4_PISTOLS_ANIM:
-                            case TR4_UZI_ANIM:
-                            case TR4_SHOTGUN_ANIM:
-                            case TR4_CROSSBOW_ANIM:
-                            case TR4_GRENADE_GUN_ANIM:
-                            case TR4_SIXSHOOTER_ANIM:
-                                processMoveable(i, i, (int)moveable[i].object_id);
-                                break;
-                        }
-                        break;
-                    case TR_VERSION_2:
-                    case TR_VERSION_3:
-                    case TR_VERSION_5:
-                    case TR_VERSION_UNKNOWN:
-                        break;
-                }
-        }
-    }
-    */
-
-    getLog() << "Found " << mTombRaider.NumMoveables() + statCount << " moveables." << Log::endl;
-}
-
-// index moveable, i item, sometimes both moveable
-// object_id of item or moveable
-void Game::processMoveable(int index, int i, int object_id) {
-    // Check if the SkeletalModel is already cached
-    bool cached = false;
-    unsigned int model;
-    for (model = 0; model < getWorld().sizeSkeletalModel(); model++) {
-        if (getWorld().getSkeletalModel(model).getId() == object_id) {
-            cached = true;
-            break;
-        }
-    }
-
-    // Create a new SkeletalModel, if needed
-    if (!cached)
-        getWorld().addSkeletalModel(new SkeletalModel(mTombRaider, index, object_id));
-
-    // Create a new Entity, using the cached or the new SkeletalModel
-    Entity* entity = new Entity(mTombRaider, index, i, model);
-    getWorld().addEntity(entity);
-
-    // Store reference to Lara
-    if (entity->getObjectId() == 0)
-        mLara = getWorld().sizeEntity() - 1;
-
-    // Store reference to the SkyMesh
-    if (i == mTombRaider.getSkyModelId())
-        getRender().setSkyMesh(i, //moveable[i].starting_mesh,
-                               (mTombRaider.Engine() == TR_VERSION_2));
-}
-

src/Menu.cpp

         unsigned int xOverlay = (::getWindow().getWidth() - wOverlay) / 2;
         unsigned int yOverlay = (::getWindow().getHeight() - hOverlay) / 2;
 
+        /*
         glColor4f(0.0f, 0.0f, 0.0f, 0.75f);
         glDisable(GL_TEXTURE_2D);
         glRecti(xOverlay, yOverlay, xOverlay + wOverlay, yOverlay + hOverlay);
         glEnable(GL_TEXTURE_2D);
+        */
 
         Font::drawTextWrapped(xOverlay + 10, yOverlay + 5, 1.0f, BLUE, w0, dialogText);
         if (dialogButton2.length() > 0) {

src/MenuFolder.cpp

 #include "Game.h"
 #include "loader/Loader.h"
 #include "Log.h"
+#include "Render.h"
 #include "RunTime.h"
 #include "MenuFolder.h"
 #include "system/Font.h"
     if (!visible)
         return;
 
-    ::getWindow().glEnter2D();
+    Font::drawTextCentered(0, 10, 1.2f, BLUE, ::getWindow().getWidth(), VERSION);
 
     // Draw half-transparent overlay
-    glColor4f(0.0f, 0.0f, 0.0f, 0.75f);
-    glDisable(GL_TEXTURE_2D);
-    glRecti(0, 0, (GLint)::getWindow().getWidth(), (GLint)::getWindow().getHeight());
-    glEnable(GL_TEXTURE_2D);
+    glm::vec4 color(0.0f, 0.0f, 0.0f, 0.75f);
+    Render::drawTexture(0.0f, 0.0f, getWindow().getWidth(), getWindow().getHeight(),
+                    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, getWindow().getWidth(), VERSION);
 
     // Estimate displayable number of items
-    int items = (::getWindow().getHeight() - 60) / 25;
+    int items = (getWindow().getHeight() - 60) / 25;
 
     // Print list of "..", folders, files
     for (long i = mMin; (i < (mMin + items))
     }
 
     displayDialog();
-
-    ::getWindow().glExit2D();
 }
 
 void MenuFolder::loadOrOpen() {

src/Mesh.cpp

 #include "TextureManager.h"
 #include "Mesh.h"
 
-void Mesh::addTexturedRectangle(Vec3 a, Vec3 b, Vec3 c, Vec3 d, uint16_t textile) {
+void Mesh::addTexturedRectangle(glm::vec3 a, glm::vec3 b, glm::vec3 c, glm::vec3 d,
+                                uint16_t textile) {
     texturedRectangles.emplace_back(a, b, c, d, textile);
 }
 
-void Mesh::addTexturedTriangle(Vec3 a, Vec3 b, Vec3 c, uint16_t textile) {
-    texturedTriangles.emplace_back(a, b, c, Vec3(), textile);
+void Mesh::addTexturedTriangle(glm::vec3 a, glm::vec3 b, glm::vec3 c, uint16_t textile) {
+    texturedTriangles.emplace_back(a, b, c, glm::vec3(), textile);
 }
 
-void Mesh::addColoredRectangle(Vec3 a, Vec3 b, Vec3 c, Vec3 d, float re, float gr, float bl) {
+void Mesh::addColoredRectangle(glm::vec3 a, glm::vec3 b, glm::vec3 c, glm::vec3 d, float re,
+                               float gr, float bl) {
     coloredRectangles.emplace_back(a, b, c, d, -1, re, gr, bl);
 }
 
-void Mesh::addColoredTriangle(Vec3 a, Vec3 b, Vec3 c, float re, float gr, float bl) {
-    coloredTriangles.emplace_back(a, b, c, Vec3(), -1, re, gr, bl);
+void Mesh::addColoredTriangle(glm::vec3 a, glm::vec3 b, glm::vec3 c, float re, float gr, float bl) {
+    coloredTriangles.emplace_back(a, b, c, glm::vec3(), -1, re, gr, bl);
 }
 
-void Mesh::addNormal(Vec3 n) {
+void Mesh::addNormal(glm::vec3 n) {
     normals.emplace_back(n);
 }
 
         return;
     }
 
-    // Render textured quads
     for (auto& q : texturedRectangles) {
         if (mMode == MeshModeWireframe) {
             getTextureManager().bindTextureId(TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
+            /*
             glBegin(GL_QUADS);
             glTexCoord2f(0.0f, 0.0f);
             glVertex3f(q.a.x, q.a.y, q.a.z);
             glTexCoord2f(0.0f, 1.0f);
             glVertex3f(q.d.x, q.d.y, q.d.z);
             glEnd();
+            */
+        } else if (mMode == MeshModeSolid) {
+            // TODO
         } else if (mMode == MeshModeTexture) {
-            getTextureManager().getTile(q.texture).displayRectangle(q.a, q.b, q.c, q.d);
+            //getTextureManager().getTile(q.texture).displayRectangle(q.a, q.b, q.c, q.d);
+        }
+    }
+
+    for (auto& t : texturedTriangles) {
+        if (mMode == MeshModeWireframe) {
+            getTextureManager().bindTextureId(TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
+            /*
+            glBegin(GL_TRIANGLES);
+            glTexCoord2f(0.0f, 0.0f);
+            glVertex3f(t.a.x, t.a.y, t.a.z);
+            glTexCoord2f(1.0f, 0.0f);
+            glVertex3f(t.b.x, t.b.y, t.b.z);
+            glTexCoord2f(1.0f, 1.0f);
+            glVertex3f(t.c.x, t.c.y, t.c.z);
+            glEnd();
+            */
+        } else if (mMode == MeshModeSolid) {
+            // TODO
+        } else if (mMode == MeshModeTexture) {
+            //getTextureManager().getTile(t.texture).displayTriangle(t.a, t.b, t.c);
+        }
+    }
+
+    for (auto& q : coloredRectangles) {
+        if (mMode == MeshModeWireframe) {
+            getTextureManager().bindTextureId(TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
+            /*
+            glBegin(GL_QUADS);
+            glTexCoord2f(0.0f, 0.0f);
+            glVertex3f(q.a.x, q.a.y, q.a.z);
+            glTexCoord2f(1.0f, 0.0f);
+            glVertex3f(q.b.x, q.b.y, q.b.z);
+            glTexCoord2f(1.0f, 1.0f);
+            glVertex3f(q.c.x, q.c.y, q.c.z);
+            glTexCoord2f(0.0f, 1.0f);
+            glVertex3f(q.d.x, q.d.y, q.d.z);
+            glEnd();
+            */
+        } else if (mMode == MeshModeSolid) {
+            // TODO
+        } else if (mMode == MeshModeTexture) {
+            // TODO
+        }
+    }
+
+    for (auto& t : coloredTriangles) {
+        if (mMode == MeshModeWireframe) {
+            getTextureManager().bindTextureId(TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
+            /*
+            glBegin(GL_TRIANGLES);
+            glTexCoord2f(0.0f, 0.0f);
+            glVertex3f(t.a.x, t.a.y, t.a.z);
+            glTexCoord2f(1.0f, 0.0f);
+            glVertex3f(t.b.x, t.b.y, t.b.z);
+            glTexCoord2f(1.0f, 1.0f);
+            glVertex3f(t.c.x, t.c.y, t.c.z);
+            glEnd();
+            */
+        } else if (mMode == MeshModeSolid) {
+            // TODO
+        } else if (mMode == MeshModeTexture) {
+            // TODO
         }
     }
 }
     for (unsigned int i = 0; i < mNumVertices; i++)
         delete [] mVertices[i];
     delete [] mVertices;
-    mVertices = NULL;
+    mVertices = nullptr;
 
     for (unsigned int i = 0; i < mNumNormals; i++)
         delete [] mNormals[i];
     delete [] mNormals;
-    mNormals = NULL;
+    mNormals = nullptr;
 
     for (unsigned int i = 0; i < mNumColors; i++)
         delete [] mColors[i];
     delete [] mColors;
-    mColors = NULL;
+    mColors = nullptr;
 
     if (mTris) {
         for (unsigned int i = 0; i < mNumTris; ++i) {
         }
 
         delete [] mTris;
-        mTris = NULL;
+        mTris = nullptr;
     }
 
     if (mQuads) {
         }
 
         delete [] mQuads;
-        mQuads = NULL;
+        mQuads = nullptr;
     }
 
     delete [] mVertexArray;
-    mVertexArray = NULL;
+    mVertexArray = nullptr;
 
     delete [] mNormalArray;
-    mNormalArray = NULL;
+    mNormalArray = nullptr;
 
     delete [] mColorArray;
-    mColorArray = NULL;
+    mColorArray = nullptr;
 
     delete [] mTriangleTextures;
-    mTriangleTextures = NULL;
+    mTriangleTextures = nullptr;
 
     delete [] mTriangleIndices;
-    mTriangleIndices = NULL;
+    mTriangleIndices = nullptr;
 
     delete [] mTriangleFlags;
-    mTriangleFlags = NULL;
+    mTriangleFlags = nullptr;
 
     delete [] mTriangleTexCoordArray;
-    mTriangleTexCoordArray = NULL;
+    mTriangleTexCoordArray = nullptr;
 }
 
 
 void Mesh::drawAlphaOld() {
     unsigned int i, j, k, index;
 
+    /*
 
     // Render quadralaterals
     for (mQuads ? i = 0 : i = mNumQuads; i < mNumQuads; ++i) {
 
         glEnd();
     }
+
+    */
 }
 
 
 void Mesh::drawSolidOld() {
     unsigned int i, j, k, index;
 
+    /*
 
-    if (mFlags & fMesh_UseVertexArray) {
-        //glEnableClientState(GL_VERTEX_ARRAY);
-        //glVertexPointer(3, GL_FLOAT, 0, mVertexArray);
-
-        glPointSize(2.0f);
-        glColor3f(1.0f, 1.0f, 1.0f);
-        glBegin(GL_TRIANGLES);
-
-        for (i = 0; i < mTriangleCount * 3; ++i) {
-            //glArrayElement(mTriangleIndices[i]);
-            glVertex3fv(mVertexArray + mTriangleIndices[i]);
-        }
-
-        glEnd();
-
-        glPointSize(1.0f);
-
-        //! \fixme
-        /*
-        for (j = 0; j < mQuads[i].num_quads; ++j)
-        {
-            for (k = 0; k < 4; ++k)
-            {
-                index = mQuads[i].quads[j*4+k];
-
-                glTexCoord2fv(mQuads[i].texcoors[j*4+k]);
-                glArrayElement(mQuads[i].quads[j*4+k]);
-            }
-        }
-        */
-
-        return;
-    }
 
     // Render quadralaterals
     for (mQuads ? i = 0 : i = mNumQuads; i < mNumQuads; ++i) {
         glActiveTextureARB(GL_TEXTURE0_ARB);
     }
 #endif
+
+    */
 }
 
 

src/Render.cpp

 #include "World.h"
 #include "system/Window.h"
 
-Render::Render() {
-    mSkyMesh = -1;
-    mSkyMeshRotation = false;
-    mMode = Render::modeDisabled;
-    mLock = 0;
-    mFlags = (fRoomAlpha | fEntityModels | fRenderPonytail);
+RenderMode Render::mode = RenderMode::Disabled;
 
-    debugTexture = -1;
-    debugTextile = -1;
-    debugSprite = -1;
-    debugTextureStorage = TextureManager::TextureStorage::GAME;
-    debugSpriteOffset = 0;
-    debugX = 0.0f;
-    debugY = 0.0f;
-    debugW = 256.0f;
-    debugH = 256.0f;
+RenderMode Render::getMode() {
+    return mode;
 }
 
-Render::~Render() {
-    ClearWorld();
-}
-
-void Render::ClearWorld() {
-    mRoomRenderList.clear();
-}
-
-void Render::screenShot(const char* filenameBase) {
-    int sz = getWindow().getWidth() * getWindow().getHeight();
-    unsigned char* image = new unsigned char[sz * 3];
-    static int count = 0;
-    bool done = false;
-
-    assert(filenameBase != nullptr);
-
-    // Don't overwrite files
-    std::ostringstream filename;
-    while (!done) {
-        filename << filenameBase << "-" << count++ << ".tga";
-
-        FILE* f = fopen(filename.str().c_str(), "rb");
-        if (f) {
-            fclose(f);
-        } else {
-            done = true;
-        }
-    }
-
-    glReadPixels(0, 0, getWindow().getWidth(), getWindow().getHeight(), GL_BGR_EXT, GL_UNSIGNED_BYTE,
-                 image);
-    tgaSave(filename.str().c_str(), image, getWindow().getWidth(), getWindow().getHeight(), 0);
-    delete [] image;
-}
-
-unsigned int Render::getFlags() {
-    return mFlags;
-}
-
-void Render::lightRoom(Room& room) {
-    for (unsigned int i = 0; i < room.sizeLights(); ++i) {
-        Light& light = room.getLight(i);
-        float pos[4], color[4];
-        float dir[3];
-        light.getPos(pos);
-        light.getColor(color);
-        light.getDir(dir);
-
-        glEnable(GL_LIGHT0 + i);
-
-        switch (light.getType()) {
-            case Light::typeSpot:
-                glLightf(GL_LIGHT0 + i,  GL_SPOT_CUTOFF,    light.getCutoff());
-                glLightfv(GL_LIGHT0 + i, GL_POSITION,       pos);
-                glLightfv(GL_LIGHT0 + i, GL_SPOT_DIRECTION, dir);
-                glLightfv(GL_LIGHT0 + i, GL_DIFFUSE,        color);
-                break;
-            case Light::typePoint:
-            case Light::typeDirectional:
-                glLightf(GL_LIGHT0 + i, GL_CONSTANT_ATTENUATION, 1.0); // 1.0
-
-                // GL_QUADRATIC_ATTENUATION
-                // GL_LINEAR_ATTENUATION
-                glLightf(GL_LIGHT0 + i, GL_LINEAR_ATTENUATION, light.getAtt());
-
-                glLightfv(GL_LIGHT0 + i, GL_DIFFUSE, color); // GL_DIFFUSE
-                glLightfv(GL_LIGHT0 + i, GL_POSITION, pos);
-                break;
-        }
-    }
-}
-
-void Render::clearFlags(unsigned int flags) {
-    mFlags &= ~flags;
-
-    if (flags & Render::fFog) {
-        if (glIsEnabled(GL_FOG)) {
-            glDisable(GL_FOG);
-        }
-    }
-
-    if (flags & Render::fGL_Lights) {
-        glDisable(GL_LIGHTING);
-    }
-}
-
-void Render::setFlags(unsigned int flags) {
-    mFlags |= flags;
-
-    if (flags & Render::fFog) {
-        glEnable(GL_FOG);
-        glFogf(GL_FOG_MODE, GL_EXP2);
-        glFogf(GL_FOG_DENSITY, 0.00008f);
-        glFogf(GL_FOG_START, 30000.0f);
-        glFogf(GL_FOG_END, 50000.0f);
-
-        float color[4];
-        color[0] = BLACK[0] * 256.0f;
-        color[1] = BLACK[1] * 256.0f;
-        color[2] = BLACK[2] * 256.0f;
-        color[3] = BLACK[3] * 256.0f;
-        glFogfv(GL_FOG_COLOR, color);
-    }
-
-    if (flags & Render::fGL_Lights) {
-        float color[4];
-        color[0] = WHITE[0] * 256.0f;
-        color[1] = WHITE[1] * 256.0f;
-        color[2] = WHITE[2] * 256.0f;
-        color[3] = WHITE[3] * 256.0f;
-
-        glEnable(GL_LIGHTING);
-        glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 0);
-        glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, color);
-        glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, color);
-
-        color[0] = GREY[0] * 256.0f;
-        color[1] = GREY[1] * 256.0f;
-        color[2] = GREY[2] * 256.0f;
-        color[3] = GREY[3] * 256.0f;
-        glLightModelfv(GL_LIGHT_MODEL_AMBIENT, color);
-    }
-}
-
-int Render::getMode() {
-    return mMode;
-}
-
-void Render::setMode(int n) {
-    mMode = n;
-
-    switch (mMode) {
-        case Render::modeDisabled:
+void Render::setMode(RenderMode m) {
+    mode = m;
+    switch (mode) {
+        case RenderMode::Disabled:
             break;
-        case Render::modeSolid:
-        case Render::modeWireframe:
+        case RenderMode::Solid:
+        case RenderMode::Wireframe:
             glClearColor(PURPLE[0] / 256.0f, PURPLE[1] / 256.0f,
                          PURPLE[2] / 256.0f, PURPLE[3] / 256.0f);
-            glDisable(GL_TEXTURE_2D);
+            //glDisable(GL_TEXTURE_2D);
             break;
         default:
-            if (mMode == Render::modeLoadScreen) {
-                glBlendFunc(GL_SRC_ALPHA, GL_ONE);
-            } else {
-                glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
-            }
-
             glClearColor(BLACK[0] / 256.0f, BLACK[1] / 256.0f,
                          BLACK[2] / 256.0f, BLACK[3] / 256.0f);
-
-            glEnable(GL_TEXTURE_2D);
+            //glEnable(GL_TEXTURE_2D);
     }
 }
 
 void Render::display() {
-    switch (mMode) {
-        case Render::modeDisabled:
-            return;
-        case Render::modeLoadScreen:
-            drawLoadScreen();
-            return;
-        default:
-            break;
-    }
-
-    if (mMode == Render::modeWireframe)
-        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
-    else
-        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
-
-    float camOffsetH = 0.0f;
-
-    switch (getGame().getLara().getMoveType()) {
-        case Entity::MoveTypeFly:
-        case Entity::MoveTypeNoClipping:
-        case Entity::MoveTypeSwim:
-            //camOffsetH = 64.0f;
-            camOffsetH = 512.0f;
-            break;
-        case Entity::MoveTypeWalk:
-        case Entity::MoveTypeWalkNoSwim:
-            camOffsetH = 512.0f;
-            break;
-    }
-
-    float curPos[3], camPos[3], atPos[3];
-
-    curPos[0] = getGame().getLara().getPos(0);
-    curPos[1] = getGame().getLara().getPos(1);
-    curPos[2] = getGame().getLara().getPos(2);
-    float yaw = getGame().getLara().getAngle(1);
-
-    // Mongoose 2002.08.24, New 3rd person camera hack
-    camPos[0] = curPos[0] - (1024.0f * sinf(yaw));
-    camPos[1] = curPos[1] - camOffsetH; // UP is lower val
-    camPos[2] = curPos[2] - (1024.0f * cosf(yaw));
-
-    long index = getGame().getLara().getRoom();
-    long sector = getWorld().getRoom(index).getSector(camPos[0], camPos[2]);
-
-    // Handle camera out of world
-    if ((sector < 0) ||
-        ((unsigned int)sector >= getWorld().getRoom(index).sizeSectors()) ||
-        getWorld().getRoom(index).isWall(sector)) {
-        camPos[0] = curPos[0] + (64.0f * sinf(yaw));
-        camPos[1] -= 64.0f;
-        camPos[2] = curPos[2] + (64.0f * cosf(yaw));
-    }
-
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-    glLoadIdentity();
-
-    // Setup view in OpenGL with camera
-    getCamera().setPosition(camPos);
-    getCamera().update();
-    getCamera().getTarget(atPos);
-    // Mongoose 2002.08.13, Quick fix to render OpenRaider upside down
-    Window::lookAt(camPos[0], camPos[1], camPos[2], atPos[0], atPos[1], atPos[2], 0.0f, -1.0f, 0.0f);
-
-    // Update view volume for vising
-    updateViewVolume();
-
-    // Render world
-    glColor3ubv(GREY); // was WHITE
-    drawSkyMesh(96.0);
-
-    // Figure out how much of the map to render
-    newRoomRenderList(index);
-
-    // Room solid pass, need to do depth sorting to avoid 2 pass render
-    for (unsigned int i = 0; i < mRoomRenderList.size(); i++) {
-        Room& room = *mRoomRenderList[i];
-
-        if (mFlags & Render::fGL_Lights)
-            lightRoom(room);
-
-        room.display(false);
-    }
-
-    // Draw all visible enities
-    if (mFlags & Render::fEntityModels) {
-        std::vector<Entity*> entityRenderList;
-
-        for (unsigned int i = 0; i < getWorld().sizeEntity(); i++) {
-            Entity& e = getWorld().getEntity(i);
-
-            // Don't show Lara to the player
-            if (&e == &getGame().getLara())
-                continue;
-
-            // Mongoose 2002.08.15, Nothing to draw, skip
-            // Mongoose 2002.12.24, Some entities have no animation =p
-            if (e.getModel().size() == 0)
-                continue;
 
-            // Is it in view volume? ( Hack to use sphere )
-            if (!isVisible(e.getPos(0), e.getPos(1), e.getPos(2), 512.0f))
-                continue;
-
-            //! \fixme Is it in a room we're rendering?
-            //if (mRoomRenderList[e->room] == 0x0)
-            //{
-            //  continue;
-            //}
-
-            entityRenderList.push_back(&e);
-        }
-
-        // Draw objects not tied to rooms
-        glPushMatrix();
-
-        // Draw lara or other player model ( move to entity rendering method )
-        getGame().getLara().display();
-
-        // Draw sprites after player to handle alpha
-        for (unsigned int i = 0; i < getWorld().sizeSprite(); i++) {
-            SpriteSequence& sprite = getWorld().getSprite(i);
-            for (unsigned int j = 0; j < sprite.size(); j++)
-                sprite.get(j).display();
-        }
-
-        glPopMatrix();
-
-        // Depth sort entityRenderList and display each entity
-        std::sort(entityRenderList.begin(), entityRenderList.end(), Entity::compare);
-        for (unsigned int i = 0; i < entityRenderList.size(); i++) {
-            entityRenderList[i]->display();
-        }
-    }
-
-    // Room alpha pass
-    // Skip room alpha pass for modes w/o texture
-    if (!(mMode == Render::modeSolid || mMode == Render::modeWireframe)) {
-        for (unsigned int i = 0; i < mRoomRenderList.size(); i++)
-            mRoomRenderList[i]->display(true);
-
-        if (debugTexture >= 0) {
-            getWindow().glEnter2D();
-            drawTexture(debugX, debugY, debugW, debugH, debugTexture, debugTextureStorage);
-            getWindow().glExit2D();
-        } else if (debugTextile >= 0) {
-            getWindow().glEnter2D();
-            drawTextile(debugX, debugY, debugW, debugH, debugTextile);
-            getWindow().glExit2D();
-        } else if (debugSprite >= 0) {
-            getWindow().glEnter2D();
-            drawSprite(debugX, debugY, debugW, debugH, debugSprite, debugSpriteOffset);
-            getWindow().glExit2D();
-        }
+    if (mode == RenderMode::LoadScreen) {
+        glm::vec4 color(1.0f, 1.0f, 1.0f, 1.0f);
+        drawTexture(0.0f, 0.0f, getWindow().getWidth(), getWindow().getHeight(),
+                    color, TEXTURE_SPLASH, TextureManager::TextureStorage::SYSTEM);
+        return;
+    } else if (mode == RenderMode::Disabled) {
+        return;
     }
 
-    if (mMode == Render::modeWireframe)
+    if (mode == RenderMode::Wireframe) {
+        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+    } else {
         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
-
-    glFlush();
-}
-
-void Render::drawLoadScreen() {
-    getWindow().glEnter2D();
-
-    drawTexture(0.0f, 0.0f, getWindow().getWidth(), getWindow().getHeight(),
-                TEXTURE_SPLASH, TextureManager::TextureStorage::SYSTEM);
-
-    if (debugTexture >= 0)
-        drawTexture(debugX, debugY, debugW, debugH, debugTexture, debugTextureStorage);
-    else if (debugTextile >= 0)
-        drawTextile(debugX, debugY, debugW, debugH, debugTextile);
-    else if (debugSprite >= 0)
-        drawSprite(debugX, debugY, debugW, debugH, debugSprite, debugSpriteOffset);
-
-    getWindow().glExit2D();
-
-    glFlush();
-}
-
-void Render::newRoomRenderList(int index) {
-    assert(index >= 0);
-
-    static int currentRoomId = -1;
-
-    // Update room render list if needed
-    if (currentRoomId != index) {
-        buildRoomRenderList(getWorld().getRoom(index));
-    }
-
-    currentRoomId = index;
-}
-
-void Render::buildRoomRenderList(Room& room) {
-
-    // Must be visible
-    //! \fixme Add depth sorting here - remove multipass
-    if (!isVisible(room.getBoundingBox()))
-        return;
-
-    // Must not already be cached
-    for (unsigned int i = 0; i < mRoomRenderList.size(); i++) {
-        Room* room2 = mRoomRenderList[i];
-
-        if (room2 == &room)
-            return;
     }
 
-    /* Add current room to list */
-    mRoomRenderList.push_back(&room);
+    // TODO Setup matrices
 
-    // Try to add adj rooms and their adj rooms, skip this room
-    for (unsigned int i = 1; i < room.sizeAdjacentRooms(); i++) {
-        if (room.getAdjacentRoom(i) < 0)
-            continue;
+    // TODO Render world
 
-        Room& room2 = getWorld().getRoom(room.getAdjacentRoom(i));
-
-        //! \fixme Add portal visibility check here
-
-        if (&room2 != &room)
-            buildRoomRenderList(room2);
+    if (mode == RenderMode::Wireframe) {
+        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
     }
 }
 
-void Render::drawSkyMesh(float scale) {
-    //skeletal_model_t *model = getWorld().getModel(mSkyMesh);
-    //if (!model)
-    //    return;
-
-    glDisable(GL_DEPTH_TEST);
-    glPushMatrix();
-
-    if (mSkyMeshRotation)
-        glRotated(90.0, 1, 0, 0);
-
-    glTranslated(0.0, 1000.0, 0.0);
-    glScaled(scale, scale, scale);
-    //drawModel(model);
-    //drawModelMesh(getWorld().getMesh(mSkyMesh), );
-    glPopMatrix();
-    glEnable(GL_DEPTH_TEST);
-}
-
-void Render::setSkyMesh(int index, bool rot) {
-    mSkyMesh = index;
-    mSkyMeshRotation = rot;
-}
-
-void Render::updateViewVolume() {
-    float proj[16], mdl[16];
-
-    glGetFloatv(GL_PROJECTION_MATRIX, proj);
-    glGetFloatv(GL_MODELVIEW_MATRIX, mdl);
-    mViewVolume.updateFrame(proj, mdl);
-}
-
-bool Render::isVisible(BoundingBox& box) {
-    float bbox[2][3];
-    box.getBoundingBox(bbox);
-
-    // For debugging purposes
-    if (mMode == Render::modeWireframe)
-        box.display(true, PINK, RED);
-
-    return mViewVolume.isBboxInFrustum(bbox[0], bbox[1]);
-}
+void Render::screenShot(const char* filenameBase) {
+    int sz = getWindow().getWidth() * getWindow().getHeight();
+    unsigned char* image = new unsigned char[sz * 3];
+    static int count = 0;
+    bool done = false;
 
-bool Render::isVisible(float x, float y, float z) {
-    // For debugging purposes
-    if (mMode == Render::modeWireframe) {
-        glPointSize(5.0);
-        glColor3ubv(PINK);
-        glBegin(GL_POINTS);
-        glVertex3f(x, y, z);
-        glEnd();
-    }
+    assert(filenameBase != nullptr);
 
-    return (mViewVolume.isPointInFrustum(x, y, z));
-}
+    // Don't overwrite files
+    std::ostringstream filename;
+    while (!done) {
+        filename << filenameBase << "-" << count++ << ".tga";
 
-bool Render::isVisible(float x, float y, float z, float radius) {
-    // For debugging purposes
-    if (mMode == Render::modeWireframe) {
-        glPointSize(5.0);
-        glColor3ubv(PINK);
-        glBegin(GL_POINTS);
-        glVertex3f(x, y, z);
-        glEnd();
+        FILE* f = fopen(filename.str().c_str(), "rb");
+        if (f) {
+            fclose(f);
+        } else {
+            done = true;
+        }
     }
 
-    return (mViewVolume.isSphereInFrustum(x, y, z, radius));
-}
-
-float Render::getDistToSphereFromNear(float x, float y, float z, float radius) {
-    return mViewVolume.getDistToSphereFromNear(x, y, z, radius);
-}
-
-void Render::debugDisplayTexture(int texture, TextureManager::TextureStorage s,
-                                 float x, float y, float w, float h) {
-    debugTexture = texture;
-    debugTextureStorage = s;
-    debugX = x;
-    debugY = y;
-    debugW = w;
-    debugH = h;
-    debugTextile = -1;
+    //glReadPixels(0, 0, getWindow().getWidth(), getWindow().getHeight(), GL_BGR_EXT, GL_UNSIGNED_BYTE,
+    //             image);
+    //tgaSave(filename.str().c_str(), image, getWindow().getWidth(), getWindow().getHeight(), 0);
+    delete [] image;
 }
 
-void Render::drawTexture(float x, float y, float w, float h,
+void Render::drawTexture(float x, float y, float w, float h, glm::vec4 color,
                          unsigned int texture, TextureManager::TextureStorage s) {
-    float z = 0.0f;
-
-    glColor3ubv(WHITE);
-
-    if (mFlags & Render::fGL_Lights)
-        glDisable(GL_LIGHTING);
+    std::vector<glm::vec2> vertices;
+    std::vector<glm::vec2> uvs;
 
-    getTextureManager().bindTextureId(texture, s);
+    vertices.push_back(glm::vec2(x, y + h));
+    vertices.push_back(glm::vec2(x, y));
+    vertices.push_back(glm::vec2(x + w, y + h));
 
-    glBegin(GL_TRIANGLE_STRIP);
-    glTexCoord2f(1.0, 1.0);
-    glVertex3f(x + w, y + h, z);
-    glTexCoord2f(0.0, 1.0);
-    glVertex3f(x, y + h, z);
-    glTexCoord2f(1.0, 0.0);
-    glVertex3f(x + w, y, z);
-    glTexCoord2f(0.0, 0.0);
-    glVertex3f(x, y, z);
-    glEnd();
-
-    if (mFlags & Render::fGL_Lights)
-        glEnable(GL_LIGHTING);
-}
-
-void Render::debugDisplayTextile(int texture, float x, float y, float w, float h) {
-    debugTextile = texture;
-    debugX = x;
-    debugY = y;
-    debugW = w;
-    debugH = h;
-    debugTexture = -1;
-}
-
-void Render::drawTextile(float x, float y, float w, float h, unsigned int textile) {
-    glColor3ubv(WHITE);
-
-    if (mFlags & Render::fGL_Lights)
-        glDisable(GL_LIGHTING);
-
-    getTextureManager().getTile(textile).display(x, y, w, h, 0.0f);
-
-    if (mFlags & Render::fGL_Lights)
-        glEnable(GL_LIGHTING);
-}
-
-void Render::debugDisplaySprite(int sprite, int offset, float x, float y, float w, float h) {
-    debugSprite = sprite;
-    debugSpriteOffset = offset;
-    debugX = x;
-    debugY = y;
-    debugW = w;
-    debugH = h;
-    debugTexture = -1;
-    debugTextile = -1;
-}
+    vertices.push_back(glm::vec2(x + w, y));
+    vertices.push_back(glm::vec2(x + w, y + h));
+    vertices.push_back(glm::vec2(x, y));
 
-void Render::drawSprite(float x, float y, float w, float h, unsigned int sprite,
-                        unsigned int offset) {
-    glColor3ubv(WHITE);
+    uvs.push_back(glm::vec2(0.0f, 1.0f));
+    uvs.push_back(glm::vec2(0.0f, 0.0f));
+    uvs.push_back(glm::vec2(1.0f, 1.0f));
 
-    if (mFlags & Render::fGL_Lights)
-        glDisable(GL_LIGHTING);
+    uvs.push_back(glm::vec2(1.0f, 0.0f));
+    uvs.push_back(glm::vec2(1.0f, 1.0f));
+    uvs.push_back(glm::vec2(0.0f, 0.0f));
 
-    getWorld().getSprite(sprite).get(offset).display(x, y, w, h);
+    //! \fixme drawTextGL only uses SYSTEM textures!
+    assert(s == TextureManager::TextureStorage::SYSTEM);
 
-    if (mFlags & Render::fGL_Lights)
-        glEnable(GL_LIGHTING);
+    Window::drawTextGL(vertices, uvs, color, texture);
 }
 

src/Room.cpp

  * \author xythobuz
  */
 
+#include "glm/gtx/intersect.hpp"
+
 #include <algorithm>
 
 #include "global.h"
 #include "Room.h"
 #include "TextureManager.h"
 
-#ifdef MULTITEXTURE
-#include <map>
-extern std::map<int, int> gMapTex2Bump;
-#endif
-
 Room::Room(float p[3], unsigned int f, unsigned int x, unsigned int z)
     : flags(f), numXSectors(x), numZSectors(z) {
     if (p == nullptr) {
         pos[i] = p[i];
 }
 
-Room::Room(TombRaider& tr, unsigned int index) {
-    if (!tr.isRoomValid(index)) {
-        getLog() << "WARNING: Handling invalid vertex array in room" << Log::endl;
-        return;
-    }
-
-    flags = 0;
-    unsigned int trFlags = 0;
-    float box[2][3];
-    tr.getRoomInfo(index, &trFlags, pos, box[0], box[1]);
-
-    if (trFlags & tombraiderRoom_underWater)
-        flags |= RoomFlagUnderWater;
-
-    // Adjust positioning for OR world coordinate translation
-    box[0][0] += pos[0];
-    box[1][0] += pos[0];
-    box[0][2] += pos[2];
-    box[1][2] += pos[2];
-
-    bbox.setBoundingBox(box[0], box[1]);
-
-    // Mongoose 2002.04.03, Setup 3D transform
-    Matrix transform;
-    transform.setIdentity();
-    transform.translate(pos);
-
-    // Current room is always first
-    adjacentRooms.push_back(index);
-
-    // Setup portals
-    unsigned int count = tr.getRoomPortalCount(index);
-    for (unsigned int i = 0; i < count; i++) {
-        portals.push_back(new Portal(tr, index, i, transform));
-        adjacentRooms.push_back(portals.back()->getAdjoiningRoom());
-    }
-
-    // List of sectors in this room
-    count = tr.getRoomSectorCount(index, &numZSectors, &numXSectors);
-    for (unsigned int i = 0; i < count; i++)
-        sectors.push_back(new Sector(tr, index, i));
-
-    // Setup room lights
-    count = tr.getRoomLightCount(index);
-    for (unsigned int i = 0; i < count; i++)
-        lights.push_back(new Light(tr, index, i));
-
-    // Room models
-    count = tr.getRoomModelCount(index);
-    for (unsigned int i = 0; i < count; i++)
-        models.push_back(new StaticModel(tr, index, i));
-
-    // Room sprites
-    count = tr.getRoomSpriteCount(index);
-    for (unsigned int i = 0; i < count; i++)
-        sprites.push_back(new Sprite(tr, index, i));
-
-//#define EXPERIMENTAL_UNIFIED_ROOM_GEOMETERY
-#ifdef EXPERIMENTAL_UNIFIED_ROOM_GEOMETERY
-    unsigned int vertexCount, normalCount, colorCount, triCount;
-    float* vertexArray;
-    float* normalArray;
-    float* colorArray;
-    unsigned int* indices, *fflags;
-    float* texCoords;
-    int* textures;
-
-    tr.getRoomVertexArrays(index,
-                           &vertexCount, &vertexArray,
-                           &normalCount, &normalArray,
-                           &colorCount, &colorArray);
-
-    mesh.bufferVertexArray(vertexCount, vertexArray);
-    mesh.bufferNormalArray(normalCount, normalArray);
-    mesh.bufferColorArray(vertexCount, colorArray);
-
-    tr.getRoomTriangles(index, 0, &triCount, &indices, &texCoords, &textures, &fflags);
-
-    mesh.bufferTriangles(triCount, indices, texCoords, textures, fflags);
-#else
-    const unsigned int TextureLimit = 24;
-    float rgba[4];
-    float xyz[3];
-
-    count = tr.getRoomVertexCount(index);
-    mesh.allocateVertices(count);
-    mesh.allocateNormals(0); // count
-    mesh.allocateColors(count);
-
-    for (unsigned int i = 0; i < count; ++i) {
-        tr.getRoomVertex(index, i, xyz, rgba);
-
-        mesh.setVertex(i, xyz[0], xyz[1], xyz[2]);
-        mesh.setColor(i, rgba);
-    }
-
-    // Mongoose 2002.06.09, Setup allocation of meshes and polygons
-    // Counters ( Textured polygon lists are allocated per texture)
-    //          ( Textures are mapped to these meshes )
-    int triangle_counter[TextureLimit];
-    int triangle_counter_alpha[TextureLimit];
-    int rectangle_counter[TextureLimit];
-    int rectangle_counter_alpha[TextureLimit];
-    int tris_mesh_map[TextureLimit];
-    int rect_mesh_map[TextureLimit];
-
-    for (unsigned int i = 0; i < TextureLimit; ++i) {
-        triangle_counter[i]        = 0;
-        triangle_counter_alpha[i]  = 0;
-        rectangle_counter[i]       = 0;
-        rectangle_counter_alpha[i] = 0;
-
-        tris_mesh_map[i] = -1;
-        rect_mesh_map[i] = -1;
-    }
-
-    unsigned int numTris = 0;
-    unsigned int numQuads = 0;
-
-    int texture;
-    unsigned int r, t, q, v;
-    unsigned int indices[4];
-    float texCoords[8];
-
-    count = tr.getRoomTriangleCount(index);
-
-    // Mongoose 2002.08.15, Presort by alpha and texture and setup mapping
-    for (t = 0; t < count; ++t) {
-        tr.getRoomTriangle(index, t,
-                           indices, texCoords, &texture, &flags);
-
-        if (texture > (int)TextureLimit) {
-            getLog() << "Handling bad room[" << index << "].tris["
-                     << t << "].texture = " << texture << Log::endl;
-            texture = TextureLimit - 1;
-        }
-
-        // Counters set up polygon allocation
-        if (flags & tombraiderFace_Alpha ||
-            flags & tombraiderFace_PartialAlpha) {
-            triangle_counter_alpha[texture] += 1;
-        } else {
-            triangle_counter[texture] += 1;
-        }
-
-        // Counter sets up texture id to mesh id mapping
-        if (tris_mesh_map[texture] == -1) {
-            tris_mesh_map[texture] = ++numTris;
-        }
-    }
-
-    count = tr.getRoomRectangleCount(index);
-
-    for (r = 0; r < count; ++r) {
-        tr.getRoomRectangle(index, r,
-                            indices, texCoords, &texture, &flags);
-
-        if (texture > (int)TextureLimit) {
-            getLog() << "Handling bad room[" << index << "].quad["
-                     << r << "].texture = " << texture << Log::endl;
-            texture = TextureLimit - 1;
-        }
-
-        if (flags & tombraiderFace_Alpha ||
-            flags & tombraiderFace_PartialAlpha) {
-            rectangle_counter_alpha[texture] += 1;
-        } else {
-            rectangle_counter[texture] += 1;
-        }
-
-        if (rect_mesh_map[texture] == -1) {
-            rect_mesh_map[texture] = ++numQuads;
-        }
-    }
-
-    // Allocate indexed polygon meshes
-    mesh.allocateTriangles(numTris);
-    mesh.allocateRectangles(numQuads);
-
-    for (unsigned int i = 0, j = 0; i < TextureLimit; ++i) {
-        if (tris_mesh_map[i] > 0) {
-            j = tris_mesh_map[i] - 1;
-
-            t = triangle_counter[i];
-
-            mesh.mTris[j].texture = i;
-#ifdef MULTITEXTURE
-            mesh.mTris[j].bumpmap = gMapTex2Bump[i];
-#endif
-            mesh.mTris[j].cnum_triangles = 0;
-            mesh.mTris[j].num_triangles = 0;
-            mesh.mTris[j].cnum_alpha_triangles = 0;
-            mesh.mTris[j].num_alpha_triangles = 0;
-            mesh.mTris[j].triangles = 0x0;
-            mesh.mTris[j].alpha_triangles = 0x0;
-            mesh.mTris[j].texcoors = 0x0;
-            mesh.mTris[j].texcoors2 = 0x0;
-
-            if (t > 0) {
-                mesh.mTris[j].num_triangles = t;
-                mesh.mTris[j].triangles = new unsigned int[t * 3];
-                mesh.mTris[j].num_texcoors = t * 3;
-                mesh.mTris[j].texcoors = new float *[t * 3];
-                for (unsigned int tmp = 0; tmp < (t * 3); tmp++)
-                    mesh.mTris[j].texcoors[tmp] = new float[2];
-            }
-
-            t = triangle_counter_alpha[i];
-
-            if (t > 0) {
-                mesh.mTris[j].num_alpha_triangles = t;
-                mesh.mTris[j].alpha_triangles = new unsigned int[t * 3];
-                mesh.mTris[j].num_texcoors2 = t * 3;
-                mesh.mTris[j].texcoors2 = new float *[t * 3];
-                for (unsigned int tmp = 0; tmp < (t * 3); tmp++)
-                    mesh.mTris[j].texcoors2[tmp] = new float[2];
-            }
-        }
-
-        ///////////////////////////////////////////
-
-        if (rect_mesh_map[i] > 0) {
-            j = rect_mesh_map[i] - 1;
-
-            r = rectangle_counter[i];
-
-            mesh.mQuads[j].texture = i;
-#ifdef MULTITEXTURE
-            mesh.mQuads[j].bumpmap = gMapTex2Bump[i];
-#endif
-            mesh.mQuads[j].cnum_quads = 0;
-            mesh.mQuads[j].num_quads = 0;
-            mesh.mQuads[j].cnum_alpha_quads = 0;
-            mesh.mQuads[j].num_alpha_quads = 0;
-            mesh.mQuads[j].quads = 0x0;
-            mesh.mQuads[j].alpha_quads = 0x0;
-            mesh.mQuads[j].texcoors = 0x0;
-            mesh.mQuads[j].texcoors2 = 0x0;
-
-            if (r > 0) {
-                mesh.mQuads[j].num_quads = r;
-                mesh.mQuads[j].quads = new unsigned int[r * 4];
-                mesh.mQuads[j].num_texcoors = r * 4;
-                mesh.mQuads[j].texcoors = new float *[r * 4];
-                for (unsigned int tmp = 0; tmp < (r * 4); tmp++)
-                    mesh.mQuads[j].texcoors[tmp] = new float[2];
-            }
-
-            r = rectangle_counter_alpha[i];
-
-            if (r > 0) {
-                mesh.mQuads[j].num_alpha_quads = r;
-                mesh.mQuads[j].alpha_quads = new unsigned int[r * 4];
-                mesh.mQuads[j].num_texcoors2 = r * 4;
-                mesh.mQuads[j].texcoors2 = new float *[r * 4];
-                for (unsigned int tmp = 0; tmp < (r * 4); tmp++)
-                    mesh.mQuads[j].texcoors2[tmp] = new float[2];
-            }
-        }
-    }
-
-    // Generate textured triangles
-    count = tr.getRoomTriangleCount(index);
-
-    for (t = 0; t < count; ++t) {
-        tr.getRoomTriangle(index, t,
-                           indices, texCoords, &texture, &flags);
-
-        unsigned int j = tris_mesh_map[texture] - 1;
-
-        // Setup per vertex
-        for (unsigned int i = 0; i < 3; ++i) {
-            // Get vertex index {(0, a), (1, b), (2, c)}
-            v = indices[i];
-
-            if ((flags & tombraiderFace_Alpha ||
-                 flags & tombraiderFace_PartialAlpha) &&
-                mesh.mTris[j].num_alpha_triangles > 0) {
-                q = mesh.mTris[j].cnum_alpha_triangles * 3 + i;
-
-                mesh.mTris[j].alpha_triangles[q] = v;
-
-                mesh.mTris[j].texcoors2[q][0] = texCoords[i * 2];
-                mesh.mTris[j].texcoors2[q][1] = texCoords[i * 2 + 1];
-            } else if (mesh.mTris[j].num_triangles > 0) {
-                q = mesh.mTris[j].cnum_triangles * 3 + i;
-
-                mesh.mTris[j].triangles[q] = v;
-
-                mesh.mTris[j].texcoors[q][0] = texCoords[i * 2];
-                mesh.mTris[j].texcoors[q][1] = texCoords[i * 2 + 1];
-            }
-
-            // Partial alpha hack
-            if (flags & tombraiderFace_PartialAlpha) {
-                //mesh.colors[v].rgba[3] = 0.45;
-            }
-        }
-
-        if (flags & tombraiderFace_Alpha ||
-            flags & tombraiderFace_PartialAlpha) {
-            mesh.mTris[j].cnum_alpha_triangles++;
-        } else {
-            mesh.mTris[j].cnum_triangles++;
-        }
-    }
-
-    // Generate textured quads
-    count = tr.getRoomRectangleCount(index);
-
-    for (r = 0; r < count; ++r) {
-        tr.getRoomRectangle(index, r,
-                            indices, texCoords, &texture, &flags);
-
-        if (texture > (int)TextureLimit) {
-            texture = TextureLimit - 1;
-        }
-
-        unsigned int j = rect_mesh_map[texture] - 1;
-
-        if (mesh.mQuads[j].num_quads <= 0 &&
-            mesh.mQuads[j].num_alpha_quads <= 0)
-            continue;
-
-        // Setup per vertex
-        for (unsigned int i = 0; i < 4; ++i) {
-            // Get vertex index {(0, a), (1, b), (2, c), (3, d)}
-            v = indices[i];
-
-            if ((flags & tombraiderFace_Alpha ||
-                 flags & tombraiderFace_PartialAlpha) &&
-                mesh.mQuads[j].num_alpha_quads > 0) {
-                q = mesh.mQuads[j].cnum_alpha_quads * 4 + i;
-
-                mesh.mQuads[j].alpha_quads[q] = v;
-
-                mesh.mQuads[j].texcoors2[q][0] = texCoords[i * 2];
-                mesh.mQuads[j].texcoors2[q][1] = texCoords[i * 2 + 1];
-            } else if (mesh.mQuads[j].num_quads > 0) {
-                q = mesh.mQuads[j].cnum_quads * 4 + i;
-
-                mesh.mQuads[j].quads[q] = v;
-
-                mesh.mQuads[j].texcoors[q][0] = texCoords[i * 2];
-                mesh.mQuads[j].texcoors[q][1] = texCoords[i * 2 + 1];
-            }
-
-            // Partial alpha hack
-            if (flags & tombraiderFace_PartialAlpha) {
-                //rRoom->mesh.colors[v].rgba[3] = 0.45;
-            }
-        }
-
-        if (flags & tombraiderFace_Alpha ||
-            flags & tombraiderFace_PartialAlpha) {
-            mesh.mQuads[j].cnum_alpha_quads++;
-        } else {
-            mesh.mQuads[j].cnum_quads++;
-        }
-    }
-#endif
-}
-
 #define EMPTY_VECTOR(x)     \
 while (!x.empty()) {        \
     delete x[x.size() - 1]; \
 }
 
 void Room::display(bool alpha) {
+    /*
     glPushMatrix();
     //LightingSetup();
 
     getTextureManager().bindTextureId(TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
 
-    if ((!alpha) && getRender().getMode() == Render::modeWireframe) {
+    if ((!alpha) && Render::getMode() == RenderMode::Wireframe) {
         glLineWidth(2.0);
         glColor3ubv(RED);
 
         glLineWidth(1.0);
     }
 
-    if (getRender().getMode() == Render::modeWireframe && (!alpha)) {
+    if (Render::getMode() == RenderMode::Wireframe && (!alpha)) {
         bbox.display(true, RED, GREEN);
     }
 
     // Reset since GL_MODULATE used, reset to WHITE
     glColor3ubv(WHITE);
 
-    switch (getRender().getMode()) {
-        case Render::modeWireframe:
+    switch (Render::getMode()) {
+        case RenderMode::Wireframe:
             mesh.mMode = Mesh::MeshModeWireframe;
             break;
-        case Render::modeSolid:
+        case RenderMode::Solid:
             mesh.mMode = Mesh::MeshModeSolid;
             break;
         default:
     glPopMatrix();
 
     // Draw other room meshes and sprites
-    if (alpha || (getRender().getMode() == Render::modeWireframe)
-        || (getRender().getMode() == Render::modeSolid)) {
-        sortModels();
+    if (alpha || (Render::getMode() == RenderMode::Wireframe)
+        || (Render::getMode() == RenderMode::Solid)) {
+        //sortModels(); // TODO
         for (unsigned int i = 0; i < sizeModels(); i++)
             getModel(i).display();
 
         for (unsigned int i = 0; i < sizeSprites(); i++)
             getSprite(i).display();
     }
+    */
 }
 
 bool Room::isWall(unsigned long sector) {
 }
 
 long Room::getSector(float x, float z, float* floor, float* ceiling) {
-    assert(floor != NULL);
-    assert(ceiling != NULL);
+    assert(floor != nullptr);
+    assert(ceiling != nullptr);
 
     long sector = getSector(x, z);
 
 
 int Room::getAdjoiningRoom(float x, float y, float z,
                            float x2, float y2, float z2) {
-    float intersect[3], p1[3], p2[3];
     float vertices[4][3];
-
-    p1[0] = x;  p1[1] = y;  p1[2] = z;
-    p2[0] = x2; p2[1] = y2; p2[2] = z2;
+    glm::vec3 orig(x, y, z);
+    glm::vec3 dir(x2 - x, y2 - y, z2 - z);
+    glm::vec3 intersect;
+    glm::vec3 verts[4];
 
     for (unsigned long i = 0; i < portals.size(); i++) {
         portals.at(i)->getVertices(vertices);
-        if (intersectionLinePolygon(intersect, p1, p2, //4,
-                                    vertices))
+        verts[0] = glm::vec3(vertices[0][0], vertices[0][1], vertices[0][2]);
+        verts[1] = glm::vec3(vertices[1][0], vertices[1][1], vertices[1][2]);
+        verts[2] = glm::vec3(vertices[2][0], vertices[2][1], vertices[2][2]);
+        verts[3] = glm::vec3(vertices[3][0], vertices[3][1], vertices[3][2]);
+
+        if ((glm::intersectLineTriangle(orig, dir, verts[0], verts[1], verts[2], intersect))
+            || (glm::intersectLineTriangle(orig, dir, verts[0], verts[3], verts[1], intersect)))
             return portals.at(i)->getAdjoiningRoom();
     }
 
     models.push_back(s);
 }
 
-void Room::sortModels() {
-    std::sort(models.begin(), models.end(), StaticModel::compare);
-}
-
 unsigned long Room::sizeLights() {
     return lights.size();
 }

src/RoomData.cpp

  */
 
 #include "global.h"
-#include "Render.h"
 #include "SkeletalModel.h"
 #include "World.h"
 #include "RoomData.h"
 }
 
 void BoundingBox::display(bool points, const unsigned char c1[4], const unsigned char c2[4]) {
+    /*
     // Bind before entering now
     //glBindTexture(GL_TEXTURE_2D, 1);
     glPointSize(4.0);
 
     glPointSize(1.0);
     //glLineWidth(1.0);
+    */
 }
 
 // ----------------------------------------------------------------------------
 
-Light::Light(TombRaider& tr, unsigned int room, unsigned int index) {
-    unsigned int lightFlags, lightType;
-
-    tr.getRoomLight(room, index, pos, color,
-                    dir, &att, &cutoff, &lightType, &lightFlags);
-
-    switch (lightType) {
-        case tombraiderLight_typeDirectional:
-            type = Light::typeDirectional;
-            break;
-        case tombraiderLight_typeSpot:
-            type = Light::typeSpot;
-            break;
-        case tombraiderLight_typePoint:
-        default:
-            type = Light::typePoint;
-    }
-
-    //! \todo Light flags?
-}
-
 void Light::getPos(float p[4]) {
     p[0] = pos[0];
     p[1] = pos[1];
 
 // ----------------------------------------------------------------------------
 
-StaticModel::StaticModel(TombRaider& tr, unsigned int room, unsigned int i) {
-    tr.getRoomModel(room, i, &index, pos, &yaw);
-}
-
 void StaticModel::display() {
     StaticMesh& mesh = getWorld().getStaticMesh(index);
 
-    if (!getRender().isVisible(pos[0], pos[1], pos[2], mesh.getRadius()))
-        return;
+    //if (!getRender().isVisible(pos[0], pos[1], pos[2], mesh.getRadius()))
+    //    return;
 
+    /*
     glPushMatrix();
     glTranslated(pos[0], pos[1], pos[2]);
     glRotated(yaw, 0, 1, 0);
     mesh.display();
     glPopMatrix();
-}
-
-bool StaticModel::operator<(const StaticModel& other) {
-    float distA, distB;
-    distA = getRender().getDistToSphereFromNear(pos[0],
-            pos[1], pos[2], 128.0f);
-    distB = getRender().getDistToSphereFromNear(other.pos[0],
-            other.pos[1], other.pos[2], 128.0f);
-    return (distA < distB);
-}
-
-bool StaticModel::compare(StaticModel* a, StaticModel* b) {
-    return (*b) < (*a);
+    */
 }
 
 // ----------------------------------------------------------------------------
 
-Portal::Portal(TombRaider& tr, unsigned int room, unsigned int index, Matrix& transform) {
-    float portalVertices[12];
-    tr.getRoomPortal(room, index, &adjoiningRoom, normal, portalVertices);
-    for (unsigned int j = 0; j < 4; ++j) {
-        vertices[j][0] = portalVertices[j * 3];
-        vertices[j][1] = portalVertices[j * 3 + 1];
-        vertices[j][2] = portalVertices[j * 3 + 2];
-
-        // Relative coors in vis portals
-        transform.multiply3v(vertices[j], vertices[j]);
-    }
-}
-
-Portal::Portal(float vert[4][3], float norm[3], int adj) {
+Portal::Portal(glm::vec3 vert[4], float norm[3], int adj) {
     for (unsigned int i = 0; i < 4; i++) {
         for (unsigned int j = 0; j < 3; j++) {
             vertices[i][j] = vert[i][j];
 
 // ----------------------------------------------------------------------------
 
-Sector::Sector(TombRaider& tr, unsigned int room, unsigned int index) {
-    unsigned int sectorFlags;
-    int floorDataIndex, boxIndex, roomBelow, roomAbove;
-
-    tr.getRoomSector(room, index, &sectorFlags,
-                     &ceiling, &floor, &floorDataIndex, &boxIndex,
-                     &roomBelow, &roomAbove);
-
-    wall = (sectorFlags & tombraiderSector_wall);
-}
-
 float Sector::getFloor() {
     return floor;
 }

src/SkeletalModel.cpp

 
 #include "global.h"
 #include "Log.h"
-#include "Render.h"
 #include "SkeletalModel.h"
 #include "World.h"
 
     }
 }
 
-BoneTag::BoneTag(TombRaider& tr, unsigned int index, unsigned int i, unsigned int* l,
-                 unsigned int frame_offset) {
-    tr2_moveable_t* moveable = tr.Moveable();
-    tr2_meshtree_t* meshtree = tr.MeshTree();
-    unsigned short* frame = tr.Frame();
-
-    off[0] = 0.0f;
-    off[1] = 0.0f;
-    off[2] = 0.0f;
-    flag = 0x00;
-    rot[0] = 0.0f;
-    rot[1] = 0.0f;
-    rot[2] = 0.0f;
-    mesh = moveable[index].starting_mesh + i;
-
-    // Setup offsets to produce skeleton
-    if (i == 0) {
-        // Always push tag[0], this isn't really used either
-        flag = 0x02;
-    } else { // Nonprimary tag - position relative to first tag
-
-        // Hack: moveable[index].mesh_tree is a byte offset
-        //       into mesh_tree[], so we have to convert to index
-        int* tree = (int*)(void*)meshtree;
-        tr2_meshtree_t* mesh_tree = (tr2_meshtree_t*)(tree
-                                    + moveable[index].mesh_tree + ((i - 1) * 4));
-
-        off[0] = mesh_tree->x;
-        off[1] = mesh_tree->y;
-        off[2] = mesh_tree->z;
-        flag = (char)mesh_tree->flags;
-    }
-
-    // Setup tag rotations
-    tr.computeRotationAngles(&frame, &frame_offset, l, rot, rot + 1, rot + 2);
-}
-
 void BoneTag::display() {
     if (getWorld().sizeMesh() > 0)
         getWorld().getMesh(mesh).drawSolid(); // TODO ?
         pos[i] = p[i];
 }
 
-BoneFrame::BoneFrame(TombRaider& tr, unsigned int index, unsigned int frame_offset) {
-    tr2_moveable_t* moveable = tr.Moveable();
-    unsigned short* frame = tr.Frame();
-
-    pos[0] = (short)frame[frame_offset + 6];
-    pos[1] = (short)frame[frame_offset + 7];
-    pos[2] = (short)frame[frame_offset + 8];
-
-    unsigned int l = 9; // First angle offset in this Frame
-
-    for (unsigned int i = 0; i < moveable[index].num_meshes; i++)
-        tag.push_back(new BoneTag(tr, index, i, &l, frame_offset));
-}
-
 BoneFrame::~BoneFrame() {
     for (unsigned long i = 0; i < tag.size(); i++)
         delete tag[i];
     rate = r;
 }
 
-AnimationFrame::AnimationFrame(TombRaider& tr, unsigned int index, int a,
-                               unsigned int* frame_offset, int frame_step) {
-    tr2_moveable_t* moveable = tr.Moveable();
-    tr2_animation_t* animation = tr.Animation();
-
-    unsigned int frame_count = (animation[a].frame_end - animation[a].frame_start) + 1;
-    rate = animation[a].frame_rate;
-
-    for (unsigned int f = 0; f < frame_count; f++, *frame_offset += frame_step) {
-        // HACK: Lara's ObjectID is 315, but her meshes start at 0, so make a
-        // quick substitution (so she doesn't appear as a bunch of thighs)
-        if ((index == 0) && (tr.Engine() == TR_VERSION_3)) {
-            for (int j = 0; (j < (int)tr.NumMoveables()) && (index == 0); j++) {
-                if (moveable[j].object_id == 315)
-                    index = j;
-            }
-        }
-
-        // Fix Lara in TR4
-        // Body is ItemID 8, joints are ItemID 9
-        // (TR4 demo: body is ItemID 10, joints are ItemID 11)
-        if ((index == 0) && (tr.Engine() == TR_VERSION_4)) {
-            for (int j = 0; (j < (int)tr.NumMoveables()) && (index == 0); j++) {
-                if (moveable[j].object_id == 8)
-                    index = j;
-            }
-        } else if ((moveable[index].object_id == 8) && (tr.Engine() == TR_VERSION_4)) {
-            // KLUDGE to do "skinning"
-            index = 0;
-            for (int j = 0; (j < (int)tr.NumMoveables()) && (index == 0); j++) {
-                if (moveable[j].object_id == 9)
-                    index = j;
-            }
-        }
-
-        if (*frame_offset > tr.NumFrames()) {
-            getLog() << "WARNING: Bad animation frame " << *frame_offset
-                     << " > " << tr.NumFrames() << " (" << index << "." << a << ")"
-                     << Log::endl;
-            return;
-        }
-
-        frame.push_back(new BoneFrame(tr, index, *frame_offset));
-    }
-}
-
 AnimationFrame::~AnimationFrame() {
     for (unsigned long i = 0; i < frame.size(); i++)
         delete frame[i];
     id = i;
 }
 
-SkeletalModel::SkeletalModel(TombRaider& tr, unsigned int index, int objectId) {
-    tr2_moveable_t* moveable = tr.Moveable();
-    tr2_animation_t* anim = tr.Animation();
-    tr2_mesh_t* mesh = tr.Mesh();
-
-    id = objectId;
-
-    // Gather more info if this is lara
-    if (id == 0) {
-        // Only TR4 lara has 2 layer bone tags/meshes per bone frame
-        tr4Overlay = (tr.Engine() == TR_VERSION_4);
-        ponytailId = 0;
-    } else {
-        tr4Overlay = false;
-        ponytailId = -1;
-    }
-
-    switch (tr.Engine()) {
-        case TR_VERSION_4:
-            if (moveable[index].object_id == 30) {
-                ponytailId = getWorld().sizeSkeletalModel(); //! \fixme Why is this even needed?
-                ponytailMeshId = moveable[index].starting_mesh;
-                ponytailNumMeshes = ((moveable[index].num_meshes > 0) ?
-                                     moveable[index].num_meshes : 0);
-                ponytailAngle = -90.0f;
-                ponytail[0] = -3;
-                ponytail[1] = -22;
-                ponytail[2] = -20;
-                ponyOff = 40;
-                ponyOff2 = 32;
-                pigtails = false;
-
-                // Try to guess pigtails by looking for certian num verts in head
-                if (mesh[moveable[0].starting_mesh].num_vertices > 80) {
-                    pigtails = true;
-                    ponyOff -= 20;
-                    ponytail[1] -= 32;
-                }
-
-                getRender().setFlags(Render::fRenderPonytail);
-                getLog() << "Found known ponytail" << Log::endl;
-            }
-            break;
-
-        case TR_VERSION_1:
-        case TR_VERSION_2:
-        case TR_VERSION_3:
-        case TR_VERSION_5:
-        case TR_VERSION_UNKNOWN:
-            if (moveable[index].object_id == 2) {
-                ponytailId = getWorld().sizeSkeletalModel(); //! \fixme Why is this even needed?
-                ponytailMeshId = moveable[index].starting_mesh;
-                ponytailNumMeshes = ((moveable[index].num_meshes > 0) ?
-                                     moveable[index].num_meshes : 0);
-                ponytailAngle = -90.0f;
-                ponytail[0] = 0;
-                ponytail[1] = -20;
-                ponytail[2] = -20;
-                ponyOff = 40;
-                ponyOff2 = 0;
-
-                getRender().setFlags(Render::fRenderPonytail);
-                getLog() << "Found ponytail?" << Log::endl;
-            }
-            break;
-    }
-
-    // Animations
-    int a = moveable[index].animation;
-    unsigned int frame_offset = anim[a].frame_offset / 2;
-    int frame_step = anim[a].frame_size;
-
-    int frame_cycle = 0;
-
-    if (a >= (int)tr.NumAnimations())
-        a = tr.NumFrames() - frame_offset; //! \fixme Couldn't a be already used out of range?!
-    else
-        a = (anim[a].frame_offset / 2) - frame_offset; //! \fixme Same as a = 0; ??
-
-    if (frame_step != 0) // prevent divide-by-zero errors
-        a /= frame_step;
-
-    if (a != 0)
-        frame_offset += frame_step * (frame_cycle % a);
-
-    if (a < 0) {
-        getLog() << "Invalid animation data for model " << index << ". Skip!" << Log::endl;
-        return;
-    } else {
-        for (; a < tr.getNumAnimsForMoveable(index); a++) {
-            animation.push_back(new AnimationFrame(tr, index, a, &frame_offset, frame_step));
-
-            if (frame_offset > tr.NumFrames())
-                return;
-
-            frame_offset = anim[a].frame_offset / 2;
-            frame_step = anim[a].frame_size;
-        }
-    }
-}
-
 SkeletalModel::~SkeletalModel() {
     for (unsigned long i = 0; i < animation.size(); i++)
         delete animation[i];
 }
 
 void SkeletalModel::display(unsigned long aframe, unsigned long bframe) {
+    /*
     assert(aframe < size());
     assert(bframe < get(aframe).size());
 
             glRotatef(rot[2], 0, 0, 1);
         }
 
-        // Draw layered lara in TR4 (2 meshes per tag)
-        if (tr4Overlay) {
-            BoneFrame& boneframe2 = get(0).get(0); //! \fixme Woot?
-            if (a < boneframe2.size())
-                boneframe2.get(a).display();
-        }
-
-        if (getRender().getFlags() & Render::fRenderPonytail) {
-            if ((ponytailId > 0) && (a == 14)) {
-                glPushMatrix();
-
-                // Mongoose 2002.08.30, TEST to align offset
-                glTranslatef(ponytail[0], ponytail[1], ponytail[2]);
-                glRotatef(ponytailAngle, 1, 0, 0);
-
-                // HACK: To fill TR4 void between ponytail/head
-                //   since no vertex welds are implemented yet
-                if (tr4Overlay)
-                    glScalef(1.20f, 1.20f, 1.20f);
-
-#ifdef EXPERIMENTAL_NON_ITEM_RENDER
-                getWorld().getSkeletalModel(ponytail).display(0, 0);
-#else
-                for (unsigned int i = 0; i < ponytailNumMeshes; i++) {
-                    glPushMatrix();
-
-                    if (i > 0) {
-                        glRotatef(randomNum(-8.0f, -10.0f), 1, 0, 0);
-                        glRotatef(randomNum(-5.0f, 5.0f), 0, 1, 0);
-                        glRotatef(randomNum(-5.0f, 5.0f), 0, 0, 1);
-                        glTranslatef(0.0, 0.0, ponyOff);
-                    }
-
-                    if (pigtails) {
-                        glPushMatrix();
-                        glTranslatef(ponyOff2, 0.0, 0.0);
-                        getWorld().getStaticMesh(ponytailMeshId + i).display();
-                        glPopMatrix();
-
-                        glPushMatrix();
-                        glTranslatef(-ponyOff2, 0.0, 0.0);
-                        getWorld().getStaticMesh(ponytailMeshId + i).display();
-                        glPopMatrix();
-                    } else {
-                        getWorld().getStaticMesh(ponytailMeshId + i).display();
-                    }
-                }
-
-                for (unsigned int i = 0; i < ponytailNumMeshes; i++)
-                    glPopMatrix();
-#endif
-                glPopMatrix();
-            }
-        }
-
         tag.display();
     }
+    */
 }
 
 int SkeletalModel::getId() {

src/Sprite.cpp

  * \author xythobuz
  */
 
+#include "glm/glm.hpp"
+
 #include "global.h"
 #include "Camera.h"
 #include "Game.h"
     sprites.push_back(s);
 }
 
-// -----------------------
-
-SpriteSequence::SpriteSequence(TombRaider& tr, unsigned int item, unsigned int sequence) {
-    for (int i = 0; i < (-tr.SpriteSequence()[sequence].negative_length); i++)
-        oldsprites.push_back(new Sprite(tr, item, sequence, i));
-}
-
-SpriteSequence::~SpriteSequence() {
-    for (unsigned int i = 0; i < oldsprites.size(); i++)
-        delete oldsprites.at(i);
-}
-
 unsigned long SpriteSequence::size() {
-    if (oldsprites.size() > 0)
-        return oldsprites.size();
-    else
-        return sprites.size();
+    return sprites.size();
 }
 
 Sprite& SpriteSequence::get(unsigned long index) {
-    if (oldsprites.size() > 0) {
-        assert(index < oldsprites.size());
-        return *oldsprites.at(index);
-    } else {
-        assert(index < sprites.size());
-        return sprites.at(index);
-    }
+    assert(index < sprites.size());
+    return sprites.at(index);
 }
 
 // ----------------------------------------------------------------------------
     //radius = width2 / 2.0f;
 }
 
-// -----------------------
-
-Sprite::Sprite(TombRaider& tr, unsigned int room, unsigned int index) {
-    float spriteVertices[12];
-    float spriteTexCoords[8];
-    float posUnused[3];
-
-    tr.getRoomSprite(room, index,
-                     10.0f, &texture, posUnused, spriteVertices, spriteTexCoords);
-
-    for (unsigned int j = 0; j < 12; j++)
-        vertex[j / 3][j % 3] = spriteVertices[j];
-
-    for (unsigned int j = 0; j < 8; j++)
-        texel[j / 2][j % 2] = spriteTexCoords[j];
-
-    //radius = 0.0f;
-}
-
 void Sprite::display() {
-    //if (!getRender().isVisible(pos[0], pos[1], pos[2], radius))
+    /*
+    //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(OR_RAD_TO_DEG(getCamera().getRadianYaw()), 0, 1, 0);
+    glRotated(glm::degrees(Camera::getRadianYaw()), 0, 1, 0);
 
-    switch (getRender().getMode()) {
+    switch (Render::getMode()) {
         // No vertex lighting on sprites, as far as I see in specs
         // So just draw normal texture, no case 2
-        case Render::modeSolid:
+        case RenderMode::Solid:
             glBegin(GL_TRIANGLE_STRIP);
             glColor3f(texel[0][0], texel[0][1], 0.5);
             glVertex3fv(vertex[0]);
             glVertex3fv(vertex[2]);
             glEnd();
             break;
-        case Render::modeWireframe:
+        case RenderMode::Wireframe:
             glColor3ubv(CYAN);
             glBegin(GL_LINE_LOOP);
             glVertex3fv(vertex[0]);
     }
 
     glPopMatrix();
+    */
 }
 
 void Sprite::display(float x, float y, float w, float h) {
+    /*
     float z = 0.0f;
 
     getTextureManager().bindTextureId(texture);
     glVertex3f(x, y + h, z);
 
     glEnd();
+    */
 }
 

src/StaticMesh.cpp

 }
 
 void TexturedTriangle::display(float* vertices, float* colors, float* normals) {
-    assert(vertices != NULL);
+    /*
+    assert(vertices != nullptr);
 
-    if ((getRender().getMode() != Render::modeWireframe)
-        && (getRender().getMode() != Render::modeSolid)) {
+    if ((Render::getMode() != RenderMode::Wireframe)
+        && (Render::getMode() != RenderMode::Solid)) {
         getTextureManager().bindTextureId(texture);
     }
 
     glBegin(GL_TRIANGLES);
 
-    switch (getRender().getMode()) {
-        case Render::modeSolid:
-        case Render::modeVertexLight:
-            if (colors != NULL) {
+    switch (Render::getMode()) {
+        case RenderMode::Solid:
+            //case RenderMode::VertexLight:
+            if (colors != nullptr) {
                 glColor3fv(colors + index[0]);
                 glTexCoord2fv(st);
                 glVertex3fv(vertices + (index[0] * 3));
                 glColor3fv(colors + index[2]);
                 glTexCoord2fv(st + 4);
                 glVertex3fv(vertices + (index[2] * 3));
-            } else if (normals != NULL) {
+            } else if (normals != nullptr) {
                 glNormal3fv(normals + (index[0] * 3));
                 glTexCoord2fv(st);
                 glVertex3fv(vertices + (index[0] * 3));
             }
             break;
 
-        case Render::modeWireframe:
+        case RenderMode::Wireframe:
             glVertex3fv(vertices + (index[0] * 3));
             glVertex3fv(vertices + (index[1] * 3));
             glVertex3fv(vertices + (index[2] * 3));
     }
 
     glEnd();
+    */
 }
 
 // ----------------------------------------------------------------------------
     vertices = colors = normals = nullptr;
 }
 
-#ifdef EXPERIMENTAL
-
-#include <map>
-std::map<unsigned int, unsigned int> gColorTextureHACK;
-
-int setupTextureColor(float* colorf) {
-    unsigned char color[4];
-    unsigned int colorI;
-    unsigned int texture;
-
-    color[0] = (unsigned char)(colorf[0] * 255.0f);
-    color[1] = (unsigned char)(colorf[1] * 255.0f);
-    color[2] = (unsigned char)(colorf[2] * 255.0f);
-    color[3] = (unsigned char)(colorf[3] * 255.0f);
-
-    ((unsigned char*)(&colorI))[3] = color[0];
-    ((unsigned char*)(&colorI))[2] = color[1];
-    ((unsigned char*)(&colorI))[1] = color[2];
-    ((unsigned char*)(&colorI))[0] = color[3];
-
-    try {
-        texture = gColorTextureHACK.at(colorI);
-    } catch (...) {
-        unsigned char* image = generateColorTexture(color, 32, 32, 32);
-        texture = getTextureManager().loadBufferSlot(image, 32, 32, RGBA, 32);
-        delete [] image;
-    }
-
-    return texture;
-}
-
-#endif
-
-StaticMesh::StaticMesh(TombRaider& tr, unsigned int index) {
-    int count, texture;
-    int vertexIndices[6];
-    float st[12];
-    float color[4];
-    unsigned short transparency;
-
-    if (!tr.isMeshValid(index)) {
-        dontshow = true;
-        return;
-    } else {
-        dontshow = false;
-    }
-
-    // Mongoose 2002.08.30, Testing support for 'shootable' models ( traceable )
-    tr.getMeshCollisionInfo(index, center, &radius);
-
-    //! \fixme Arrays don't work either  =)
-    // Mesh geometery, colors, etc
-    tr.getMeshVertexArrays(index,
-                           &vertexCount, &vertices,
-                           &normalCount, &normals,
-                           &colorCount,  &colors);
-
-    // Textured Triangles
-    count = tr.getMeshTexturedTriangleCount(index);
-    for (int i = 0; i < count; i++) {
-        tr.getMeshTexturedTriangle(index, i,
-                                   vertexIndices, st,
-                                   &texture, &transparency);
-        triangles.push_back(
-            new TexturedTriangle(vertexIndices, st, texture, transparency));
-    }
-
-    // Coloured Triangles
-    count = tr.getMeshColoredTriangleCount(index);
-    for (int i = 0; i < count; i++) {
-        tr.getMeshColoredTriangle(index, i,
-                                  vertexIndices, color);
-        st[0] = color[0];
-        st[1] = color[1];
-        st[2] = color[2];
-        st[3] = color[3];
-        st[4] = 1.0;
-        st[5] = 1.0;
-
-#ifdef EXPERIMENTAL
-        texture = setupTextureColor(color);
-#else
-        texture = 0; // White texture
-#endif
-        transparency = 0;
-
-        triangles.push_back(
-            new TexturedTriangle(vertexIndices, st, texture, transparency));
-    }
-
-    // Textured Rectangles
-    count = tr.getMeshTexturedRectangleCount(index);
-    for (int i = 0; i < count; i++) {
-        tr.getMeshTexturedRectangle(index, i,
-                                    vertexIndices, st,
-                                    &texture, &transparency);
-        triangles.push_back(
-            new TexturedTriangle(vertexIndices, st, texture, transparency));
-        triangles.push_back(
-            new TexturedTriangle(vertexIndices + 3, st + 6, texture, transparency));
-    }
-
-    // Coloured Rectangles
-    count = tr.getMeshColoredRectangleCount(index);
-    for (int i = 0; i < count; i++) {
-        tr.getMeshColoredRectangle(index, i,
-                                   vertexIndices, color);
-
-        st[0] = color[0];
-        st[1] = color[1];
-        st[2] = color[2];
-        st[3] = color[3];
-        st[4] = 1.0;
-        st[5] = 1.0;
-
-#ifdef EXPERIMENTAL
-        texture = setupTextureColor(color);
-#else
-        texture = 0; // White texture
-#endif
-        transparency = 0;
-
-        triangles.push_back(
-            new TexturedTriangle(vertexIndices, st, texture, transparency));
-        triangles.push_back(
-            new TexturedTriangle(vertexIndices + 3, st, texture, transparency));
-    }
-
-    id = mesh = -1;
-}
-
 StaticMesh::~StaticMesh() {
     while (!triangles.empty()) {
         delete triangles.back();
 }
 
 void StaticMesh::display() {
+    /*
     if ((id != -1) && (mesh != -1)) {
         getWorld().getMesh(mesh).drawSolid();
         return;
         //! \fixme 'AMBIENT' -- Mongoose 2002.01.08
         glColor3ubv(WHITE);
 
-        if (getRender().getMode() == Render::modeWireframe)
+        if (Render::getMode() == RenderMode::Wireframe)
             glColor3ubv(WHITE);
 
         getTextureManager().bindTextureId(TEXTURE_WHITE, TextureManager::TextureStorage::SYSTEM);
         for (unsigned int i = 0; i < triangles.size(); i++)
             triangles.at(i)->display(vertices, colors, normals);
     }
+    */
 }
 
 float StaticMesh::getRadius() {

src/TextureManager.cpp

     vertices.push_back(t);
 }
 
-bool TextureTile::isTriangle() {
-    assert(vertices.size() >= 3);
-
-    if (vertices.size() == 3)
-        return true;
-
-    return ((vertices.at(3)->xPixel == 0)
-            && (vertices.at(3)->xCoordinate == 0)
-            && (vertices.at(3)->yPixel == 0)
-            && (vertices.at(3)->yCoordinate == 0));
-}
-
-void TextureTile::display(float x, float y, float w, float h, float z) {
-    getTextureManager().bindTextureId(texture);
-
+void TextureTile::displayRectangle(float a[3], float b[3], float c[3], float d[3]) {
     //! \fixme TR Rosetta Stone says this, but looks strange?
     /*
     if (attribute == 0) {
     }
     */
 
-    if (isTriangle())
-        displayTriangle(x, y, w, h, z);
-    else
-        displayRectangle(x, y, w, h, z);
-
-    /*
-    if (attribute == 0) {
-        glEnable(GL_BLEND);
-    }
-    */
-}
-
-void TextureTile::displayRectangle(float x, float y, float w, float h, float z) {
-    displayRectangle(Vec3(x, y, z), Vec3(x + w, y, z), Vec3(x + w, y + h, z), Vec3(x, y + h, z));
-}
-
-void TextureTile::displayRectangle(Vec3 a, Vec3 b, Vec3 c, Vec3 d) {
     float xmin = 256.0f, xmax = 0.0f;
     float ymin = 256.0f, ymax = 0.0f;
     for (int i = 0; i < 4; i++) {
         }
     }
 
+    /*
     glBegin(GL_QUADS);
     glTexCoord2f(xmin / 256.0f, ymin / 256.0f);
     glVertex3f(a.x, a.y, a.z);
     glTexCoord2f(xmin / 256.0f, ymax / 256.0f);
     glVertex3f(d.x, d.y, d.z);
     glEnd();
+    */
 }
 
-void TextureTile::displayTriangle(float x, float y, float w, float h, float z) {
-    displayTriangle(Vec3(x, y, z), Vec3(x + w, y, z), Vec3(x + w, y + h, z));
-}
+void TextureTile::displayTriangle(float a[3], float b[3], float c[3]) {
 
-void TextureTile::displayTriangle(Vec3 a, Vec3 b, Vec3 c) {
-    glBegin(GL_TRIANGLE_STRIP);
-    glTexCoord2f(vertices.at(0)->xPixel / 256.0f,
-                 vertices.at(0)->yPixel / 256.0f);
-    glVertex3f(a.x, a.y, a.z);
-    glTexCoord2f(vertices.at(1)->xPixel / 256.0f,
-                 vertices.at(1)->yPixel / 256.0f);
-    glVertex3f(b.x, b.y, b.z);
-    glTexCoord2f(vertices.at(2)->xPixel / 256.0f,
-                 vertices.at(2)->yPixel / 256.0f);
-    glVertex3f(c.x, c.y, c.z);
-    glEnd();
 }
 
 // ----------------------------------------------------------------------------
 }
 
 int TextureManager::initialize() {
+    assert(mTextureIdsGame.size() == 0);
+    assert(mTextureIdsSystem.size() == 0);
+
+    while (mTextureIdsSystem.size() < 2) {
+        unsigned int id;
+        glGenTextures(1, &id);
+        mTextureIdsSystem.push_back(id);
+    }
+
+    return 0;
+}
+
+int TextureManager::initializeSplash() {
     unsigned char* image = generateColorTexture(WHITE, 32, 32, 32);
-    int res = loadBufferSlot(image, 32, 32, RGBA, 32, TextureStorage::SYSTEM, TEXTURE_WHITE);
+    int res = loadBufferSlot(image, 32, 32, ColorMode::RGBA, 32, TextureStorage::SYSTEM, TEXTURE_WHITE, false);
     delete [] image;
     if (res < 0) {
         return -1;
                                    unsigned int width, unsigned int height,
                                    ColorMode mode, unsigned int bpp,
                                    TextureStorage s, int slot, bool filter) {
-    assert(image != NULL);
     assert(width > 0);
     assert(height > 0);
-    assert((mode == GREYSCALE) || (mode == RGB)
-           || (mode == BGR) || (mode == ARGB)
-           || (mode == RGBA) || (mode ==  BGRA));
+    assert((mode == ColorMode::RGB)
+           || (mode == ColorMode::BGR)
+           || (mode == ColorMode::ARGB)
+           || (mode == ColorMode::RGBA)
+           || (mode ==  ColorMode::BGRA));
     assert((bpp == 8) || (bpp == 24) || (bpp == 32));
 
     if (slot == -1)
         getIds(s).push_back(id);
     }
 
+    if (image == nullptr)
+        return slot;
+
     unsigned int glcMode;
     switch (mode) {
-        case GREYSCALE:
-            glcMode = GL_LUMINANCE;
+        case ColorMode::BGR:
+            glcMode = GL_BGR;
             break;
 
-        case BGR:
-            bgr2rgb24(image, width, height);
+        case ColorMode::RGB:
             glcMode = GL_RGB;
             break;
 
-        case RGB:
-            glcMode = GL_RGB;
-            break;
-
-        case ARGB:
+        case ColorMode::ARGB:
             argb2rgba32(image, width, height);
             glcMode = GL_RGBA;
             break;
 
-        case BGRA:
-            bgra2rgba32(image, width, height);
-            glcMode = GL_RGBA;
+        case ColorMode::BGRA:
+            glcMode = GL_BGRA;
             break;
 
-        case RGBA:
+        case ColorMode::RGBA:
             glcMode = GL_RGBA;
             break;
     }
 
-    glColor3ubv(WHITE);
-    glEnable(GL_DEPTH_TEST);
-    glShadeModel(GL_SMOOTH);
     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
     glBindTexture(GL_TEXTURE_2D, getIds(s).at(slot));
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, glcMode, GL_UNSIGNED_BYTE, image);
 
     if (filter) {
-        glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        // Trilinear filtering
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+        glGenerateMipmap(GL_TEXTURE_2D);
     } else {
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     }
 
-    glTexImage2D(GL_TEXTURE_2D, 0, bpp / 8, width, height, 0, glcMode, GL_UNSIGNED_BYTE, image);
-
     return slot;
 }
 
     return getIds(s).size();
 }
 
-void TextureManager::bindTextureId(unsigned int n, TextureStorage s) {
+void TextureManager::bindTextureId(unsigned int n, TextureStorage s, unsigned int unit) {
     assert(n < getIds(s).size());
+    assert(unit < 80); //! \todo Query GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS
 
-    glEnable(GL_TEXTURE_2D);
-    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-
+    glActiveTexture(GL_TEXTURE0 + unit);
     glBindTexture(GL_TEXTURE_2D, getIds(s).at(n));
 }
 
 }
 
 int TextureManager::loadPCX(const char* filename, TextureStorage s, int slot) {
-    assert(filename != NULL);
+    assert(filename != nullptr);
     assert(filename[0] != '\0');
 
     unsigned char* image;
 
 int TextureManager::loadPNG(const char* filename, TextureStorage s, int slot) {
 #ifdef USING_PNG
-    assert(filename != NULL);
+    assert(filename != nullptr);
     assert(filename[0] != '\0');
 
     if (pngCheck(filename) != 0) {
 }
 
 int TextureManager::loadTGA(const char* filename, TextureStorage s, int slot) {
-    assert(filename != NULL);
+    assert(filename != nullptr);
     assert(filename[0] != '\0');
 
     unsigned char* image;
         }
         if (image) {
             id = loadBufferSlot(image, w, h,
-                                (type == 2) ? RGBA : RGB,
+                                (type == 2) ? ColorMode::RGBA : ColorMode::RGB,
                                 (type == 2) ? 32 : 24,
                                 s, slot);
             delete [] image;

src/UI.cpp

     //! \todo Use our own font subsystem instead of this?
     const void* png_data;
     unsigned int png_size;
-    ImGui::GetDefaultFontData(NULL, NULL, &png_data, &png_size);
+    ImGui::GetDefaultFontData(nullptr, nullptr, &png_data, &png_size);
     int tex_x, tex_y, tex_comp;
     void* tex_data = stbi_load_from_memory((const unsigned char*)png_data,
                                            (int)png_size, &tex_x, &tex_y, &tex_comp, 0);
 
-    //! \fixme TODO use proper texture slot
     fontTex = getTextureManager().loadBufferSlot((unsigned char*)tex_data,
-              tex_x, tex_y, RGBA, 32, TextureManager::TextureStorage::SYSTEM, -1, false);
+              tex_x, tex_y, TextureManager::ColorMode::RGBA, 32,
+              TextureManager::TextureStorage::SYSTEM, -1, false);
 
     stbi_image_free(tex_data);
 
 
         ImGui::Separator();
 
+        if (ImGui::CollapsingHeader("Sound Map Player")) {
+            if (!Sound::getEnabled()) {
+                ImGui::Text("Please enable Sound first!");
+                if (ImGui::Button("Enable Sound!")) {
+                    Sound::setEnabled(true);
+                }
+            } else if (Sound::numBuffers() == 0) {
+                ImGui::Text("Please load a level!");
+            } else {
+                static int index = 0;
+                ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.5f);
+                ImGui::SliderInt("##soundslide", &index, 0, SoundManager::sizeSoundMap() - 1);
+                ImGui::PopItemWidth();
+                ImGui::SameLine();
+                if (ImGui::Button("+##soundplus", ImVec2(0, 0), true)) {
+                    if (index < (SoundManager::sizeSoundMap() - 1))
+                        index++;
+                    else
+                        index = 0;
+                }
+                ImGui::SameLine();
+                if (ImGui::Button("-##soundminus", ImVec2(0, 0), true)) {
+                    if (index > 0)
+                        index--;
+                    else
+                        index = SoundManager::sizeSoundMap() - 1;
+                }
+                ImGui::SameLine();
+                if (ImGui::Button("Play##soundplay")) {
+                    SoundManager::playSound(index);
+                }
+
+                ImGui::Text("Index: %d", SoundManager::getIndex(index));
+            }
+        }
+
+        /*
         static bool visibleTex = false;
         static bool visibleTile = false;
         static bool visibleAnim = false;
             }
         }
 
-        if (ImGui::CollapsingHeader("Sound Map Player")) {
-            if (!Sound::getEnabled()) {
-                ImGui::Text("Please enable Sound first!");
-                if (ImGui::Button("Enable Sound!")) {
-                    Sound::setEnabled(true);
-                }
-            } else if (Sound::numBuffers() == 0) {
-                ImGui::Text("Please load a level!");
-            } else {
-                static int index = 0;
-                ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.5f);
-                ImGui::SliderInt("##soundslide", &index, 0, SoundManager::sizeSoundMap() - 1);
-                ImGui::PopItemWidth();
-                ImGui::SameLine();
-                if (ImGui::Button("+##soundplus", ImVec2(0, 0), true)) {
-                    if (index < (SoundManager::sizeSoundMap() - 1))
-                        index++;
-                    else
-                        index = 0;
-                }
-                ImGui::SameLine();
-                if (ImGui::Button("-##soundminus", ImVec2(0, 0), true)) {
-                    if (index > 0)
-                        index--;
-                    else
-                        index = SoundManager::sizeSoundMap() - 1;
-                }
-                ImGui::SameLine();
-                if (ImGui::Button("Play##soundplay")) {
-                    SoundManager::playSound(index);
-                }
-
-                ImGui::Text("Index: %d", SoundManager::getIndex(index));
-            }
-        }
-
         if (ImGui::CollapsingHeader("Sprite Sequence Viewer")) {
             if (getWorld().sizeSprite() <= 0) {
                 ImGui::Text("Please load a level containing sprites!");
                 }
             }
         }
+        */
 
         ImGui::Separator();
 
         if (ImGui::CollapsingHeader("ImGui/Debug UI Help")) {
-            ImGui::TextWrapped("DebugViewer Textures/Textiles/Sprites will be drawn on"
-                               " the left side and scale with the size of this window!");
-            ImGui::Separator();
+            //ImGui::TextWrapped("DebugViewer Textures/Textiles/Sprites will be drawn on"
+            //                   " the left side and scale with the size of this window!");
+            //ImGui::Separator();
             ImGui::ShowUserGuide();
         }
     }
     if (cmd_lists_count == 0)
         return;
 
-    getWindow().glEnter2D();
-
-    glDisable(GL_DEPTH_TEST);
     glEnable(GL_SCISSOR_TEST);
+    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);
+
+    std::vector<glm::vec2> vertices;
+    std::vector<glm::vec2> uvs;
+    std::vector<glm::vec4> colors;
+
+    /*! \fixme Don't copy data
+     * The GL calls and the shaders can probably be slightly altered
+     * to avoid copying all the vertices, uvs and colors again here.
+     */
+
+    for (int i = 0; i < cmd_lists_count; i++) {
+        auto& commands = cmd_lists[i]->commands;
+        auto& buffer = cmd_lists[i]->vtx_buffer;
 
-    glEnableClientState(GL_VERTEX_ARRAY);
-    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-    glEnableClientState(GL_COLOR_ARRAY);
-
-    // Setup texture
-    getTextureManager().bindTextureId(fontTex, TextureManager::TextureStorage::SYSTEM);
-
-    // Render command lists
-    for (int n = 0; n < cmd_lists_count; n++) {
-        const ImDrawList* cmd_list = cmd_lists[n];
-        const unsigned char* vtx_buffer = (const unsigned char*)cmd_list->vtx_buffer.begin();
-        glVertexPointer(2, GL_FLOAT, sizeof(ImDrawVert), (void*)(vtx_buffer));
-        glTexCoordPointer(2, GL_FLOAT, sizeof(ImDrawVert), (void*)(vtx_buffer + 8));
-        glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(ImDrawVert), (void*)(vtx_buffer + 16));
-
-        int vtx_offset = 0;
-        const ImDrawCmd* pcmd_end = cmd_list->commands.end();
-        for (const ImDrawCmd* pcmd = cmd_list->commands.begin(); pcmd != pcmd_end; pcmd++) {
-            glScissor((int)pcmd->clip_rect.x, (int)(ImGui::GetIO().DisplaySize.y - pcmd->clip_rect.w),
-                      (int)(pcmd->clip_rect.z - pcmd->clip_rect.x),
-                      (int)(pcmd->clip_rect.w - pcmd->clip_rect.y));
-            glDrawArrays(GL_TRIANGLES, vtx_offset, pcmd->vtx_count);
-            vtx_offset += pcmd->vtx_count;
+        int offset = 0;
+        for (int n = 0; n < commands.size(); n++) {
+            for (int v = 0; v < commands[n].vtx_count; v++) {
+                vertices.push_back(glm::vec2(buffer[offset + v].pos.x, buffer[offset + v].pos.y));
+                uvs.push_back(glm::vec2(buffer[offset + v].uv.x, buffer[offset + v].uv.y));
+
+                float r, g, b, a;
+                a = ((buffer[offset + v].col & 0xFF000000) >> 24) / 255.0f;
+                b = ((buffer[offset + v].col & 0x00FF0000) >> 16) / 255.0f;
+                g = ((buffer[offset + v].col & 0x0000FF00) >> 8) / 255.0f;
+                r = (buffer[offset + v].col & 0x000000FF) / 255.0f;
+                colors.push_back(glm::vec4(r, g, b, a));
+            }
+
+            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);
+
+            glScissor(commands[n].clip_rect.x,
+                      getWindow().getHeight() - 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);
+
+            glDrawArrays(GL_TRIANGLES, 0, vertices.size());
+
+            vertices.clear();
+            uvs.clear();
+            colors.clear();
         }
     }
 
+    glDisableVertexAttribArray(0);
+    glDisableVertexAttribArray(1);
+    glDisableVertexAttribArray(2);
+
     glEnable(GL_DEPTH_TEST);
     glDisable(GL_SCISSOR_TEST);
-
-    glDisableClientState(GL_VERTEX_ARRAY);
-    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-    glDisableClientState(GL_COLOR_ARRAY);
-
-    getWindow().glExit2D();
 }
 

src/ViewVolume.cpp

-/*!
- * \file include/ViewVolume.h
- * \brief Viewing Volume for culling use
- *
- * Thanks Mark Morley for the article I used to get several algorithms.
- *
- * \author Mongoose
- */
-
-#include <math.h>
-
-#include "global.h"
-#include "ViewVolume.h"
-
-ViewVolume::ViewVolume() {
-    mFrustum[0][0] = mFrustum[0][1] = mFrustum[0][2] = mFrustum[0][3] = 0.0f;
-    mFrustum[1][0] = mFrustum[1][1] = mFrustum[1][2] = mFrustum[1][3] = 0.0f;
-    mFrustum[2][0] = mFrustum[2][1] = mFrustum[2][2] = mFrustum[2][3] = 0.0f;
-    mFrustum[3][0] = mFrustum[3][1] = mFrustum[3][2] = mFrustum[3][3] = 0.0f;
-    mFrustum[4][0] = mFrustum[4][1] = mFrustum[4][2] = mFrustum[4][3] = 0.0f;
-    mFrustum[5][0] = mFrustum[5][1] = mFrustum[5][2] = mFrustum[5][3] = 0.0f;
-}
-
-bool ViewVolume::isPointInFrustum(float x, float y, float z) {
-    for (unsigned int p = 0; p < 6; ++p) {
-        if (mFrustum[p][0] * x + mFrustum[p][1] * y + mFrustum[p][2] * z +
-            mFrustum[p][3] <= 0) {
-            return false;
-        }
-    }
-    return true;
-}
-
-bool ViewVolume::isSphereInFrustum(float x, float y, float z, float radius) {
-    for (unsigned int p = 0; p < 6; ++p) {
-        float d = mFrustum[p][0] * x + mFrustum[p][1] * y + mFrustum[p][2] * z + mFrustum[p][3];
-        if (d <= -radius)
-            return false;
-    }
-    return true;
-}
-
-bool ViewVolume::isBboxInFrustum(float min[3], float max[3]) {
-    for (unsigned int p = 0; p < 6; ++p) {
-        if (mFrustum[p][0] * min[0] +
-            mFrustum[p][1] * min[1] +
-            mFrustum[p][2] * min[2] + mFrustum[p][3] > 0)
-            continue;
-
-        if (mFrustum[p][0] * max[0] +
-            mFrustum[p][1] * max[1] +
-            mFrustum[p][2] * max[2] + mFrustum[p][3] > 0)
-            continue;
-
-        if (mFrustum[p][0] * min[0] +
-            mFrustum[p][1] * max[1] +
-            mFrustum[p][2] * max[2] + mFrustum[p][3] > 0)
-            continue;
-
-        if (mFrustum[p][0] * min[0] +
-            mFrustum[p][1] * min[1] +
-            mFrustum[p][2] * max[2] + mFrustum[p][3] > 0)
-            continue;
-
-        if (mFrustum[p][0] * min[0] +
-            mFrustum[p][1] * max[1] +
-            mFrustum[p][2] * min[2] + mFrustum[p][3] > 0)
-            continue;
-
-        if (mFrustum[p][0] * max[0] +
-            mFrustum[p][1] * min[1] +
-            mFrustum[p][2] * min[2] + mFrustum[p][3] > 0)
-            continue;
-
-        if (mFrustum[p][0] * max[0] +
-            mFrustum[p][1] * max[1] +
-            mFrustum[p][2] * min[2] + mFrustum[p][3] > 0)
-            continue;
-
-        if (mFrustum[p][0] * max[0] +
-            mFrustum[p][1] * min[1] +
-            mFrustum[p][2] * max[2] + mFrustum[p][3] > 0)
-            continue;
-
-        return false;
-    }
-    return true;
-}
-
-float ViewVolume::getDistToSphereFromNear(float x, float y, float z, float radius) {
-    float d = 0.0;
-    for (unsigned int p = 0; p < 6; ++p) {
-        d = mFrustum[p][0] * x + mFrustum[p][1] * y + mFrustum[p][2] * z + mFrustum[p][3];
-        if (d <= -radius)
-            return 0;
-    }
-    return d + radius;
-}
-
-float ViewVolume::getDistToBboxFromNear(const float min[3], const float max[3]) {
-    float center[3];
-    float d, radius;
-
-    midpoint(min, max, center);
-
-    // 5 should be near plane
-    d = (mFrustum[5][0] * center[0] +
-         mFrustum[5][1] * center[1] +
-         mFrustum[5][2] * center[2] +
-         mFrustum[5][3]);
-
-    radius = distance(max, center);
-
-    if (d <= -radius)
-        return 0;
-
-    return d + radius;
-}
-
-void ViewVolume::getFrustum(float frustum[6][4]) {
-    for (unsigned int p = 0; p < 6; ++p) {
-        for (unsigned int i = 0; i < 4; ++i) {
-            frustum[p][i] = mFrustum[p][i];
-        }
-    }
-}
-
-void ViewVolume::getPlane(ViewVolumeSide p, float plane[4]) {
-    for (unsigned int i = 0; i < 4; ++i) {
-        plane[i] =  mFrustum[p][i];
-    }
-}
-
-void ViewVolume::updateFrame(float proj[16], float mdl[16]) {
-    setModel(mdl);
-    setProjection(proj);
-    updateClip();
-    updateFrustum();
-}
-
-void ViewVolume::updateFrame() {
-    updateClip();
-    updateFrustum();
-}
-
-void ViewVolume::setModel(float mdl[16]) {
-    mModel.setMatrix(mdl);
-}
-
-void ViewVolume::setProjection(float proj[16]) {
-    mProjection.setMatrix(proj);
-}
-
-void ViewVolume::updateClip() {
-    mClip = mProjection * mModel;
-}
-
-void ViewVolume::updateFrustum() {
-    float clip[16];
-    float t;
-
-    mClip.getMatrix(clip);
-
-    /* Extract the numbers for the RIGHT plane */
-    mFrustum[0][0] = clip[ 3] - clip[ 0];
-    mFrustum[0][1] = clip[ 7] - clip[ 4];
-    mFrustum[0][2] = clip[11] - clip[ 8];
-    mFrustum[0][3] = clip[15] - clip[12];
-
-    /* Normalize the result */
-    t = sqrtf(mFrustum[0][0] * mFrustum[0][0] +
-              mFrustum[0][1] * mFrustum[0][1] +
-              mFrustum[0][2] * mFrustum[0][2]);
-    mFrustum[0][0] /= t;
-    mFrustum[0][1] /= t;
-    mFrustum[0][2] /= t;
-    mFrustum[0][3] /= t;
-
-    /* Extract the numbers for the LEFT plane */
-    mFrustum[1][0] = clip[ 3] + clip[ 0];
-    mFrustum[1][1] = clip[ 7] + clip[ 4];
-    mFrustum[1][2] = clip[11] + clip[ 8];
-    mFrustum[1][3] = clip[15] + clip[12];
-
-    /* Normalize the result */
-    t = sqrtf(mFrustum[1][0] * mFrustum[1][0] +
-              mFrustum[1][1] * mFrustum[1][1] +
-              mFrustum[1][2] * mFrustum[1][2]);
-    mFrustum[1][0] /= t;
-    mFrustum[1][1] /= t;
-    mFrustum[1][2] /= t;
-    mFrustum[1][3] /= t;
-
-    /* Extract the BOTTOM plane */
-    mFrustum[2][0] = clip[ 3] + clip[ 1];
-    mFrustum[2][1] = clip[ 7] + clip[ 5];
-    mFrustum[2][2] = clip[11] + clip[ 9];
-    mFrustum[2][3] = clip[15] + clip[13];
-
-    /* Normalize the result */
-    t = sqrtf(mFrustum[2][0] * mFrustum[2][0] +
-              mFrustum[2][1] * mFrustum[2][1] +
-              mFrustum[2][2] * mFrustum[2][2]);
-    mFrustum[2][0] /= t;
-    mFrustum[2][1] /= t;
-    mFrustum[2][2] /= t;
-    mFrustum[2][3] /= t;
-
-    /* Extract the TOP plane */
-    mFrustum[3][0] = clip[ 3] - clip[ 1];
-    mFrustum[3][1] = clip[ 7] - clip[ 5];
-    mFrustum[3][2] = clip[11] - clip[ 9];
-    mFrustum[3][3] = clip[15] - clip[13];
-
-    /* Normalize the result */
-    t = sqrtf(mFrustum[3][0] * mFrustum[3][0] +
-              mFrustum[3][1] * mFrustum[3][1] +
-              mFrustum[3][2] * mFrustum[3][2]);
-    mFrustum[3][0] /= t;
-    mFrustum[3][1] /= t;
-    mFrustum[3][2] /= t;
-    mFrustum[3][3] /= t;
-
-    /* Extract the FAR plane */
-    mFrustum[4][0] = clip[ 3] - clip[ 2];
-    mFrustum[4][1] = clip[ 7] - clip[ 6];
-    mFrustum[4][2] = clip[11] - clip[10];
-    mFrustum[4][3] = clip[15] - clip[14];
-
-    /* Normalize the result */
-    t = sqrtf(mFrustum[4][0] * mFrustum[4][0] +
-              mFrustum[4][1] * mFrustum[4][1] +
-              mFrustum[4][2] * mFrustum[4][2]);
-    mFrustum[4][0] /= t;
-    mFrustum[4][1] /= t;
-    mFrustum[4][2] /= t;
-    mFrustum[4][3] /= t;
-
-    /* Extract the NEAR plane */
-    mFrustum[5][0] = clip[ 3] + clip[ 2];
-    mFrustum[5][1] = clip[ 7] + clip[ 6];
-    mFrustum[5][2] = clip[11] + clip[10];
-    mFrustum[5][3] = clip[15] + clip[14];
-
-    /* Normalize the result */
-    t = sqrtf(mFrustum[5][0] * mFrustum[5][0] +
-              mFrustum[5][1] * mFrustum[5][1] +
-              mFrustum[5][2] * mFrustum[5][2]);
-    mFrustum[5][0] /= t;
-    mFrustum[5][1] /= t;
-    mFrustum[5][2] /= t;
-    mFrustum[5][3] /= t;
-}
-

src/commands/CMakeLists.txt

 # Source files
 set (CMD_SRCS ${CMD_SRCS} "Command.cpp")
-set (CMD_SRCS ${CMD_SRCS} "CommandAnimate.cpp")
 set (CMD_SRCS ${CMD_SRCS} "CommandBind.cpp")
 set (CMD_SRCS ${CMD_SRCS} "CommandEngine.cpp")
 set (CMD_SRCS ${CMD_SRCS} "CommandGame.cpp")

src/commands/Command.cpp

 #include "Log.h"
 #include "utils/strings.h"
 #include "commands/Command.h"
-#include "commands/CommandAnimate.h"
 #include "commands/CommandBind.h"
 #include "commands/CommandEngine.h"
 #include "commands/CommandGame.h"
     commands.push_back(std::shared_ptr<Command>(new CommandSet()));
     commands.push_back(std::shared_ptr<Command>(new CommandGet()));
     commands.push_back(std::shared_ptr<Command>(new CommandScreenshot()));
-    commands.push_back(std::shared_ptr<Command>(new CommandAnimate()));
     commands.push_back(std::shared_ptr<Command>(new CommandMove()));
     commands.push_back(std::shared_ptr<Command>(new CommandMode()));
-    commands.push_back(std::shared_ptr<Command>(new CommandRenderflag()));
     commands.push_back(std::shared_ptr<Command>(new CommandPos()));
     commands.push_back(std::shared_ptr<Command>(new CommandViewmodel()));
     commands.push_back(std::shared_ptr<Command>(new CommandPigtail()));

src/commands/CommandAnimate.cpp

-/*!
- * \file src/commands/CommandAnimate.cpp
- * \brief Animate command
- *
- * \author xythobuz
- */
-
-#include "global.h"
-#include "Log.h"
-#include "Game.h"
-#include "Render.h"
-#include "World.h"
-#include "commands/CommandAnimate.h"
-
-std::string CommandAnimate::name() {
-    return "animate";
-}
-
-std::string CommandAnimate::brief() {
-    return "[BOOL|n|p] - Animate models";
-}
-
-void CommandAnimate::printHelp() {
-    getLog() << "animate-Command Usage:" << Log::endl;
-    getLog() << "  animate [n|p|BOOL]" << Log::endl;
-    getLog() << "Where the commands have the following meaning:" << Log::endl;
-    getLog() << "  BOOL to (de)activate animating all models" << Log::endl;
-    getLog() << "  n to step all models to their next animation" << Log::endl;
-    getLog() << "  p to step all models to their previous animation" << Log::endl;
-}
-
-int CommandAnimate::execute(std::istream& args) {
-    if (!getGame().isLoaded()) {
-        getLog() << "Use animate command interactively!" << Log::endl;
-        return -1;
-    }
-
-    if (args.peek() == 'n') {
-        // Step all skeletal models to their next animation
-        if (getRender().getFlags() & Render::fAnimateAllModels) {
-            for (unsigned int i = 0; i < getWorld().sizeEntity(); i++) {
-                Entity& e = getWorld().getEntity(i);
-                SkeletalModel& m = e.getModel();
-                if (e.getAnimation() < (m.size() - 1))
-                    e.setAnimation(e.getAnimation() + 1);
-                else
-                    e.setAnimation(0);
-            }
-        } else {
-            getLog() << "Animations need to be enabled!" << Log::endl;
-        }
-    } else if (args.peek() == 'p') {
-        // Step all skeletal models to their previous animation
-        if (getRender().getFlags() & Render::fAnimateAllModels) {
-            for (unsigned int i = 0; i < getWorld().sizeEntity(); i++) {
-                Entity& e = getWorld().getEntity(i);
-                SkeletalModel& m = e.getModel();
-                if (e.getAnimation() > 0)
-                    e.setAnimation(e.getAnimation() - 1);
-                else if (m.size() > 0)
-                    e.setAnimation(m.size() - 1);
-            }
-        } else {
-            getLog() << "Animations need to be enabled!" << Log::endl;
-        }
-    } else {
-        // Enable or disable animating all skeletal models
-        bool b = false;
-        if (!(args >> b)) {
-            getLog() << "Pass BOOL to animate command!" << Log::endl;
-            return -2;
-        }
-        if (b)
-            getRender().setFlags(Render::fAnimateAllModels);
-        else
-            getRender().clearFlags(Render::fAnimateAllModels);
-        getLog() << (b ? "Animating all models" : "No longer animating all models") << Log::endl;
-    }
-
-    return 0;
-}
-

src/commands/CommandEngine.cpp

 
     renderFrame();
     renderFrame(); // Double buffered
-    getRender().screenShot(filename.c_str());
+    Render::screenShot(filename.c_str());
 
     getMenu().setVisible(false);
     UI::setVisible(true);

src/commands/CommandRender.cpp

 #include "global.h"
 #include "Game.h"
 #include "Log.h"
-#include "RunTime.h"
 #include "Render.h"
 #include "commands/CommandRender.h"
 
     getLog() << "  wireframe" << Log::endl;
     getLog() << "  solid" << Log::endl;
     getLog() << "  texture" << Log::endl;
-    getLog() << "  vertexlight" << Log::endl;
     getLog() << "  titlescreen" << Log::endl;
+    getLog() << "  disabled" << Log::endl;
 
 }
 
     std::string s;
     args >> s;
 
-    if (s.compare("wireframe") == 0) {
-        getRender().setMode(Render::modeWireframe);
+    if (s == "wireframe") {
+        Render::setMode(RenderMode::Wireframe);
         getLog() << "Wireframe mode" << Log::endl;
-    } else if (s.compare("solid") == 0) {
-        getRender().setMode(Render::modeSolid);
+    } else if (s == "solid") {
+        Render::setMode(RenderMode::Solid);
         getLog() << "Solid mode" << Log::endl;
-    } else if (s.compare("texture") == 0) {
-        getRender().setMode(Render::modeTexture);
-        getLog() << "Texture mode" << Log::endl;
-    } else if (s.compare("vertexlight") == 0) {
-        getRender().setMode(Render::modeVertexLight);
-        getLog() << "Vertexlight mode" << Log::endl;
-    } else if (s.compare("titlescreen") == 0) {
-        getRender().setMode(Render::modeLoadScreen);
+    } else if (s == "texture") {
+        Render::setMode(RenderMode::Texture);
+        getLog() << "Texture Mode" << Log::endl;
+    } 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;
     return 0;
 }
 
-// --------------------------------------
-
-std::string CommandRenderflag::name() {
-    return "renderflag";
-}
-
-std::string CommandRenderflag::brief() {
-    return "STRING BOOL - Toggle Render flag";
-}
-
-void CommandRenderflag::printHelp() {
-    getLog() << "renderflag-Command Usage:" << Log::endl;
-    getLog() << "  renderflag STRING BOOL" << Log::endl;
-    getLog() << "Where STRING is one of the following:" << Log::endl;
-    getLog() << "  ralpha" << Log::endl;
-    getLog() << "  entmodel" << Log::endl;
-    getLog() << "  fog" << Log::endl;
-    getLog() << "  light" << Log::endl;
-    getLog() << "  ponytail" << Log::endl;
-}
-
-int CommandRenderflag::execute(std::istream& args) {
-    if (!getRunTime().isRunning()) {
-        getLog() << "Use renderflag-Command interactively!" << Log::endl;
-        return -1;
-    }
-
-    std::string flag;
-    bool b;
-    args >> flag >> b;
-    if (!args) {
-        getLog() << "Pass STRING and BOOL to renderflag command!" << Log::endl;
-        return -2;
-    }
-
-    int f = stringToFlag(flag);
-    if (f == -1) {
-        getLog() << "Unknown flag \"" << flag << "\"!" << Log::endl;
-        return -3;
-    }
-
-    if (b) {
-        getRender().setFlags((unsigned int)f);
-    } else {
-        getRender().clearFlags((unsigned int)f);
-    }
-
-    return 0;
-}
-
-int CommandRenderflag::stringToFlag(std::string flag) {
-    if (flag == "ralpha") {
-        return Render::fRoomAlpha;
-    } else if (flag == "entmodel") {
-        return Render::fEntityModels;
-    } else if (flag == "fog") {
-        return Render::fFog;
-    } else if (flag == "light") {
-        return Render::fGL_Lights;
-    } else if (flag == "ponytail") {
-        return Render::fRenderPonytail;
-    } else {
-        return -1;
-    }
-}
-

src/commands/CommandSet.cpp

  * \author xythobuz
  */
 
+#include "glm/glm.hpp"
+
 #include "global.h"
 #include "Camera.h"
 #include "Log.h"
             getLog() << "set-mouse_x-Error: Invalid value" << Log::endl;
             return -6;
         }
-        getCamera().setSensitivityX(OR_DEG_TO_RAD(sense));
+        Camera::setSensitivityX(glm::radians(sense));
     } else if (var.compare("mouse_y") == 0) {
         float sense = 1.0f;
         if (!(args >> sense)) {
             getLog() << "set-mouse_y-Error: Invalid value" << Log::endl;
             return -7;
         }
-        getCamera().setSensitivityY(OR_DEG_TO_RAD(sense));
+        Camera::setSensitivityY(glm::radians(sense));
     } else if (var.compare("fps") == 0) {
         bool fps = false;
         if (!(args >> fps)) {
     } else if (var.compare("volume") == 0) {
         getLog() << Sound::getVolume() << Log::endl;
     } else if (var.compare("mouse_x") == 0) {
-        getLog() << OR_RAD_TO_DEG(getCamera().getSensitivityX()) << Log::endl;
+        getLog() << glm::degrees(Camera::getSensitivityX()) << Log::endl;
     } else if (var.compare("mouse_y") == 0) {
-        getLog() << OR_RAD_TO_DEG(getCamera().getSensitivityY()) << Log::endl;
+        getLog() << glm::degrees(Camera::getSensitivityY()) << Log::endl;
     } else if (var.compare("fps") == 0) {
         getLog() << getRunTime().getShowFPS() << Log::endl;
     } else if (var.compare("basedir") == 0) {

src/loader/Loader.cpp

         case TR_4:
         case TR_5:
         case TR_UNKNOWN:
-            return NULL;
+            return nullptr;
 
         case TR_2:
             return std::unique_ptr<Loader>(new LoaderTR2());

src/loader/LoaderTR2.cpp

 
 #include <vector>
 
+#include "glm/glm.hpp"
+#include "glm/gtc/matrix_transform.hpp"
+
 #include "global.h"
 #include "Game.h"
 #include "Log.h"
 #include "SoundManager.h"
 #include "TextureManager.h"
 #include "World.h"
-#include "math/Matrix.h"
-#include "math/Vec3.h"
 #include "system/Sound.h"
 #include "utils/pixel.h"
 #include "loader/LoaderTR2.h"
 
         // Convert 16bit textile to 32bit textile
         unsigned char* img = argb16to32(&arr[0], 256, 256);
-        int r = getTextureManager().loadBufferSlot(img, 256, 256, ARGB, 32,
+        int r = getTextureManager().loadBufferSlot(img, 256, 256,
+                TextureManager::ColorMode::ARGB, 32,
                 TextureManager::TextureStorage::GAME, i);
         assert(r >= 0); //! \fixme properly handle error when texture could not be loaded!
         delete [] img;
         uint32_t dataToFollow = file.readU32();
 
         uint16_t numVertices = file.readU16();
-        std::vector<Vec3> vertices;
+        std::vector<glm::vec3> vertices;
         float bbox[2][3] = {
             { 0.0f, 0.0f, 0.0f },
             { 0.0f, 0.0f, 0.0f }
         };
         for (unsigned int v = 0; v < numVertices; v++) {
             // Vertex coordinates, relative to x/zOffset
-            int16_t x = file.read16();
+            int32_t x = file.read16() + xOffset;
             int16_t y = file.read16();
-            int16_t z = file.read16();
+            int32_t z = file.read16() + zOffset;
 
             int16_t light1 = file.read16();
 
             // TODO store sprites somewhere
         }
 
-        Matrix transform;
-        transform.setIdentity();
-        transform.translate(pos);
+        glm::mat4 transform = glm::translate(glm::mat4(1.0f), glm::vec3(pos[0], pos[1], pos[2]));
         room->addAdjacentRoom(i); // Always set room itself as first
 
         uint16_t numPortals = file.readU16();
             int16_t yCorner4 = file.read16();
             int16_t zCorner4 = file.read16();
 
-            float vertices[4][3] = {
-                {
+            glm::vec4 vertices[4] = {
+                glm::vec4(
                     static_cast<float>(xCorner1),
                     static_cast<float>(yCorner1),
-                    static_cast<float>(zCorner1)
-                }, {
+                    static_cast<float>(zCorner1),
+                    1.0f
+                ), glm::vec4(
                     static_cast<float>(xCorner2),
                     static_cast<float>(yCorner2),
-                    static_cast<float>(zCorner2)
-                }, {
+                    static_cast<float>(zCorner2),
+                    1.0f
+                ), glm::vec4(
                     static_cast<float>(xCorner3),
                     static_cast<float>(yCorner3),
-                    static_cast<float>(zCorner3)
-                }, {
+                    static_cast<float>(zCorner3),
+                    1.0f
+                ), glm::vec4(
                     static_cast<float>(xCorner4),
                     static_cast<float>(yCorner4),
-                    static_cast<float>(zCorner4)
-                }
+                    static_cast<float>(zCorner4),
+                    0.0f
+                )
             };
 
             // Portals have relative coordinates
-            transform.multiply3v(vertices[0], vertices[0]);
-            transform.multiply3v(vertices[1], vertices[1]);
-            transform.multiply3v(vertices[2], vertices[2]);
-            transform.multiply3v(vertices[3], vertices[3]);
+            vertices[0] = transform * vertices[0];
+            vertices[1] = transform * vertices[1];
+            vertices[2] = transform * vertices[2];
+            vertices[3] = transform * vertices[3];
 
             float normals[3] = {
                 static_cast<float>(xNormal),
                 static_cast<float>(zNormal)
             };
 
-            room->addPortal(new Portal(vertices, normals, adjoiningRoom));
+            glm::vec3 verts[4] = {
+                glm::vec3(vertices[0]),
+                glm::vec3(vertices[1]),
+                glm::vec3(vertices[2]),
+                glm::vec3(vertices[3])
+            };
+
+            room->addPortal(new Portal(verts, normals, adjoiningRoom));
             room->addAdjacentRoom(adjoiningRoom);
         }
 
         // TODO store mesh collision info somewhere
 
         uint16_t numVertices = mem.readU16();
-        std::vector<Vec3> vertices;
+        std::vector<glm::vec3> vertices;
         for (int v = 0; v < numVertices; v++) {
             int16_t x = mem.read16();
             int16_t y = mem.read16();
                 int16_t y = mem.read16();
                 int16_t z = mem.read16();
 
-                mesh->addNormal(Vec3(x, y, z));
+                mesh->addNormal(glm::vec3(x, y, z));
             }
         } else if (numNormals < 0) {
             // Internal vertex lighting is used,
 
                 float rot[3] = {
                     0.0f,
-                    OR_DEG_TO_RAD(((angle >> 14) & 0x03) * 90.0f),
+                    glm::radians(((angle >> 14) & 0x03) * 90.0f),
                     0.0f
                 };
 

src/main.cpp

 
 #ifndef UNIT_TEST
 
-#include "Camera.h"
 #include "Game.h"
 #include "Log.h"
 #include "MenuFolder.h"
-#include "Render.h"
 #include "RunTime.h"
 #include "SoundManager.h"
 #include "TextureManager.h"
 
 static std::string configFileToUse;
 
-static std::shared_ptr<Camera> gCamera;
 static std::shared_ptr<Game> gGame;
 static std::shared_ptr<Log> gLog;
 static std::shared_ptr<MenuFolder> gMenu;
-static std::shared_ptr<Render> gRender;
 static std::shared_ptr<RunTime> gRunTime;
 static std::shared_ptr<TextureManager> gTextureManager;
 static std::shared_ptr<Window> gWindow;
 static std::shared_ptr<World> gWorld;
 
-Camera& getCamera() {
-    return *gCamera;
-}
-
 Game& getGame() {
     return *gGame;
 }
     return *gMenu;
 }
 
-Render& getRender() {
-    return *gRender;
-}
-
 RunTime& getRunTime() {
     return *gRunTime;
 }
     // RunTime is required by other constructors
     gRunTime.reset(new RunTime());
 
-    gCamera.reset(new Camera());
     gGame.reset(new Game());
     gLog.reset(new Log());
     gMenu.reset(new MenuFolder());
-    gRender.reset(new Render());
     gTextureManager.reset(new TextureManager());
     gWorld.reset(new World());
 
         return -2;
     }
 
-    // Initialize Font
-    error = Font::initialize();
+    // Initialize Texture Manager
+    error = getTextureManager().initialize();
     if (error != 0) {
-        std::cout << "Could not initialize Font (" << error << ")!" << std::endl;
+        std::cout << "Could not initialize TextureManager (" << error << ")!" << std::endl;
         return -3;
     }
 
         Command::executeFile(configFileToUse);
     }
 
-    // Initialize Sound
-    error = Sound::initialize();
+    error = getTextureManager().initializeSplash();
     if (error != 0) {
-        std::cout << "Could not initialize Sound (" << error << ")!" << std::endl;
+        std::cout << "Coult not load Splash Texture (" << error << ")!" << std::endl;
         return -4;
     }
 
-    // Initialize Texture Manager
-    error = getTextureManager().initialize();
+    // Initialize Sound
+    error = Sound::initialize();
     if (error != 0) {
-        std::cout << "Could not initialize TextureManager (" << error << ")!" << std::endl;
+        std::cout << "Could not initialize Sound (" << error << ")!" << std::endl;
         return -5;
     }
 
     UI::shutdown();
     Font::shutdown();
     Sound::shutdown();
+    Window::shutdownGL();
 
 #ifdef DEBUG
     std::cout << std::endl;
     getMenu().display();
     UI::display();
 
+    /*
     if (getRunTime().getShowFPS()) {
         std::ostringstream s;
         s << getRunTime().getFPS() << "FPS";
         Font::drawText(10, getWindow().getHeight() - 25, 0.6f, BLUE, s.str());
         getWindow().glExit2D();
     }
+    */
 
     getWindow().swapBuffersGL();
 

src/math/CMakeLists.txt

-# Source files
-set (MATH_SRCS ${MATH_SRCS} "math.cpp")
-set (MATH_SRCS ${MATH_SRCS} "Matrix.cpp")
-set (MATH_SRCS ${MATH_SRCS} "Quaternion.cpp")
-set (MATH_SRCS ${MATH_SRCS} "Vec3.cpp")
-
-# Add library
-add_library (OpenRaider_math OBJECT ${MATH_SRCS})
-

src/math/Matrix.cpp

-/*!
- * \file src/math/Matrix.cpp
- * \brief 3D Matrix
- *
- * \author Mongoose
- */
-
-#include <stdio.h>
-#include <math.h>
-
-#include "global.h"
-#include "math/Matrix.h"
-
-Matrix::Matrix() {
-    setIdentity();
-}
-
-Matrix::Matrix(float m[16]) {
-    setMatrix(m);
-}
-
-Matrix::Matrix(Quaternion& q) {
-    float m[16];
-    q.getMatrix(m);
-    setMatrix(m);
-}
-
-bool Matrix::getInvert(float out[16]) {
-    float m[16];
-
-#ifdef COLUMN_ORDER
-    getMatrix(m);
-#else
-    getTransposeMatrix(m);
-#endif
-
-    /*
-     * Mongoose: This code was from a Jeff Lander tutorial which was based
-     * on MESA GL's InvertMatrix.
-     *
-     * NB. OpenGL Matrices are COLUMN major
-     */
-
-#define SWAP_ROWS(a, b) { float *_tmp = a; (a)=(b); (b)=_tmp; }
-#define MAT(m,r,c) (m)[(c)*4+(r)]
-
-    float wtmp[4][8];
-    float m0, m1, m2, m3, s;
-    float* r0, *r1, *r2, *r3;
-
-    r0 = wtmp[0];
-    r1 = wtmp[1];
-    r2 = wtmp[2];
-    r3 = wtmp[3];
-
-    r0[0] = MAT(m, 0, 0);
-    r0[1] = MAT(m, 0, 1);
-    r0[2] = MAT(m, 0, 2);
-    r0[3] = MAT(m, 0, 3);
-    r0[4] = 1.0f;
-    r0[5] = r0[6] = r0[7] = 0.0f;
-
-    r1[0] = MAT(m, 1, 0);
-    r1[1] = MAT(m, 1, 1);
-    r1[2] = MAT(m, 1, 2);
-    r1[3] = MAT(m, 1, 3);
-    r1[5] = 1.0f;
-    r1[4] = r1[6] = r1[7] = 0.0f;
-
-    r2[0] = MAT(m, 2, 0);
-    r2[1] = MAT(m, 2, 1);
-    r2[2] = MAT(m, 2, 2);
-    r2[3] = MAT(m, 2, 3);
-    r2[6] = 1.0f;
-    r2[4] = r2[5] = r2[7] = 0.0f;
-
-    r3[0] = MAT(m, 3, 0);
-    r3[1] = MAT(m, 3, 1);
-    r3[2] = MAT(m, 3, 2);
-    r3[3] = MAT(m, 3, 3);
-    r3[7] = 1.0f;
-    r3[4] = r3[5] = r3[6] = 0.0f;
-
-    // choose pivot or die
-    if (fabs(r3[0]) > fabs(r2[0]))
-        SWAP_ROWS(r3, r2);
-
-    if (fabs(r2[0]) > fabs(r1[0]))
-        SWAP_ROWS(r2, r1);
-
-    if (fabs(r1[0]) > fabs(r0[0]))
-        SWAP_ROWS(r1, r0);
-
-    if (0.0f == r0[0])
-        return false;
-
-    // eliminate first variable
-    m1 = r1[0] / r0[0];
-    m2 = r2[0] / r0[0];
-    m3 = r3[0] / r0[0];
-
-    s = r0[1];
-    r1[1] -= m1 * s;
-    r2[1] -= m2 * s;
-    r3[1] -= m3 * s;
-
-    s = r0[2];
-    r1[2] -= m1 * s;
-    r2[2] -= m2 * s;
-    r3[2] -= m3 * s;
-
-    s = r0[3];
-    r1[3] -= m1 * s;
-    r2[3] -= m2 * s;
-    r3[3] -= m3 * s;
-
-    s = r0[4];
-    if (s != 0.0f) {
-        r1[4] -= m1 * s;
-        r2[4] -= m2 * s;
-        r3[4] -= m3 * s;
-    }
-
-    s = r0[5];
-    if (s != 0.0f) {
-        r1[5] -= m1 * s;
-        r2[5] -= m2 * s;
-        r3[5] -= m3 * s;
-    }
-
-    s = r0[6];
-    if (s != 0.0f) {
-        r1[6] -= m1 * s;
-        r2[6] -= m2 * s;
-        r3[6] -= m3 * s;
-    }
-
-    s = r0[7];
-    if (s != 0.0f) {
-        r1[7] -= m1 * s;
-        r2[7] -= m2 * s;
-        r3[7] -= m3 * s;
-    }
-
-    // choose pivot or die
-    if (fabs(r3[1]) > fabs(r2[1]))
-        SWAP_ROWS(r3, r2);
-
-    if (fabs(r2[1]) > fabs(r1[1]))
-        SWAP_ROWS(r2, r1);
-
-    if (0.0f == r1[1])
-        return false;
-
-    // eliminate second variable
-    m2 = r2[1] / r1[1];
-    m3 = r3[1] / r1[1];
-    r2[2] -= m2 * r1[2];
-    r3[2] -= m3 * r1[2];
-    r2[3] -= m2 * r1[3];
-    r3[3] -= m3 * r1[3];
-
-    s = r1[4];
-    if (0.0f != s) {
-        r2[4] -= m2 * s;
-        r3[4] -= m3 * s;
-    }
-
-    s = r1[5];
-    if (0.0f != s) {
-        r2[5] -= m2 * s;
-        r3[5] -= m3 * s;
-    }
-
-    s = r1[6];
-    if (0.0f != s) {
-        r2[6] -= m2 * s;
-        r3[6] -= m3 * s;
-    }
-
-    s = r1[7];
-    if (0.0f != s) {
-        r2[7] -= m2 * s;
-        r3[7] -= m3 * s;
-    }
-
-    // choose pivot or die
-    if (fabs(r3[2]) > fabs(r2[2])) SWAP_ROWS(r3, r2);
-    if (0.0f == r2[2])  return false;
-
-    // eliminate third variable
-    m3 = r3[2] / r2[2];
-    r3[3] -= m3 * r2[3];
-    r3[4] -= m3 * r2[4];
-    r3[5] -= m3 * r2[5];
-    r3[6] -= m3 * r2[6];
-    r3[7] -= m3 * r2[7];
-
-    // last check
-    if (0.0f == r3[3])
-        return false;
-
-    s = 1.0f / r3[3]; // now back substitute row 3
-    r3[4] *= s;
-    r3[5] *= s;
-    r3[6] *= s;
-    r3[7] *= s;
-
-    m2 = r2[3]; // now back substitute row 2
-    s = 1.0f / r2[2];
-    r2[4] = s * (r2[4] - r3[4] * m2);
-    r2[5] = s * (r2[5] - r3[5] * m2);
-    r2[6] = s * (r2[6] - r3[6] * m2);
-    r2[7] = s * (r2[7] - r3[7] * m2);
-
-    m1 = r1[3];
-    r1[4] -= r3[4] * m1;
-    r1[5] -= r3[5] * m1;
-    r1[6] -= r3[6] * m1;
-    r1[7] -= r3[7] * m1;
-
-    m0 = r0[3];
-    r0[4] -= r3[4] * m0;
-    r0[5] -= r3[5] * m0;
-    r0[6] -= r3[6] * m0;
-    r0[7] -= r3[7] * m0;
-
-    m1 = r1[2]; // now back substitute row 1
-    s = 1.0f / r1[1];
-    r1[4] = s * (r1[4] - r2[4] * m1);
-    r1[5] = s * (r1[5] - r2[5] * m1);
-    r1[6] = s * (r1[6] - r2[6] * m1);
-    r1[7] = s * (r1[7] - r2[7] * m1);
-
-    m0 = r0[2];
-    r0[4] -= r2[4] * m0;
-    r0[5] -= r2[5] * m0;
-    r0[6] -= r2[6] * m0;
-    r0[7] -= r2[7] * m0;
-
-    m0 = r0[1]; // now back substitute row 0
-    s = 1.0f / r0[0];
-    r0[4] = s * (r0[4] - r1[4] * m0);
-    r0[5] = s * (r0[5] - r1[5] * m0);
-    r0[6] = s * (r0[6] - r1[6] * m0);
-    r0[7] = s * (r0[7] - r1[7] * m0);
-
-    MAT(out, 0, 0) = r0[4];
-    MAT(out, 0, 1) = r0[5];
-    MAT(out, 0, 2) = r0[6];
-    MAT(out, 0, 3) = r0[7];
-    MAT(out, 1, 0) = r1[4];
-    MAT(out, 1, 1) = r1[5];
-    MAT(out, 1, 2) = r1[6];
-    MAT(out, 1, 3) = r1[7];
-    MAT(out, 2, 0) = r2[4];
-    MAT(out, 2, 1) = r2[5];
-    MAT(out, 2, 2) = r2[6];
-    MAT(out, 2, 3) = r2[7];
-    MAT(out, 3, 0) = r3[4];
-    MAT(out, 3, 1) = r3[5];
-    MAT(out, 3, 2) = r3[6];
-    MAT(out, 3, 3) = r3[7];
-
-    return true;
-}
-
-void Matrix::getMatrix(float mat[16]) {
-    copy(mMatrix, mat);
-}
-
-void Matrix::getTransposeMatrix(float m[16]) {
-    m[ 0] = mMatrix[0]; m[ 1] = mMatrix[4]; m[ 2] = mMatrix[ 8]; m[ 3] = mMatrix[12];
-    m[ 4] = mMatrix[1]; m[ 5] = mMatrix[5]; m[ 6] = mMatrix[ 9]; m[ 7] = mMatrix[13];
-    m[ 8] = mMatrix[2]; m[ 9] = mMatrix[6]; m[10] = mMatrix[10]; m[11] = mMatrix[14];
-    m[12] = mMatrix[3]; m[13] = mMatrix[7]; m[14] = mMatrix[11]; m[15] = mMatrix[15];
-}
-
-Matrix Matrix::multiply(const Matrix& a, const Matrix& b) {
-    Matrix c;
-    multiply(a.mMatrix, b.mMatrix, c.mMatrix);
-    return c;
-}
-
-Matrix Matrix::operator *(const Matrix& a) {
-    return multiply(a, *this);
-}
-
-Vec3 Matrix::operator *(Vec3 v) {
-    float x = v.x, y = v.y, z = v.z;
-
-#ifdef COLUMN_ORDER
-    return Vec3(mMatrix[0] * x + mMatrix[4] * y + mMatrix[ 8] * z + mMatrix[12],
-                mMatrix[1] * x + mMatrix[5] * y + mMatrix[ 9] * z + mMatrix[13],
-                mMatrix[2] * x + mMatrix[6] * y + mMatrix[10] * z + mMatrix[14]);
-#else
-    return Vec3(mMatrix[0] * x + mMatrix[1] * y + mMatrix[ 2] * z + mMatrix[ 3],
-                mMatrix[4] * x + mMatrix[5] * y + mMatrix[ 6] * z + mMatrix[ 7],
-                mMatrix[8] * x + mMatrix[9] * y + mMatrix[10] * z + mMatrix[11]);
-#endif
-}
-
-void Matrix::multiply3v(float v[3], float result[3]) {
-    float x = v[0], y = v[1], z = v[2];
-
-    result[0] = mMatrix[0] * x + mMatrix[1] * y + mMatrix[ 2] * z + mMatrix[ 3];
-    result[1] = mMatrix[4] * x + mMatrix[5] * y + mMatrix[ 6] * z + mMatrix[ 7];
-    result[2] = mMatrix[8] * x + mMatrix[9] * y + mMatrix[10] * z + mMatrix[11];
-}
-
-void Matrix::multiply4v(float v[4], float result[4]) {
-    float x = v[0], y = v[1], z = v[2], w = v[3];
-
-    result[0] = mMatrix[ 0] * x + mMatrix[ 1] * y + mMatrix[ 2] * z + mMatrix[ 3] * w;
-    result[1] = mMatrix[ 4] * x + mMatrix[ 5] * y + mMatrix[ 6] * z + mMatrix[ 7] * w;
-    result[2] = mMatrix[ 8] * x + mMatrix[ 9] * y + mMatrix[10] * z + mMatrix[11] * w;
-    result[3] = mMatrix[12] * x + mMatrix[13] * y + mMatrix[14] * z + mMatrix[15] * w;
-}
-
-void Matrix::print() {
-    printf("{\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n}\n",
-#ifdef COLUMN_ORDER
-           mMatrix[0], mMatrix[4], mMatrix[ 8], mMatrix[12],
-           mMatrix[1], mMatrix[5], mMatrix[ 9], mMatrix[13],
-           mMatrix[2], mMatrix[6], mMatrix[10], mMatrix[14],
-           mMatrix[3], mMatrix[7], mMatrix[11], mMatrix[15]);
-#else
-           mMatrix[ 0], mMatrix[ 1], mMatrix[ 2], mMatrix[ 3],
-           mMatrix[ 4], mMatrix[ 5], mMatrix[ 6], mMatrix[ 7],
-           mMatrix[ 8], mMatrix[ 9], mMatrix[10], mMatrix[11],
-           mMatrix[12], mMatrix[13], mMatrix[14], mMatrix[15]);
-#endif
-}
-
-bool Matrix::isIdentity() {
-    if (equalEpsilon(mMatrix[ 0], 1.0) && equalEpsilon(mMatrix[ 1], 0.0)
-        && equalEpsilon(mMatrix[ 2], 0.0) &&
-        equalEpsilon(mMatrix[ 3], 0.0) && equalEpsilon(mMatrix[ 4], 0.0) && equalEpsilon(mMatrix[ 5], 1.0)
-        &&
-        equalEpsilon(mMatrix[ 6], 0.0) && equalEpsilon(mMatrix[ 7], 0.0) && equalEpsilon(mMatrix[ 8], 0.0)
-        &&
-        equalEpsilon(mMatrix[ 9], 0.0) && equalEpsilon(mMatrix[10], 1.0) && equalEpsilon(mMatrix[11], 0.0)
-        &&
-        equalEpsilon(mMatrix[12], 0.0) && equalEpsilon(mMatrix[13], 0.0) && equalEpsilon(mMatrix[14], 0.0)
-        &&
-        equalEpsilon(mMatrix[15], 1.0))
-        return true;
-
-    return false;
-}
-
-void Matrix::setMatrix(float mat[16]) {
-    copy(mat, mMatrix);
-}
-
-void Matrix::setIdentity() {
-    mMatrix[ 0] = 1; mMatrix[ 1] = 0; mMatrix[ 2] = 0; mMatrix[ 3] = 0;
-    mMatrix[ 4] = 0; mMatrix[ 5] = 1; mMatrix[ 6] = 0; mMatrix[ 7] = 0;
-    mMatrix[ 8] = 0; mMatrix[ 9] = 0; mMatrix[10] = 1; mMatrix[11] = 0;
-    mMatrix[12] = 0; mMatrix[13] = 0; mMatrix[14] = 0; mMatrix[15] = 1;
-}
-
-void Matrix::scale(const float* xyz) {
-    scale(xyz[0], xyz[1], xyz[2]);
-}
-
-void Matrix::scale(float sx, float sy, float sz) {
-    float smatrix[16];
-    float tmp[16];
-
-    smatrix[ 0] = sx; smatrix[ 1] = 0;  smatrix[ 2] = 0;  smatrix[ 3] = 0;
-    smatrix[ 4] = 0;  smatrix[ 5] = sy; smatrix[ 6] = 0;  smatrix[ 7] = 0;
-    smatrix[ 8] = 0;  smatrix[ 9] = 0;  smatrix[10] = sz; smatrix[11] = 0;
-    smatrix[12] = 0;  smatrix[13] = 0;  smatrix[14] = 0;  smatrix[15] = 1;
-
-    copy(mMatrix, tmp);
-    multiply(tmp, smatrix, mMatrix);
-}
-
-void Matrix::rotate(const float* xyz) {
-    rotate(xyz[0], xyz[1], xyz[2]);
-}
-
-void Matrix::rotate(float ax, float ay, float az) {
-    float xmat[16], ymat[16], zmat[16], tmp[16], tmp2[16];
-
-    xmat[ 0] = 1;         xmat[ 1] = 0;         xmat[ 2] = 0;         xmat[ 3] = 0;
-    xmat[ 4] = 0;         xmat[ 5] = cosf(ax);  xmat[ 6] = sinf(ax);  xmat[ 7] = 0;
-    xmat[ 8] = 0;         xmat[ 9] = -sinf(ax); xmat[10] = cosf(ax);  xmat[11] = 0;
-    xmat[12] = 0;         xmat[13] = 0;         xmat[14] = 0;         xmat[15] = 1;
-
-    ymat[ 0] = cosf(ay);  ymat[ 1] = 0;         ymat[ 2] = -sinf(ay); ymat[ 3] = 0;
-    ymat[ 4] = 0;         ymat[ 5] = 1;         ymat[ 6] = 0;         ymat[ 7] = 0;
-    ymat[ 8] = sinf(ay);  ymat[ 9] = 0;         ymat[10] = cosf(ay);  ymat[11] = 0;
-    ymat[12] = 0;         ymat[13] = 0;         ymat[14] = 0;         ymat[15] = 1;
-
-    zmat[ 0] = cosf(az);  zmat[ 1] = sinf(az);  zmat[ 2] = 0;         zmat[ 3] = 0;
-    zmat[ 4] = -sinf(az); zmat[ 5] = cosf(az);  zmat[ 6] = 0;         zmat[ 7] = 0;
-    zmat[ 8] = 0;         zmat[ 9] = 0;         zmat[10] = 1;         zmat[11] = 0;
-    zmat[12] = 0;         zmat[13] = 0;         zmat[14] = 0;         zmat[15] = 1;
-
-    multiply(mMatrix, ymat, tmp);
-    multiply(tmp, xmat, tmp2);
-    multiply(tmp2, zmat, mMatrix);
-}
-
-void Matrix::translate(const float* xyz) {
-    translate(xyz[0], xyz[1], xyz[2]);
-}
-
-void Matrix::translate(float tx, float ty, float tz) {
-    float tmat[16], tmp[16];
-
-    tmat[ 0] = 1;  tmat[ 1] = 0;  tmat[ 2] = 0;  tmat[ 3] = 0;
-    tmat[ 4] = 0;  tmat[ 5] = 1;  tmat[ 6] = 0;  tmat[ 7] = 0;
-    tmat[ 8] = 0;  tmat[ 9] = 0;  tmat[10] = 1;  tmat[11] = 0;
-    tmat[12] = tx; tmat[13] = ty; tmat[14] = tz; tmat[15] = 1;
-
-    copy(mMatrix, tmp);
-    multiply(tmp, tmat, mMatrix);
-}
-
-void Matrix::copy(float source[16], float dest[16]) {
-    for (int i = 0; i < 16; i++)
-        dest[i] = source[i];
-}
-
-void Matrix::multiply(const float a[16], const float b[16], float result[16]) {
-    /* Generated code for matrix mult
-     * Code used:
-
-    // char order is argument
-    int i, j, k;
-    if (order == 'r') {
-        printf("// Row order\n");
-    } else {
-        printf("// Column order\n");
-    }
-    for (i = 0; i < 4; ++i) {
-        for (j = 0; j < 4; ++j) {
-            if (order == 'r') {
-                printf("result[%2i] = ", j+i*4);
-            } else {
-                printf("result[%2i] = ", j+i*4);
-            }
-            for (k = 0; k < 4; ++k) {
-                if (order == 'r') {
-                    printf("a[%2i] * b[%2i]%s",
-                    k+i*4, j+k*4, (k == 3) ? ";\n" : " + ");
-                } else {
-                    printf("a[%2i] * b[%2i]%s",
-                    i+k*4, k+j*4, (k == 3) ? ";\n" : " + ");
-                }
-                //sum+=(elements[i+k*4]*m.elements[k+j*4]);
-            }
-            //result.elements[i+j*4]=sum;
-        }
-        printf("\n");
-    }
-    printf("\n");
-    printf("// Transpose\n");
-    for(i = 0; i < 4; ++i) {
-        for (j = 0; j < 4; ++j) {
-            printf("a[%2i] = b[%2i]%s",
-            j+i*4, i+j*4, (j == 3) ? ";\n" : "; ");
-        }
-    }
-
-     * was in test/Matrix.cpp
-     */
-#ifdef COLUMN_ORDER
-    /* Column order */
-    result[ 0] = a[ 0] * b[ 0] + a[ 4] * b[ 1] + a[ 8] * b[ 2] + a[12] * b[ 3];
-    result[ 1] = a[ 0] * b[ 4] + a[ 4] * b[ 5] + a[ 8] * b[ 6] + a[12] * b[ 7];
-    result[ 2] = a[ 0] * b[ 8] + a[ 4] * b[ 9] + a[ 8] * b[10] + a[12] * b[11];
-    result[ 3] = a[ 0] * b[12] + a[ 4] * b[13] + a[ 8] * b[14] + a[12] * b[15];
-
-    result[ 4] = a[ 1] * b[ 0] + a[ 5] * b[ 1] + a[ 9] * b[ 2] + a[13] * b[ 3];
-    result[ 5] = a[ 1] * b[ 4] + a[ 5] * b[ 5] + a[ 9] * b[ 6] + a[13] * b[ 7];
-    result[ 6] = a[ 1] * b[ 8] + a[ 5] * b[ 9] + a[ 9] * b[10] + a[13] * b[11];
-    result[ 7] = a[ 1] * b[12] + a[ 5] * b[13] + a[ 9] * b[14] + a[13] * b[15];
-
-    result[ 8] = a[ 2] * b[ 0] + a[ 6] * b[ 1] + a[10] * b[ 2] + a[14] * b[ 3];
-    result[ 9] = a[ 2] * b[ 4] + a[ 6] * b[ 5] + a[10] * b[ 6] + a[14] * b[ 7];
-    result[10] = a[ 2] * b[ 8] + a[ 6] * b[ 9] + a[10] * b[10] + a[14] * b[11];
-    result[11] = a[ 2] * b[12] + a[ 6] * b[13] + a[10] * b[14] + a[14] * b[15];
-
-    result[12] = a[ 3] * b[ 0] + a[ 7] * b[ 1] + a[11] * b[ 2] + a[15] * b[ 3];
-    result[13] = a[ 3] * b[ 4] + a[ 7] * b[ 5] + a[11] * b[ 6] + a[15] * b[ 7];
-    result[14] = a[ 3] * b[ 8] + a[ 7] * b[ 9] + a[11] * b[10] + a[15] * b[11];
-    result[15] = a[ 3] * b[12] + a[ 7] * b[13] + a[11] * b[14] + a[15] * b[15];
-#else
-    /* Row order */
-    result[ 0] = a[ 0] * b[ 0] + a[ 1] * b[ 4] + a[ 2] * b[ 8] + a[ 3] * b[12];
-    result[ 1] = a[ 0] * b[ 1] + a[ 1] * b[ 5] + a[ 2] * b[ 9] + a[ 3] * b[13];
-    result[ 2] = a[ 0] * b[ 2] + a[ 1] * b[ 6] + a[ 2] * b[10] + a[ 3] * b[14];
-    result[ 3] = a[ 0] * b[ 3] + a[ 1] * b[ 7] + a[ 2] * b[11] + a[ 3] * b[15];
-
-    result[ 4] = a[ 4] * b[ 0] + a[ 5] * b[ 4] + a[ 6] * b[ 8] + a[ 7] * b[12];
-    result[ 5] = a[ 4] * b[ 1] + a[ 5] * b[ 5] + a[ 6] * b[ 9] + a[ 7] * b[13];
-    result[ 6] = a[ 4] * b[ 2] + a[ 5] * b[ 6] + a[ 6] * b[10] + a[ 7] * b[14];
-    result[ 7] = a[ 4] * b[ 3] + a[ 5] * b[ 7] + a[ 6] * b[11] + a[ 7] * b[15];
-
-    result[ 8] = a[ 8] * b[ 0] + a[ 9] * b[ 4] + a[10] * b[ 8] + a[11] * b[12];
-    result[ 9] = a[ 8] * b[ 1] + a[ 9] * b[ 5] + a[10] * b[ 9] + a[11] * b[13];
-    result[10] = a[ 8] * b[ 2] + a[ 9] * b[ 6] + a[10] * b[10] + a[11] * b[14];
-    result[11] = a[ 8] * b[ 3] + a[ 9] * b[ 7] + a[10] * b[11] + a[11] * b[15];
-
-    result[12] = a[12] * b[ 0] + a[13] * b[ 4] + a[14] * b[ 8] + a[15] * b[12];
-    result[13] = a[12] * b[ 1] + a[13] * b[ 5] + a[14] * b[ 9] + a[15] * b[13];
-    result[14] = a[12] * b[ 2] + a[13] * b[ 6] + a[14] * b[10] + a[15] * b[14];
-    result[15] = a[12] * b[ 3] + a[13] * b[ 7] + a[14] * b[11] + a[15] * b[15];
-#endif
-}
-

src/math/Quaternion.cpp

-/*!
- * \file src/math/Quaternion.cpp
- * \brief Quaternion
- *
- * \author Mongoose
- */
-
-#include <math.h>
-
-#include "global.h"
-#include "math/Quaternion.h"
-
-Quaternion::Quaternion() {
-    mW = 0;
-    mX = 0;
-    mY = 0;
-    mZ = 0;
-}
-
-Quaternion::Quaternion(float w, float x, float y, float z) {
-    mW = w;
-    mX = x;
-    mY = y;
-    mZ = z;
-}
-
-Quaternion::Quaternion(float v[4]) {
-    mW = v[0];
-    mX = v[1];
-    mY = v[2];
-    mZ = v[3];
-}
-
-void Quaternion::getMatrix(float m[16]) {
-    m[ 0] = 1.0f - 2.0f * (mY * mY + mZ * mZ);
-    m[ 1] = 2.0f * (mX * mY - mW * mZ);
-    m[ 2] = 2.0f * (mX * mZ + mW * mY);
-    m[ 3] = 0.0f;
-
-    m[ 4] = 2.0f * (mX * mY + mW * mZ);
-    m[ 5] = 1.0f - 2.0f * (mX * mX + mZ * mZ);
-    m[ 6] = 2.0f * (mY * mZ - mW * mX);
-    m[ 7] = 0.0f;
-
-    m[ 8] = 2.0f * (mX * mZ - mW * mY);
-    m[ 9] = 2.0f * (mY * mZ + mW * mX);
-    m[10] = 1.0f - 2.0f * (mX * mX + mY * mY);
-    m[11] = 0.0f;
-
-    m[12] = 0.0f;
-    m[13] = 0.0f;
-    m[14] = 0.0f;
-    m[15] = 1.0f;
-}
-
-Quaternion Quaternion::operator *(const Quaternion& q) {
-    return multiply(*this, q);
-}
-
-Quaternion Quaternion::operator /(const Quaternion& q) {
-    return divide(*this, q);
-}
-
-Quaternion Quaternion::operator +(const Quaternion& q) {
-    return add(*this, q);
-}
-
-Quaternion Quaternion::operator -(const Quaternion& q) {
-    return subtract(*this, q);
-}
-
-bool Quaternion::operator ==(const Quaternion& q) {
-    //return (mX == q.mX && mY == q.mY && mZ == q.mZ && mW == q.mW);
-    return (equalEpsilon(mX, q.mX) && equalEpsilon(mY, q.mY) &&
-            equalEpsilon(mZ, q.mZ) && equalEpsilon(mW, q.mW));
-}
-
-Quaternion Quaternion::conjugate() {
-    return Quaternion(mW, -mX, -mY, -mZ);
-}
-
-Quaternion Quaternion::scale(float s) {
-    return Quaternion(mW * s, mX * s, mY * s, mZ * s);
-}
-
-Quaternion Quaternion::inverse() {
-    return conjugate().scale(1 / magnitude());
-}
-
-float Quaternion::dot(Quaternion a, Quaternion b) {
-    return ((a.mW * b.mW) + (a.mX * b.mX) + (a.mY * b.mY) + (a.mZ * b.mZ));
-}
-
-float Quaternion::magnitude() {
-    return sqrtf(dot(*this, *this));
-}
-
-void Quaternion::setIdentity() {
-    mW = 1.0;
-    mX = 0.0;
-    mY = 0.0;
-    mZ = 0.0;
-}
-
-void Quaternion::set(float angle, float x, float y, float z) {
-    float temp, dist;
-
-    // Normalize
-    temp = x * x + y * y + z * z;
-
-    dist = 1.0f / sqrtf(temp);
-
-    x *= dist;
-    y *= dist;
-    z *= dist;
-
-    mX = x;
-    mY = y;
-    mZ = z;
-
-    mW = cosf(angle / 2.0f);
-}
-
-void Quaternion::normalize() {
-    float dist, square;
-
-    square = mX * mX + mY * mY + mZ * mZ + mW * mW;
-
-    if (square > 0.0) {
-        dist = 1.0f / sqrtf(square);
-    } else {
-        dist = 1;
-    }
-
-    mX *= dist;
-    mY *= dist;
-    mZ *= dist;
-    mW *= dist;
-}
-
-void Quaternion::copy(Quaternion q) {
-    mW = q.mW;
-    mX = q.mX;
-    mY = q.mY;
-    mZ = q.mZ;
-}
-
-Quaternion Quaternion::slerp(Quaternion a, Quaternion b, float time) {
-    /*******************************************************************
-     * Spherical Linear Interpolation algorthim
-     *-----------------------------------------------------------------
-     *
-     * Interpolate between A and B rotations ( Find qI )
-     *
-     * qI = (((qB . qA)^ -1)^ Time) qA
-     *
-     * http://www.magic-software.com/Documentation/quat.pdf
-     *
-     * Thanks to digiben for algorithms and basis of the notes in
-     * this func
-     *
-     *******************************************************************/
-
-    float result, scaleA, scaleB;
-    Quaternion i;
-
-
-    // Don't bother if it's the same rotation, it's the same as the result
-    if (a == b)
-        return a;
-
-    // A . B
-    result = dot(a, b);
-
-    // If the dot product is less than 0, the angle is greater than 90 degrees
-    if (result < 0.0f) {
-        // Negate quaternion B and the result of the dot product
-        b = Quaternion(-b.mW, -b.mX, -b.mY, -b.mZ);
-        result = -result;
-    }
-
-    // Set the first and second scale for the interpolation
-    scaleA = 1 - time;
-    scaleB = time;
-
-    // Next, we want to actually calculate the spherical interpolation.  Since this
-    // calculation is quite computationally expensive, we want to only perform it
-    // if the angle between the 2 quaternions is large enough to warrant it.  If the
-    // angle is fairly small, we can actually just do a simpler linear interpolation
-    // of the 2 quaternions, and skip all the complex math.  We create a "delta" value
-    // of 0.1 to say that if the cosine of the angle (result of the dot product) between
-    // the 2 quaternions is smaller than 0.1, then we do NOT want to perform the full on
-    // interpolation using.  This is because you won't really notice the difference.
-
-    // Check if the angle between the 2 quaternions was big enough
-    // to warrant such calculations
-    if (1 - result > 0.1f) {
-        // Get the angle between the 2 quaternions, and then
-        // store the sin() of that angle
-        float theta = (float)acos(result);
-        float sinTheta = (float)sin(theta);
-
-        // Calculate the scale for qA and qB, according to
-        // the angle and it's sine value
-        scaleA = (float)sin((1 - time) * theta) / sinTheta;
-        scaleB = (float)sin((time * theta)) / sinTheta;
-    }
-
-    // Calculate the x, y, z and w values for the quaternion by using a special
-    // form of linear interpolation for quaternions.
-    return (a.scale(scaleA) + b.scale(scaleB));
-}
-
-void Quaternion::setByMatrix(float matrix[16]) {
-    float diagonal = matrix[0] + matrix[5] + matrix[10] + 1.0f;
-    float scale = 0.0f;
-    float w = 0.0f, x = 0.0f, y = 0.0f, z = 0.0f;
-
-    if (diagonal > 0.00000001) {
-        // Calculate the scale of the diagonal
-        scale = (float)(sqrt(diagonal) * 2);
-
-        w = 0.25f * scale;
-        x = (matrix[9] - matrix[6]) / scale;
-        y = (matrix[2] - matrix[8]) / scale;
-        z = (matrix[4] - matrix[1]) / scale;
-    } else {
-        // If the first element of the diagonal is the greatest value
-        if (matrix[0] > matrix[5] && matrix[0] > matrix[10]) {
-            // Find the scale according to the first element, and double it
-            scale = (float)sqrt(1.0f + matrix[0] - matrix[5] - matrix[10]) * 2.0f;
-
-            // Calculate the quaternion
-            w = (matrix[9] - matrix[6]) / scale;
-            x = 0.25f * scale;
-            y = (matrix[4] + matrix[1]) / scale;
-            z = (matrix[2] + matrix[8]) / scale;
-        } else if (matrix[5] > matrix[10]) {
-            // The second element of the diagonal is the greatest value
-            // Find the scale according to the second element, and double it
-            scale = (float)sqrt(1.0f + matrix[5] - matrix[0] - matrix[10]) * 2.0f;
-
-            // Calculate the quaternion
-            w = (matrix[2] - matrix[8]) / scale;
-            x = (matrix[4] + matrix[1]) / scale;
-            y = 0.25f * scale;
-            z = (matrix[9] + matrix[6]) / scale;
-        } else { // The third element of the diagonal is the greatest value
-            // Find the scale according to the third element, and double it
-            scale = (float)sqrt(1.0f + matrix[10] - matrix[0] - matrix[5]) * 2.0f;
-
-            // Calculate the quaternion
-            w = (matrix[4] - matrix[1]) / scale;
-            x = (matrix[2] + matrix[8]) / scale;
-            y = (matrix[9] + matrix[6]) / scale;
-            z = 0.25f * scale;
-        }
-    }
-
-    mW = w;
-    mX = x;
-    mY = y;
-    mZ = z;
-}
-
-Quaternion Quaternion::multiply(Quaternion a, Quaternion b) {
-    return Quaternion(a.mW * b.mW - a.mX * b.mX - a.mY * b.mY - a.mZ * b.mZ,
-                      a.mW * b.mX + a.mX * b.mW + a.mY * b.mZ - a.mZ * b.mY,
-                      a.mW * b.mY + a.mY * b.mW + a.mZ * b.mX - a.mX * b.mZ,
-                      a.mW * b.mZ + a.mZ * b.mW + a.mX * b.mY - a.mY * b.mX);
-}
-
-Quaternion Quaternion::divide(Quaternion a, Quaternion b) {
-    return (a * (b.inverse()));
-}
-
-Quaternion Quaternion::add(Quaternion a, Quaternion b) {
-    return Quaternion(a.mW + b.mW,
-                      a.mX + b.mX,
-                      a.mY + b.mY,
-                      a.mZ + b.mZ);
-}
-
-Quaternion Quaternion::subtract(Quaternion a, Quaternion b) {
-    return Quaternion(a.mW - b.mW,
-                      a.mX - b.mX,
-                      a.mY - b.mY,
-                      a.mZ - b.mZ);
-}
-

src/math/Vec3.cpp

-/*!
- * \file src/math/Vec3.cpp
- * \brief 3D Math vector
- *
- * \author Mongoose
- */
-
-#include <math.h>
-
-#include "global.h"
-#include "math/Vec3.h"
-
-Vec3::Vec3(float _x, float _y, float _z) {
-    x = _x;
-    y = _y;
-    z = _z;
-}
-
-Vec3::Vec3(float v[3]) {
-    assert(v != nullptr);
-    x = v[0];
-    y = v[1];
-    z = v[2];
-}
-
-float Vec3::magnitude() {
-    return sqrtf(x * x + y * y + z * z);
-}
-
-void Vec3::normalize() {
-    float norm = magnitude();
-    x /= norm;
-    y /= norm;
-    z /= norm;
-}
-
-Vec3 Vec3::unit() {
-    float norm = magnitude();
-    return Vec3(x / norm,
-                y / norm,
-                z / norm);
-}
-
-Vec3 Vec3::operator +(const Vec3& v) {
-    return Vec3(x + v.x,
-                y + v.y,
-                z + v.z);
-}
-
-Vec3 Vec3::operator -(const Vec3& v) {
-    return Vec3(x - v.x,
-                y - v.y,
-                z - v.z);
-}
-
-Vec3 Vec3::operator -() {
-    return Vec3(-x,
-                -y,
-                -z);
-}
-
-Vec3 Vec3::operator *(float s) {
-    return Vec3(s * x,
-                s * y,
-                s * z);
-}
-
-Vec3 Vec3::operator /(float s) {
-    return Vec3(x / s,
-                y / s,
-                z / s);
-}
-
-float Vec3::operator *(const Vec3& v) {
-    return dot(*this, v);
-}
-
-Vec3& Vec3::operator +=(const Vec3& v) {
-    x += v.x;
-    y += v.y;
-    z += v.z;
-    return *this;
-}
-
-Vec3& Vec3::operator -=(const Vec3& v) {
-    x -= v.x;
-    y -= v.y;
-    z -= v.z;
-    return *this;
-}
-
-Vec3& Vec3::operator *=(float s) {
-    x *= s;
-    y *= s;
-    z *= s;
-    return *this;
-}
-
-bool Vec3::operator ==(const Vec3& v) {
-    return equalEpsilon(x, v.x)
-           && equalEpsilon(y, v.y)
-           && equalEpsilon(z, v.z);
-}
-
-bool Vec3::operator !=(const Vec3& v) {
-    return !((*this) == v);
-}
-
-float Vec3::dot(const Vec3& u, const Vec3& v) {
-    return (u.x * v.x + u.y * v.y + u.z * v.z);
-}
-
-Vec3 Vec3::cross(const Vec3& u, const Vec3& v) {
-    return Vec3(u.y * v.z - u.z * v.y,
-                u.z * v.x - u.x * v.z,
-                u.x * v.y - u.y * v.x);
-}
-

src/math/math.cpp

-/*!
- *
- * \file src/math/math.cpp
- * \brief Vector and Matrix math
- *
- * \author Mongoose
- * \author xythobuz
- */
-
-#include <cstdlib>
-#include <cmath>
-#include <float.h>
-#include <algorithm>
-
-#include "global.h"
-#include "math/Vec3.h"
-#include "math/Matrix.h"
-#include "math/math.h"
-
-bool equalEpsilon(float a, float b) {
-    float epsilon = FLT_EPSILON;
-    if (fabs(a - b) <= (std::max(fabs(a), fabs(b)) * epsilon))
-        return true;
-    return false;
-}
-
-int intersectionLinePolygon(float intersect[3],
-                            float p1[3], float p2[3], float polygon[3][3]) {
-    assert(polygon != NULL);
-
-    // float normal[3], a[3], b[3];
-    Vec3 a, b, normal, pA, pB;
-    float d, denominator, mu;
-
-
-    pA = Vec3(p1);
-    pB = Vec3(p2);
-
-    // Find normal
-    a = Vec3(polygon[1]) - Vec3(polygon[0]);
-    b = Vec3(polygon[2]) - Vec3(polygon[0]);
-    normal = Vec3::cross(a, b);
-    normal.normalize();
-
-    // find D
-    d = (normal.x * polygon[0][0] -
-         normal.y * polygon[0][1] -
-         normal.z * polygon[0][2]);
-
-    // line segment parallel to plane?
-    a = pB - pA;
-
-    denominator = Vec3::dot(normal, a);
-
-    if (denominator > 0.0)
-        return 0;
-
-    // Line segment contains intercept point?
-    mu = -((d + Vec3::dot(normal, pA)) / denominator);
-
-    if (mu < 0.0 || mu > 1.0)
-        return 0;
-
-    b = pA + (a * mu);
-    intersect[0] = b.x;
-    intersect[1] = b.y;
-    intersect[2] = b.z;
-
-    // See if the intercept is bound by polygon by winding number
-    // assume convex polygons here for sure
-    double theta = Vec3::dot(b - Vec3(polygon[0]), normal); // b = intersect
-
-    if (theta >= 90.0) // Yeah I know
-        return 0;
-
-    return 1;
-}
-
-float distance(const float a[3], const float b[3]) {
-    return sqrtf(((b[0] - a[0]) * (b[0] - a[0])) +
-                 ((b[1] - a[1]) * (b[1] - a[1])) +
-                 ((b[2] - a[2]) * (b[2] - a[2])));
-}
-
-void midpoint(const float a[3], const float b[3], float mid[3]) {
-    mid[0] = (a[0] + b[0]) / 2.0f;
-    mid[1] = (a[1] + b[1]) / 2.0f;
-    mid[2] = (a[2] + b[2]) / 2.0f;
-}
-
-float randomNum(float from, float to) {
-    return from + ((to - from) * rand() / (RAND_MAX + 1.0f));
-}
-

src/system/FontImGui.cpp

 #define SCALE_DRAW 20.0f
 
 unsigned int FontImGui::widthText(float scale, std::string s) {
-    //ImGuiIO& io = ImGui::GetIO();
-    //ImVec2 size = io.Font->CalcTextSizeA(scale * SCALE_CALC, io.DisplaySize.y, s.c_str(),
-    //                                     s.c_str() + s.length());
-    //return size.y;
-    return s.length() * 15;
+    ImGuiIO& io = ImGui::GetIO();
+    ImVec2 size = io.Font->CalcTextSizeA(scale * SCALE_CALC, FLT_MAX, io.DisplaySize.y, s.c_str(),
+                                         s.c_str() + s.length());
+    return size.y;
 }
 
 void FontImGui::drawText(unsigned int x, unsigned int y, float scale,
 }
 
 unsigned int FontImGui::heightText(float scale, unsigned int maxWidth, std::string s) {
-    //ImGuiIO& io = ImGui::GetIO();
-    //ImVec2 size = io.Font->CalcTextSizeA(scale * SCALE_CALC, maxWidth, s.c_str(),
-    //                                     s.c_str() + s.length());
-    //return size.x;
-    return 15;
+    ImGuiIO& io = ImGui::GetIO();
+    ImVec2 size = io.Font->CalcTextSizeA(scale * SCALE_CALC, FLT_MAX, maxWidth, s.c_str(),
+                                         s.c_str() + s.length());
+    return size.x;
 }
 
 void FontImGui::drawTextWrapped(unsigned int x, unsigned int y, float scale,
                                 const unsigned char color[4], unsigned int maxWidth, std::string s) {
-    drawText(x, y, scale, color, s);
+    ImGuiIO& io = ImGui::GetIO();
+    ImVec2 pos = ImVec2(x, y);
+    ImU32 col = color[0] | (color[1] << 8) | (color[2] << 16) | (color[3] << 24);
+
+    ImDrawList dl;
+    dl.PushClipRect(ImVec4(0.0f, 0.0f, io.DisplaySize.x, io.DisplaySize.y));
+    dl.AddText(io.Font, scale * SCALE_DRAW, pos, col, s.c_str(), s.c_str() + s.length(), maxWidth);
+
+    ImDrawList* dlp = &dl;
+    UI::renderImGui(&dlp, 1);
 }
 

src/system/FontSDL.cpp

 #include <iostream>
 
 #include "global.h"
+#include "TextureManager.h"
+#include "system/Window.h"
 #include "system/FontSDL.h"
 
 bool FontSDL::mFontInit = false;
 TTF_Font* FontSDL::mFont = nullptr;
-unsigned int FontSDL::mFontTexture = 0;
+unsigned int FontSDL::mFontTexture = -1;
 
 void FontSDL::shutdown() {
     if (mFont != nullptr)
 
     if (mFontInit) {
         TTF_Quit();
-        glDeleteTextures(1, &mFontTexture);
         mFontInit = false;
     }
 }
             return -1;
         }
 
-        glGenTextures(1, &mFontTexture);
+        // Reserve slot
+        mFontTexture = getTextureManager().loadBufferSlot(nullptr, 256, 256,
+                TextureManager::ColorMode::RGBA, 32, TextureManager::TextureStorage::SYSTEM);
+
         mFontInit = true;
     }
 
     int w = (int)((float)surface->w * scale);
     int h = (int)((float)surface->h * scale);
 
-    GLenum textureFormat;
+    TextureManager::ColorMode textureFormat;
+    unsigned int bpp = 0;
     if (surface->format->BytesPerPixel == 4) {
         if (surface->format->Rmask == 0x000000FF)
-            textureFormat = GL_RGBA;
+            textureFormat = TextureManager::ColorMode::RGBA;
         else
-            textureFormat = GL_BGRA_EXT;
+            textureFormat = TextureManager::ColorMode::BGRA;
+        bpp = 32;
     } else {
         if (surface->format->Rmask == 0x000000FF)
-            textureFormat = GL_RGB;
+            textureFormat = TextureManager::ColorMode::RGB;
         else
-            textureFormat = GL_BGR_EXT;
+            textureFormat = TextureManager::ColorMode::BGR;
+        bpp = 24;
     }
 
-    glBindTexture(GL_TEXTURE_2D, mFontTexture);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexImage2D(GL_TEXTURE_2D, 0, surface->format->BytesPerPixel, surface->w, surface->h, 0,
-                 textureFormat, GL_UNSIGNED_BYTE, surface->pixels);
+    getTextureManager().loadBufferSlot(static_cast<unsigned char*>(surface->pixels),
+                                       surface->w, surface->h, textureFormat, bpp,
+                                       TextureManager::TextureStorage::SYSTEM, mFontTexture);
     SDL_FreeSurface(surface);
 
-    GLuint xMin = x;
-    GLuint yMin = y;
-    GLuint xMax = xMin + w;
-    GLuint yMax = yMin + h;
+    std::vector<glm::vec2> vertices;
+    std::vector<glm::vec2> uvs;
 
-    glColor4ubv(color);
+    vertices.push_back(glm::vec2(x, y + h));
+    vertices.push_back(glm::vec2(x, y));
+    vertices.push_back(glm::vec2(x + w, y + h));
 
-    glBegin(GL_QUADS);
-    glTexCoord2f(0.0f, 0.0f);
-    glVertex2i(xMin, yMin);
+    vertices.push_back(glm::vec2(x + w, y));
+    vertices.push_back(glm::vec2(x + w, y + h));
+    vertices.push_back(glm::vec2(x, y));
 
-    glTexCoord2f(0.0f, 1.0f);
-    glVertex2i(xMin, yMax);
+    uvs.push_back(glm::vec2(0.0f, 1.0f));
+    uvs.push_back(glm::vec2(0.0f, 0.0f));
+    uvs.push_back(glm::vec2(1.0f, 1.0f));
 
-    glTexCoord2f(1.0f, 1.0f);
-    glVertex2i(xMax, yMax);
+    uvs.push_back(glm::vec2(1.0f, 0.0f));
+    uvs.push_back(glm::vec2(1.0f, 1.0f));
+    uvs.push_back(glm::vec2(0.0f, 0.0f));
 
-    glTexCoord2f(1.0f, 0.0f);
-    glVertex2i(xMax, yMin);
-    glEnd();
+    Window::drawTextGL(vertices, uvs, glm::vec4(1.0f, 1.0f, 1.0f, 1.0f), mFontTexture);
 }
 
 unsigned int FontSDL::heightText(float scale, unsigned int maxWidth, std::string s) {
     int w = (int)((float)surface->w * scale);
     int h = (int)((float)surface->h * scale);
 
-    GLenum textureFormat;
+    TextureManager::ColorMode textureFormat;
+    unsigned int bpp = 0;
     if (surface->format->BytesPerPixel == 4) {
         if (surface->format->Rmask == 0x000000FF)
-            textureFormat = GL_RGBA;
+            textureFormat = TextureManager::ColorMode::RGBA;
         else
-            textureFormat = GL_BGRA_EXT;
+            textureFormat = TextureManager::ColorMode::BGRA;
+        bpp = 32;
     } else {
         if (surface->format->Rmask == 0x000000FF)
-            textureFormat = GL_RGB;
+            textureFormat = TextureManager::ColorMode::RGB;
         else
-            textureFormat = GL_BGR_EXT;
+            textureFormat = TextureManager::ColorMode::BGR;
+        bpp = 24;
     }
 
-    glBindTexture(GL_TEXTURE_2D, mFontTexture);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexImage2D(GL_TEXTURE_2D, 0, surface->format->BytesPerPixel, surface->w, surface->h, 0,
-                 textureFormat, GL_UNSIGNED_BYTE, surface->pixels);
+    getTextureManager().loadBufferSlot(static_cast<unsigned char*>(surface->pixels),
+                                       surface->w, surface->h, textureFormat, bpp,
+                                       TextureManager::TextureStorage::SYSTEM, mFontTexture);
     SDL_FreeSurface(surface);
 
-    GLuint xMin = x;
-    GLuint yMin = y;
-    GLuint xMax = xMin + w;
-    GLuint yMax = yMin + h;
+    std::vector<glm::vec2> vertices;
+    std::vector<glm::vec2> uvs;
 
-    glColor4ubv(color);
+    vertices.push_back(glm::vec2(x, y + h));
+    vertices.push_back(glm::vec2(x, y));
+    vertices.push_back(glm::vec2(x + w, y + h));
 
-    glBegin(GL_QUADS);
-    glTexCoord2f(0.0f, 0.0f);
-    glVertex2i(xMin, yMin);
+    vertices.push_back(glm::vec2(x + w, y));
+    vertices.push_back(glm::vec2(x + w, y + h));
+    vertices.push_back(glm::vec2(x, y));
 
-    glTexCoord2f(0.0f, 1.0f);
-    glVertex2i(xMin, yMax);
+    uvs.push_back(glm::vec2(0.0f, 1.0f));
+    uvs.push_back(glm::vec2(0.0f, 0.0f));
+    uvs.push_back(glm::vec2(1.0f, 1.0f));
 
-    glTexCoord2f(1.0f, 1.0f);
-    glVertex2i(xMax, yMax);
+    uvs.push_back(glm::vec2(1.0f, 0.0f));
+    uvs.push_back(glm::vec2(1.0f, 1.0f));
+    uvs.push_back(glm::vec2(0.0f, 0.0f));
 
-    glTexCoord2f(1.0f, 0.0f);
-    glVertex2i(xMax, yMin);
-    glEnd();
+    Window::drawTextGL(vertices, uvs, glm::vec4(1.0f, 1.0f, 1.0f, 1.0f), mFontTexture);
 }
 

src/system/FontTRLE.cpp

 #include <stdexcept>
 
 #include "global.h"
+#include "TextureManager.h"
 #include "utils/strings.h"
+#include "system/Window.h"
 #include "system/FontTRLE.h"
 
 #define SCALING 2.0f
 int FontTRLE::offsets[106][5];
 
 void FontTRLE::shutdown() {
-    if (mFontInit)
-        glDeleteTextures(1, &mFontTexture);
 }
 
 int FontTRLE::initialize(std::string font) {
         pixels[i] = pixels[i + 1] = pixels[i + 2] = (unsigned char)y;
     }
 
-    // ...into GL texture
-    glGenTextures(1, &mFontTexture);
-    glBindTexture(GL_TEXTURE_2D, mFontTexture);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 256, 256, 0, GL_BGRA_EXT, GL_UNSIGNED_BYTE, pixels);
+    mFontTexture = getTextureManager().loadBufferSlot(pixels, 256, 256,
+            TextureManager::ColorMode::BGRA, 32, TextureManager::TextureStorage::SYSTEM);
     delete [] pixels;
 
     // Try to load .lps file or use default glyph positions
         return;
     }
 
-    //! \todo This is probably the worlds most unreliable parser...
-
     for (std::string line; std::getline(file, line);) {
         std::istringstream stream(line);
         int index;
     }
 }
 
-void FontTRLE::writeChar(unsigned int index, unsigned int xDraw, unsigned int yDraw,
-                         float scale, const unsigned char color[4]) {
+void FontTRLE::writeChar(unsigned int index, unsigned int xDraw, unsigned int yDraw, float scale,
+                         std::vector<glm::vec2>& vertices, std::vector<glm::vec2>& uvs) {
     assert(mFontInit == true);
 
-    int width = (int)(((float)offsets[index][2]) * scale * SCALING);
-    int height = (int)(((float)offsets[index][3]) * scale * SCALING);
-    int offset = (int)(((float)offsets[index][4]) * scale * SCALING);
+    float width = ((float)offsets[index][2]) * scale * SCALING;
+    float height = ((float)offsets[index][3]) * scale * SCALING;
+    float offset = ((float)offsets[index][4]) * scale * SCALING;
 
     // screen coordinates
-    int xMin = xDraw;
-    int yMin = ((int)yDraw) + offset + (int)(10.0f * scale * SCALING);
-    int xMax = xMin + width;
-    int yMax = yMin + height;
+    float xMin = xDraw;
+    float yMin = yDraw + offset + (10.0f * scale * SCALING);
+    float xMax = xMin + width;
+    float yMax = yMin + height;
 
     // texture part
     float txMin = ((float)offsets[index][0]) / 256.0f;
     float tyMin = ((float)offsets[index][1]) / 256.0f;
     float tyMax = ((float)(offsets[index][1] + offsets[index][3])) / 256.0f;
 
-    // draw
-    glBindTexture(GL_TEXTURE_2D, mFontTexture);
-    glColor4f(color[0] * 256.0f, color[1] * 256.0f, color[2] * 256.0f, color[3] * 256.0f);
-    glBegin(GL_QUADS);
-    glTexCoord2f(txMin, tyMin);
-    glVertex2i(xMin, yMin);
-    glTexCoord2f(txMin, tyMax);
-    glVertex2i(xMin, yMax);
-    glTexCoord2f(txMax, tyMax);
-    glVertex2i(xMax, yMax);
-    glTexCoord2f(txMax, tyMin);
-    glVertex2i(xMax, yMin);
-    glEnd();
+    vertices.push_back(glm::vec2(xMin, yMax));
+    vertices.push_back(glm::vec2(xMin, yMin));
+    vertices.push_back(glm::vec2(xMax, yMax));
+
+    vertices.push_back(glm::vec2(xMax, yMin));
+    vertices.push_back(glm::vec2(xMax, yMax));
+    vertices.push_back(glm::vec2(xMin, yMin));
+
+    uvs.push_back(glm::vec2(txMin, tyMax));
+    uvs.push_back(glm::vec2(txMin, tyMin));
+    uvs.push_back(glm::vec2(txMax, tyMax));
+
+    uvs.push_back(glm::vec2(txMax, tyMin));
+    uvs.push_back(glm::vec2(txMax, tyMax));
+    uvs.push_back(glm::vec2(txMin, tyMin));
 }
 
 unsigned int FontTRLE::widthText(float scale, std::string s) {
     assert(mFontInit == true);
     assert(s.length() > 0);
 
+    std::vector<glm::vec2> vertices;
+    std::vector<glm::vec2> uvs;
     for (unsigned int i = 0; i < s.length(); i++) {
         // index into offset table
         int index = s[i] - '!';
         if ((index < 0) || (index > 105))
             continue; // skip unprintable chars
 
-        writeChar((unsigned int)index, x, y, scale, color);
+        writeChar((unsigned int)index, x, y, scale, vertices, uvs);
         x += (int)((float)(offsets[index][2] + 1) * scale * SCALING); // width
     }
+
+    glm::vec4 col(color[0] / 256.0f, color[1] / 256.0f, color[2] / 256.0f, color[3] / 256.0f);
+    Window::drawTextGL(vertices, uvs, col, mFontTexture);
 }
 
 unsigned int FontTRLE::heightText(float scale, unsigned int maxWidth, std::string s) {
     unsigned int xStart = x;
     unsigned int yMax = 0;
 
+    std::vector<glm::vec2> vertices;
+    std::vector<glm::vec2> uvs;
     for (unsigned int i = 0; i < s.length(); i++) {
         // index into offset table
         int index = s[i] - '!';
             x -= (int)((float)(offsets[index][2] + 1) * scale * SCALING);
         }
 
-        writeChar((unsigned int)index, x, y, scale, color);
+        writeChar((unsigned int)index, x, y, scale, vertices, uvs);
         x += (int)((float)(offsets[index][2] + 1) * scale * SCALING); // width
     }
+
+    glm::vec4 col(color[0] / 256.0f, color[1] / 256.0f, color[2] / 256.0f, color[3] / 256.0f);
+    Window::drawTextGL(vertices, uvs, col, mFontTexture);
 }
 
 int FontTRLE::defaultOffsets[106][5] = {

src/system/SoundAL.cpp

     if (init)
         return 0;
 
-    ALCdevice* device = alcOpenDevice(NULL);
-    ALCcontext* context = alcCreateContext(device, NULL);
+    ALCdevice* device = alcOpenDevice(nullptr);
+    ALCcontext* context = alcCreateContext(device, nullptr);
     alcMakeContextCurrent(context);
 
     if (alutInitWithoutContext(nullptr, nullptr) == AL_FALSE) {

src/system/Window.cpp

  * \author xythobuz
  */
 
-#include <cstdio>
-#include <cstring>
-#include <cstdarg>
-#include <cmath>
-
 #include "global.h"
-#include "math/math.h"
+#include "Log.h"
+#include "TextureManager.h"
 #include "utils/strings.h"
 #include "system/Window.h"
 
+unsigned int Window::getWidth() {
+    return mWidth;
+}
+
+unsigned int Window::getHeight() {
+    return mHeight;
+}
+
+bool Window::getFullscreen() {
+    return mFullscreen;
+}
+
+bool Window::getMousegrab() {
+    return mMousegrab;
+}
+
+bool Window::getTextInput() {
+    return mTextInput;
+}
+
+// ----------------------------------------------------------------------------
+
+Shader Window::textShader;
+Shader Window::imguiShader;
+unsigned int Window::vertexArrayID = 0;
+
 int Window::initializeGL() {
-    // Print driver support information
-    //printf("GL Vendor  : %s\n", glGetString(GL_VENDOR));
-    //printf("GL Renderer: %s\n", glGetString(GL_RENDERER));
-    //printf("GL Version : %s\n", glGetString(GL_VERSION));
-
-    // Testing for goodies
-    //const char *s = (const char *)glGetString(GL_EXTENSIONS);
-    //if ((s != NULL) && (s[0] != '\0')) {
-    //! \todo MultiTexture flag
-    //if (strstr(s, "GL_ARB_multitexture"))
-    //mFlags |= Render::fMultiTexture;
-    //}
+    getLog() << "GL Ven.: " << glGetString(GL_VENDOR) << Log::endl;
+    getLog() << "GL Ren.: " << glGetString(GL_RENDERER) << Log::endl;
+    getLog() << "GL Ver.: " << glGetString(GL_VERSION) << Log::endl;
+    getLog() << "GLSL V.: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << Log::endl;
+
+    glGenVertexArrays(1, &vertexArrayID);
+	glBindVertexArray(vertexArrayID);
+
+    // Set background to black
+    glClearColor(BLACK[0] / 256.0f, BLACK[1] / 256.0f, BLACK[2] / 256.0f, BLACK[3] / 256.0f);
 
     // Set up Z buffer
     glEnable(GL_DEPTH_TEST);
+    // Accept fragment if closer to camera
     glDepthFunc(GL_LESS);
 
     // Set up culling
-    glEnable(GL_CULL_FACE);
-    glFrontFace(GL_CW);
-    //glFrontFace(GL_CCW);
-    //glCullFace(GL_FRONT);
+    //glEnable(GL_CULL_FACE); //! \todo Transparency?
+
+    if (textShader.compile(textShaderVertex, textShaderFragment) < 0)
+        return -1;
+    if (textShader.addUniform("screen") < 0)
+        return -2;
+    if (textShader.addUniform("textureSampler") < 0)
+        return -3;
+    if (textShader.addUniform("colorVar") < 0)
+        return -4;
+    textShader.addBuffer(2);
+
+    if (imguiShader.compile(imguiShaderVertex, imguiShaderFragment) < 0)
+        return -5;
+    if (imguiShader.addUniform("screen") < 0)
+        return -6;
+    if (imguiShader.addUniform("textureSampler") < 0)
+        return -7;
+    imguiShader.addBuffer(3);
 
-    // Set background to black
-    glClearColor(BLACK[0] / 256.0f, BLACK[1] / 256.0f, BLACK[2] / 256.0f, BLACK[3] / 256.0f);
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-    // Disable lighting
-    glDisable(GL_LIGHTING);
+    return 0;
+}
 
-    // Set up alpha blending
-    glEnable(GL_BLEND);
-    glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+void Window::shutdownGL() {
+    glDeleteVertexArrays(1, &vertexArrayID);
+}
 
-    //glEnable(GL_ALPHA_TEST); // Disable per pixel alpha blending
-    glAlphaFunc(GL_GREATER, 0);
+void Window::resizeGL() {
+    // new matrix?
+}
 
-    glPointSize(5.0);
+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);
 
-    // Setup shading
-    glShadeModel(GL_SMOOTH);
+    glBindBuffer(GL_ARRAY_BUFFER, textShader.getBuffer(0));
+    glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(glm::vec2), &vertices[0], GL_STATIC_DRAW);
 
-    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
-    glHint(GL_FOG_HINT, GL_NICEST);
-    glEnable(GL_COLOR_MATERIAL);
-    glEnable(GL_DITHER);
+    glBindBuffer(GL_ARRAY_BUFFER, textShader.getBuffer(1));
+    glBufferData(GL_ARRAY_BUFFER, uvs.size() * sizeof(glm::vec2), &uvs[0], GL_STATIC_DRAW);
 
-    // AA polygon edges
-    glEnable(GL_POLYGON_SMOOTH);
-    glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);
+    textShader.use();
 
-    glDisable(GL_LINE_SMOOTH);
-    glDisable(GL_POINT_SMOOTH);
-    glDisable(GL_AUTO_NORMAL);
-    glDisable(GL_LOGIC_OP);
-    glDisable(GL_TEXTURE_1D);
-    glDisable(GL_STENCIL_TEST);
-    glDisable(GL_FOG);
+    glUniform2f(textShader.getUniform(0), getWindow().getWidth(), getWindow().getHeight());
 
-    glDisable(GL_NORMALIZE);
+    getTextureManager().bindTextureId(texture, TextureManager::TextureStorage::SYSTEM, 0);
+    glUniform1i(textShader.getUniform(1), 0);
 
-    //glEnableClientState(GL_VERTEX_ARRAY);
-    //glDisableClientState(GL_EDGE_FLAG_ARRAY);
-    //glDisableClientState(GL_COLOR_ARRAY);
-    //glDisableClientState(GL_NORMAL_ARRAY);
+    glUniform4fv(textShader.getUniform(2), 1, &color.r);
 
-    glPolygonMode(GL_FRONT, GL_FILL);
+    glEnableVertexAttribArray(0); // Vertices
+    glBindBuffer(GL_ARRAY_BUFFER, textShader.getBuffer(0));
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
 
-    glMatrixMode(GL_MODELVIEW);
+    glEnableVertexAttribArray(1); // UVs
+    glBindBuffer(GL_ARRAY_BUFFER, textShader.getBuffer(1));
+    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
 
-    return 0;
+    glDisable(GL_DEPTH_TEST);
+    glDrawArrays(GL_TRIANGLES, 0, vertices.size());
+    glEnable(GL_DEPTH_TEST);
+
+    glDisableVertexAttribArray(0);
+    glDisableVertexAttribArray(1);
 }
 
-void Window::resizeGL() {
-    float fovY = 40.0f; // 45.0f
-    float clipNear = 10.0f; // 4.0f
-    float clipFar = 600000.0f; // 4000.0f
+// ----------------------------------------------------------------------------
 
-    glViewport(0, 0, mWidth, mHeight);
-    glMatrixMode(GL_PROJECTION);
-    glLoadIdentity();
+Shader::~Shader() {
+    if (programID >= 0)
+        glDeleteProgram(programID);
 
-    // Adjust clipping
-    GLfloat fH = tanf(fovY * OR_PI / 360.0f) * clipNear;
-    GLfloat fW = fH * ((GLfloat)mWidth) / ((GLfloat)mHeight);
-    glFrustum(-fW, fW, -fH, fH, clipNear, clipFar);
+    if (!buffers.empty())
+        glDeleteBuffers(buffers.size(), &buffers[0]);
+}
 
-    glMatrixMode(GL_MODELVIEW);
-    glLoadIdentity();
+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;
 }
 
-void Window::glEnter2D() {
-    glPushAttrib(GL_ENABLE_BIT);
-    glDisable(GL_DEPTH_TEST);
-    glDisable(GL_CULL_FACE);
-    glEnable(GL_TEXTURE_2D);
+unsigned int Shader::getUniform(int n) {
+    assert(n >= 0);
+    assert(n < uniforms.size());
+    return uniforms.at(n);
+}
 
-    /* This allows alpha blending of 2D textures with the scene */
-    glEnable(GL_BLEND);
-    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+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);
+}
 
-    glViewport(0, 0, mWidth, mHeight);
+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"!?!(
+#version 330 core
+
+layout(location = 0) in vec2 vertexPosition_screen;
+layout(location = 1) in vec2 vertexUV;
+
+out vec2 UV;
+
+uniform vec2 screen;
+
+void main() {
+    vec2 halfScreen = screen / 2;
+    vec2 vertexPosition_homogenous = (vertexPosition_screen - halfScreen) / halfScreen;
 
-    glMatrixMode(GL_PROJECTION);
-    glPushMatrix();
-    glLoadIdentity();
+    gl_Position = vec4(vertexPosition_homogenous.x, -vertexPosition_homogenous.y, 0, 1);
+    UV = vertexUV;
+}
+)!?!";
+
+const char* Window::textShaderFragment = R"!?!(
+#version 330 core
 
-    glOrtho(0.0, (GLdouble)mWidth, (GLdouble)mHeight, 0.0, 0.0, 1.0);
+in vec2 UV;
 
-    glMatrixMode(GL_MODELVIEW);
-    glPushMatrix();
-    glLoadIdentity();
+out vec4 color;
 
-    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+uniform sampler2D textureSampler;
+uniform vec4 colorVar;
+
+void main() {
+    color = texture(textureSampler, UV) * colorVar;
 }
+)!?!";
+
+// --------------------------------------
 
-void Window::glExit2D() {
-    glMatrixMode(GL_MODELVIEW);
-    glPopMatrix();
+const char* Window::imguiShaderVertex = R"!?!(
+#version 330 core
 
-    glMatrixMode(GL_PROJECTION);
-    glPopMatrix();
+layout(location = 0) in vec2 vertexPosition_screen;
+layout(location = 1) in vec2 vertexUV;
+layout(location = 2) in vec4 vertexColor;
 
-    glPopAttrib();
+out vec2 UV;
+out vec4 FragColor;
 
-    glMatrixMode(GL_MODELVIEW);
+uniform vec2 screen;
+
+void main() {
+    vec2 halfScreen = screen / 2;
+    vec2 vertexPosition_homogenous = (vertexPosition_screen - halfScreen) / halfScreen;
+
+    gl_Position = vec4(vertexPosition_homogenous.x, -vertexPosition_homogenous.y, 0, 1);
+    UV = vertexUV;
+    FragColor = vertexColor;
 }
+)!?!";
 
-// Replaced the deprecated gluLookAt with slightly modified code from here:
-// http://www.khronos.org/message_boards/showthread.php/4991
-void Window::lookAt(float eyeX, float eyeY, float eyeZ,
-                    float lookAtX, float lookAtY, float lookAtZ,
-                    float upX, float upY, float upZ) {
-    // calculating the viewing vector
-    float f[3] = {
-        lookAtX - eyeX,
-        lookAtY - eyeY,
-        lookAtZ - eyeZ
-    };
+const char* Window::imguiShaderFragment = R"!?!(
+#version 330 core
 
-    // normalizing the viewing vector
-    float fMag = sqrtf(f[0] * f[0] + f[1] * f[1] + f[2] * f[2]);
-    f[0] /= fMag;
-    f[1] /= fMag;
-    f[2] /= fMag;
+in vec2 UV;
+in vec4 FragColor;
 
-    float s[3] = {
-        (f[1] * upZ) - (upY* f[2]),
-        (upX* f[2]) - (f[0] * upZ),
-        (f[0] * upY) - (upX* f[1])
-    };
+out vec4 color;
 
-    float u[3] = {
-        (s[1] * f[2]) - (f[1] * s[2]),
-        (f[0] * s[2]) - (s[0] * f[2]),
-        (s[0] * f[1]) - (f[0] * s[1])
-    };
+uniform sampler2D textureSampler;
 
-    float m[16] = {
-        s[0], u[0], -f[0], 0,
-        s[1], u[1], -f[1], 0,
-        s[2], u[2], -f[2], 0,
-        0,    0,     0, 1
-    };
-    glMultMatrixf(m);
-    glTranslatef(-eyeX, -eyeY, -eyeZ);
+void main() {
+    color = texture(textureSampler, UV) * FragColor;
 }
+)!?!";
+
+// *INDENT-ON*
 

src/system/WindowGLUT.cpp

     int argc = 1;
     char* argv[] = { new char[11], nullptr };
     strcpy(argv[0], "OpenRaider");
-    glutInit(&argc, argv);
     glutInitWindowSize(mWidth, mHeight);
-    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
+    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH | GLUT_MULTISAMPLE);
+    glutInitContextVersion(3, 3);
+    glutInitContextProfile(GLUT_CORE_PROFILE);
+    glutInit(&argc, argv);
     glutCreateWindow(VERSION);
 
     glutReshapeFunc(WindowGLUT::reshapeCallback);

src/system/WindowSDL.cpp

     mFullscreen = false;
     mMousegrab = false;
     mTextInput = false;
-    mWindow = NULL;
-    mGLContext = NULL;
+    mWindow = nullptr;
+    mGLContext = nullptr;
 }
 
 WindowSDL::~WindowSDL() {
     if (mFullscreen)
         flags |= SDL_WINDOW_FULLSCREEN;
 
-    if ((SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5) != 0)
-        || (SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5) != 0)
-        || (SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5) != 0)
-        || (SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16) != 0)
-        || (SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1) != 0)) {
+    if ((SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8) != 0)
+        || (SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8) != 0)
+        || (SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8) != 0)
+        || (SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8) != 0)
+        || (SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24) != 0)
+        || (SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1) != 0)
+        || (SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1) != 0)
+        //|| (SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 2) != 0)
+        || (SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4) != 0)
+        || (SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3) != 0)
+        || (SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3) != 0)
+        || (SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE))) {
         std::cout << "SDL_GL_SetAttribute Error: " << SDL_GetError() << std::endl;
         return -2;
     }
 
     mWindow = SDL_CreateWindow(VERSION, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
                                mWidth, mHeight, flags);
-    if (mWindow == NULL) {
+    if (mWindow == nullptr) {
         std::cout << "SDL_CreateWindow Error: " << SDL_GetError() << std::endl;
         return -3;
     }
 
     mGLContext = SDL_GL_CreateContext(mWindow);
-    if (mGLContext == NULL) {
+    if (mGLContext == nullptr) {
         std::cout << "SDL_GL_CreateContext Error: " << SDL_GetError() << std::endl;
         return -4;
     }
 
             case SDL_TEXTINPUT:
             case SDL_TEXTEDITING:
-                if (event.text.text != NULL)
+                if (event.text.text != nullptr)
                     UI::handleText(event.text.text, (event.type == SDL_TEXTEDITING));
                 break;
 

src/utils/filesystem.cpp

 #elif defined(_WIN32)
 
     char path[MAX_PATH];
-    assertEqual(SHGetFolderPath(NULL, CSIDL_PROFILE, NULL, 0, path), S_OK);
+    assertEqual(SHGetFolderPath(nullptr, CSIDL_PROFILE, nullptr, 0, path), S_OK);
     size_t lenPath = strlen(path);
     for (unsigned int i = 0; i < lenPath; i++)
         if (dir[i] == '\\')

src/utils/pcx.cpp

 #include "utils/pcx.h"
 
 int pcxCheck(const char* filename) {
-    assert(filename != NULL);
+    assert(filename != nullptr);
     assert(filename[0] != '\0');
 
     std::ifstream file(filename, std::ios::in | std::ios::binary);
 }
 
 int pcxLoad(const char* filename, unsigned char** image,
-            unsigned int* width, unsigned int* height, ColorMode* mode, unsigned int* bpp) {
-    assert(filename != NULL);
+            unsigned int* width, unsigned int* height,
+            TextureManager::ColorMode* mode, unsigned int* bpp) {
+    assert(filename != nullptr);
     assert(filename[0] != '\0');
-    assert(image != NULL);
-    assert(width != NULL);
-    assert(height != NULL);
-    assert(mode != NULL);
-    assert(bpp != NULL);
+    assert(image != nullptr);
+    assert(width != nullptr);
+    assert(height != nullptr);
+    assert(mode != nullptr);
+    assert(bpp != nullptr);
 
     std::ifstream file(filename, std::ios::in | std::ios::binary);
 
     }
 
     // Read color palette
-    unsigned char* palette = NULL;
+    unsigned char* palette = nullptr;
     if (versionFive) {
         int c = file.get();
         if ((c == 12) && file) {
             unsigned long baseIndex = (x + (y** width)) * 4;
             unsigned char alpha = 255, red = 0, green = 0, blue = 0;
 
-            if (palette != NULL) {
+            if (palette != nullptr) {
                 if (nPlanes == 1) {
                     red = palette[buffer[(y * totalBytes) + x] * 3];
                     green = palette[(buffer[(y * totalBytes) + x] * 3) + 1];
                     delete [] buffer;
                     delete [] palette;
                     delete [] *image;
-                    *image = NULL;
+                    *image = nullptr;
                     return -10;
                 }
             } else {
                     delete [] buffer;
                     delete [] palette;
                     delete [] *image;
-                    *image = NULL;
+                    *image = nullptr;
                     return -11;
                 }
             }
         }
     }
 
-    *mode = RGBA;
+    *mode = TextureManager::ColorMode::RGBA;
     *bpp = 32;
 
     delete [] buffer;

src/utils/pixel.cpp

 
 unsigned char* generateColorTexture(const unsigned char* rgba, unsigned int width,
                                     unsigned int height, unsigned int bpp) {
-    assert(rgba != NULL);
+    assert(rgba != nullptr);
     assert(width > 0);
     assert(height > 0);
     assert((bpp % 8) == 0);
                            unsigned int bpp) {
     unsigned int width = *w;
     unsigned int height = *h;
-    assert(image != NULL);
+    assert(image != nullptr);
     assert(width > 0);
     assert(height > 0);
     assert((bpp % 8) == 0);
 
     // Check to see if scaling is needed
     if (height == original_height && width == original_width)
-        return NULL;
+        return nullptr;
 
     *w = width;
     *h = height;

src/utils/png.cpp

 int pngCheck(const char* filename) {
     png_byte header[8];
 
-    assert(filename != NULL);
+    assert(filename != nullptr);
     assert(filename[0] != '\0');
 
     FILE* fp = fopen(filename, "rb");
-    if (fp == NULL) {
+    if (fp == nullptr) {
         std::cout << "Could not open " << filename << std::endl;
         return -1;
     }
 }
 
 int pngLoad(const char* filename, unsigned char** image,
-            unsigned int* width, unsigned int* height, ColorMode* mode, unsigned int* bpp) {
+            unsigned int* width, unsigned int* height,
+            TextureManager::ColorMode* mode, unsigned int* bpp) {
     png_byte header[8];
 
-    assert(filename != NULL);
+    assert(filename != nullptr);
     assert(filename[0] != '\0');
-    assert(image != NULL);
-    assert(width != NULL);
-    assert(height != NULL);
-    assert(mode != NULL);
-    assert(bpp != NULL);
+    assert(image != nullptr);
+    assert(width != nullptr);
+    assert(height != nullptr);
+    assert(mode != nullptr);
+    assert(bpp != nullptr);
 
     FILE* fp = fopen(filename, "rb");
-    if (fp == NULL) {
+    if (fp == nullptr) {
         std::cout << "Could not open " << filename << std::endl;
         return -1;
     }
         return -2;
     }
 
-    png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+    png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
     if (!png_ptr) {
         std::cout << "png_create_read_struct returned 0." << std::endl;
         fclose(fp);
     png_infop info_ptr = png_create_info_struct(png_ptr);
     if (!info_ptr) {
         std::cout << "png_create_info_struct returned 0." << std::endl;
-        png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL);
+        png_destroy_read_struct(&png_ptr, (png_infopp)nullptr, (png_infopp)nullptr);
         fclose(fp);
         return -4;
     }
     png_infop end_info = png_create_info_struct(png_ptr);
     if (!end_info) {
         std::cout << "png_create_info_struct returned 0." << std::endl;
-        png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp) NULL);
+        png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp) nullptr);
         fclose(fp);
         return -5;
     }
     png_uint_32 tmpWidth, tmpHeight;
 
     png_get_IHDR(png_ptr, info_ptr, &tmpWidth, &tmpHeight, &bit_depth, &color_type,
-                 NULL, NULL, NULL);
+                 nullptr, nullptr, nullptr);
 
     *width = tmpWidth;
     *height = tmpHeight;
     delete [] row_pointers;
     fclose(fp);
 
-    if (color_type == PNG_COLOR_TYPE_GRAY) {
-        *mode = GREYSCALE;
-        *bpp = 8;
-    } else if (color_type == PNG_COLOR_TYPE_RGB) {
-        *mode = RGB;
+    if (color_type == PNG_COLOR_TYPE_RGB) {
+        *mode = TextureManager::ColorMode::RGB;
         *bpp = 24;
     } else if (color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
-        *mode = RGBA;
+        *mode = TextureManager::ColorMode::RGBA;
         *bpp = 32;
     } else {
         std::cout << filename << ": Unknown libpng color type " << color_type << std::endl;
 }
 
 int pngSave(const char* filename, unsigned char* image,
-            unsigned int width, unsigned int height, ColorMode mode, unsigned int bpp) {
-    assert(filename != NULL);
+            unsigned int width, unsigned int height,
+            TextureManager::ColorMode mode, unsigned int bpp) {
+    assert(filename != nullptr);
     assert(filename[0] != '\0');
-    assert(image != NULL);
+    assert(image != nullptr);
     assert(width > 0);
     assert(height > 0);
 
         return -1;
     }
 
-    png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+    png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
 
     if (!png_ptr) {
         std::cout << "png_create_write_struct failed" << std::endl;
     }
 
     int color_type;
-    if ((mode == GREYSCALE) && (bpp == 8)) {
-        color_type = PNG_COLOR_TYPE_GRAY;
-    } else if (((mode == RGB) || (mode == BGR)) && (bpp == 24)) {
-        if (mode == BGR) {
+    if (((mode == TextureManager::ColorMode::RGB)
+                || (mode == TextureManager::ColorMode::BGR)) && (bpp == 24)) {
+        if (mode == TextureManager::ColorMode::BGR) {
             bgr2rgb24(image, width, height);
         }
         color_type = PNG_COLOR_TYPE_RGB;
-    } else if (((mode == RGBA) || (mode == BGRA)) && (bpp == 32)) {
-        if (mode == BGRA) {
+    } else if (((mode == TextureManager::ColorMode::RGBA)
+                || (mode == TextureManager::ColorMode::BGRA)) && (bpp == 32)) {
+        if (mode == TextureManager::ColorMode::BGRA) {
             bgra2rgba32(image, width, height);
         }
         color_type = PNG_COLOR_TYPE_RGB_ALPHA;
         return -8;
     }
 
-    png_write_end(png_ptr, NULL);
+    png_write_end(png_ptr, nullptr);
 
     delete [] row_pointers;
     fclose(fp);

src/utils/tga.cpp

 int tgaCheck(const char* filename) {
     char buffer[10];
 
-    assert(filename != NULL);
+    assert(filename != nullptr);
     assert(filename[0] != '\0');
 
     FILE* f = fopen(filename, "rb");
     tga_t header;
     char comment[256];
     unsigned char pixel[4];
-    unsigned char* swap_row = NULL;
+    unsigned char* swap_row = nullptr;
     unsigned char tmp, packet;
     bool must_flip = 0;
     unsigned int size;
     unsigned int i, j;
 
-    assert(filename != NULL);
+    assert(filename != nullptr);
     assert(filename[0] != '\0');
-    assert(image != NULL);
-    assert(width != NULL);
-    assert(height != NULL);
-    assert(type != NULL);
+    assert(image != nullptr);
+    assert(width != nullptr);
+    assert(height != nullptr);
+    assert(type != nullptr);
 
     FILE* f = fopen(filename, "rb");
     if (!f) {
         printf("Comment: '%s'\n", comment);
     }
 
-    *image = NULL;
+    *image = nullptr;
     size = header.width * header.height;
 
     if (!size || (!(header.colormap_type == 0 && (header.image_type == 2
     //unsigned int i;
     //unsigned char tmp;
 
-    assert(filename != NULL);
+    assert(filename != nullptr);
     assert(filename[0] != '\0');
-    assert(image != NULL);
+    assert(image != nullptr);
     assert(width > 0);
     assert(height > 0);
 

test/CMakeLists.txt

 
 #################################################################
 
-add_executable (tester_math EXCLUDE_FROM_ALL
-    "math.cpp" "../src/math/math.cpp"
-    "../src/math/Vec3.cpp"
-)
-add_dependencies (check tester_math)
-add_test (NAME test_math COMMAND tester_math)
-
-#################################################################
-
 add_executable (tester_script EXCLUDE_FROM_ALL
     "Script.cpp" "../src/Script.cpp" "../src/main.cpp"
     "../src/utils/binary.cpp" "../src/Exception.cpp"

test/math.cpp

-/*!
- * \file test/math.cpp
- * \brief Math Unit Test
- *
- * \author xythobuz
- */
-
-#include <iostream>
-
-#include "global.h"
-#include "math/math.h"
-#include "math/Vec3.h"
-
-#define check(x) if (!(x)) { \
-    std::cout << "Test failed: " << #x << std::endl; \
-    return -1; \
-}
-
-int main() {
-    // math.h
-    check(equalEpsilon(42.23f, 42.23f));
-    check(!equalEpsilon(42.23f, 23.42f));
-
-    // Vec3.h
-    Vec3 a(42.0f, 23.0f, 66.0f);
-    Vec3 b(23.0f, 66.0f, 42.0f);
-    Vec3 result(-3390.0f, -246.0f, 2243.0f);
-    check(Vec3::cross(a, b) == result);
-
-    check(equalEpsilon(a * b, 5256.0f));
-
-    return 0;
-}
-