Auto code indentation [skip ci]

CMakeLists.txt

         # Clean doc files
         set_directory_properties (PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "doc")
     endif (DOXYGEN_FOUND)
+
+    #################################################################
+
+    # Auto-format code
+    add_custom_target (format
+        COMMAND astyle -A14s4pHUk1OocxC100z2SKNLm1Qxynr "include/*.h"
+        COMMAND astyle -A14s4pHUk1OocxC100z2SKNLm1Qxynr "src/*.cpp" --exclude=src/deps
+        COMMAND astyle -A14s4pHUk1OocxC100z2SKNLm1Qxynr "test/*.cpp" "test/*.h"
+        WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+        COMMENT "Auto-Formatting code..." VERBATIM
+    )
 endif (${CMAKE_GENERATOR} STREQUAL "Unix Makefiles")
 

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20141018 ]
+    * Added target to auto-indent code using astyle and used it.
+
     [ 20141016 ]
     * ImGuis Font can now be used if no other is available
     * Added [Binspector](https://github.com/binspector/binspector) binary file format template

include/Camera.h

  * \brief Camera class
  */
 class Camera {
-public:
+  public:
     /*!
      * \brief Constructs an object of Camera
      */
      */
     void command(enum camera_command cmd);
 
-private:
+  private:
 
     void rotate(float angle, float x, float y, float z);
 
     float mRotationDeltaY; //!< Vertical mouse sensitivity
 };
 
-Camera &getCamera();
+Camera& getCamera();
 
 #endif

include/Console.h

 #include <vector>
 
 class Console {
-public:
+  public:
     static void display();
 
-private:
+  private:
     const static int bufferLength = 256;
     static char buffer[bufferLength + 1];
     static bool scrollToBottom;

include/Entity.h

 #include "TombRaider.h"
 
 class Entity {
-public:
+  public:
     typedef enum {
         MoveTypeWalkNoSwim = -1,
         MoveTypeWalk       = 0,
         MoveTypeSwim       = 3
     } MoveType;
 
-    Entity(TombRaider &tr, unsigned int index, unsigned int i, 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);
+    bool operator<(Entity& o);
+    static bool compare(Entity* a, Entity* b);
     void display();
     void move(char movement);
     void print();
 
-    SkeletalModel &getModel();
+    SkeletalModel& getModel();
     void setSkeletalModel(unsigned int model);
     MoveType getMoveType();
     void setMoveType(MoveType m);
     unsigned long getIdleAnimation();
     void setIdleAnimation(unsigned long index);
 
-private:
+  private:
     float pos[3];
     float angles[3];
     long room;

include/Exception.h

 #include <string>
 
 class Exception : std::runtime_error {
-public:
-    Exception(const char *what);
-    Exception(const std::string &what);
+  public:
+    Exception(const char* what);
+    Exception(const std::string& what);
 
     static std::string getLastException();
 
-private:
+  private:
     static std::string lastException;
 
     virtual void foo(); //!< We don't want to emit a vtable in every translation unit

include/Font.h

  * \brief Font interface
  */
 class Font {
-public:
+  public:
     static void shutdown();
 
     static int initialize(std::string font = "");
     static unsigned int heightText(float scale, unsigned int maxWidth, std::string s);
 
     static void drawText(unsigned int x, unsigned int y, float scale,
-            const unsigned char color[4], std::string s);
+                         const unsigned char color[4], std::string s);
 
     static void drawTextWrapped(unsigned int x, unsigned int y, float scale,
-            const unsigned char color[4], unsigned int maxWidth, std::string s);
+                                const unsigned char color[4], unsigned int maxWidth, std::string s);
 
     static void drawTextCentered(unsigned int x, unsigned int y, float scale,
-            const unsigned char color[4], unsigned int width, std::string s);
+                                 const unsigned char color[4], unsigned int width, std::string s);
 
-private:
+  private:
     static bool isInit;
     static std::string fontName;
 };

include/FontImGui.h

  * \brief Default Font implementation
  */
 class FontImGui {
-public:
+  public:
     static unsigned int widthText(float scale, std::string s);
 
     static unsigned int heightText(float scale, unsigned int maxWidth, std::string s);
 
     static void drawText(unsigned int x, unsigned int y, float scale,
-            const unsigned char color[4], std::string s);
+                         const unsigned char color[4], std::string s);
 
     static void drawTextWrapped(unsigned int x, unsigned int y, float scale,
-            const unsigned char color[4], unsigned int maxWidth, std::string s);
+                                const unsigned char color[4], unsigned int maxWidth, std::string s);
 };
 
 #endif

include/FontSDL.h

  * \brief SDL Font implementation
  */
 class FontSDL {
-public:
+  public:
     static void shutdown();
 
     static int initialize(std::string font);
     static unsigned int heightText(float scale, unsigned int maxWidth, std::string s);
 
     static void drawText(unsigned int x, unsigned int y, float scale,
-            const unsigned char color[4], std::string s);
+                         const unsigned char color[4], std::string s);
 
     static void drawTextWrapped(unsigned int x, unsigned int y, float scale,
-            const unsigned char color[4], unsigned int maxWidth, std::string s);
+                                const unsigned char color[4], unsigned int maxWidth, std::string s);
 
-private:
+  private:
     static bool mFontInit;
-    static TTF_Font *mFont;
+    static TTF_Font* mFont;
     static unsigned int mFontTexture;
 };
 

include/FontTRLE.h

  * \brief Tomb Raider Level Editor Font loader
  */
 class FontTRLE {
-public:
+  public:
     static void shutdown();
 
     static int initialize(std::string font);
     static unsigned int heightText(float scale, unsigned int maxWidth, std::string s);
 
     static void drawText(unsigned int x, unsigned int y, float scale,
-            const unsigned char color[4], std::string s);
+                         const unsigned char color[4], std::string s);
 
     static void drawTextWrapped(unsigned int x, unsigned int y, float scale,
-            const unsigned char color[4], unsigned int maxWidth, std::string s);
+                                const unsigned char color[4], unsigned int maxWidth, std::string s);
 
-private:
+  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]);
+                          float scale, const unsigned char color[4]);
 
     static bool mFontInit;
     static unsigned int mFontTexture;

include/Game.h

 #include "TombRaider.h"
 
 class Game {
-public:
+  public:
 
     Game();
     ~Game();
 
     bool isLoaded();
 
-    int loadLevel(const char *level);
+    int loadLevel(const char* level);
 
     void destroy();
 
     unsigned int getTextureStart();
     unsigned int getTextureOffset();
 
-    Entity &getLara();
+    Entity& getLara();
 
-private:
+  private:
 
     void processPakSounds();
     void processTextures();
     long mLara;
 };
 
-Game &getGame();
+Game& getGame();
 
 #endif

include/Log.h

 #include <vector>
 
 class Log {
-public:
+  public:
 
     const static char endl = '\n';
 
         return (*this);
     }
 
-private:
+  private:
     std::vector<std::string> mHistory;
     std::ostringstream printBuffer;
 };
 
-Log &getLog();
+Log& getLog();
 
 #endif
 

include/Menu.h

 #include <functional>
 
 class Menu {
-public:
+  public:
 
     virtual ~Menu() { }
 
     virtual void handleKeyboard(KeyboardButton key, bool pressed) = 0;
 
     virtual void handleMouseClick(unsigned int x, unsigned int y,
-            KeyboardButton button, bool released) = 0;
+                                  KeyboardButton button, bool released) = 0;
 
     virtual void handleMouseScroll(int xrel, int yrel) = 0;
 
 
     void setVisible(bool v) { visible = v; }
 
-protected:
+  protected:
 
     virtual void showDialog(std::string msg, std::string btn1, std::string btn2,
-            std::function<int (bool state)> callback = std::function<int (bool)>());
+                            std::function<int (bool state)> callback = std::function<int (bool)>());
 
     virtual void ackDialog();
 
     virtual bool handleKeyboardDialog(KeyboardButton key, bool pressed);
 
     virtual bool handleMouseClickDialog(unsigned int x, unsigned int y,
-            KeyboardButton button, bool released);
+                                        KeyboardButton button, bool released);
 
     virtual bool handleMouseScrollDialog(int xrel, int yrel);
 
     bool visible;
 };
 
-Menu &getMenu();
+Menu& getMenu();
 
 #endif
 

include/MenuFolder.h

  * \brief Menu 'overlay'
  */
 class MenuFolder : public Menu {
-public:
+  public:
 
     /*!
      * \brief Constructs an object of MenuFolder
     virtual void display();
     virtual void handleKeyboard(KeyboardButton key, bool pressed);
     virtual void handleMouseClick(unsigned int x, unsigned int y,
-            KeyboardButton button, bool released);
+                                  KeyboardButton button, bool released);
     virtual void handleMouseScroll(int xrel, int yrel);
 
-private:
+  private:
 
     int init(std::string s);
-    int init(Folder *folder, bool filter = true);
+    int init(Folder* folder, bool filter = true);
     virtual void loadOrOpen();
 
     long mCursor;
     long mMin;
 
-    Folder *mapFolder;
+    Folder* mapFolder;
     bool hiddenState;
 };
 

include/Mesh.h

  * \brief OpenGL Mesh
  */
 class Mesh {
-public:
+  public:
 
     typedef enum {
         MeshModeSolid,
         unsigned int cnum_alpha_triangles;
 
         unsigned int num_texcoors;
-        float **texcoors; // 2D
+        float** texcoors; // 2D
 
         unsigned int num_texcoors2;
-        float **texcoors2; // 2D
+        float** texcoors2; // 2D
 
         //! Arrays of triangle indices sorted by texture
         unsigned int num_triangles;
-        unsigned int *triangles; //!< ABCABCABC...
+        unsigned int* triangles; //!< ABCABCABC...
 
         //! Arrays of alpha triangle indices sorted by texture
         unsigned int num_alpha_triangles;
-        unsigned int *alpha_triangles; //!< ABCABCABC...
+        unsigned int* alpha_triangles; //!< ABCABCABC...
     } tris_t;
 
     typedef struct {
         unsigned int cnum_alpha_quads;
 
         unsigned int num_texcoors;
-        float **texcoors; // 2D
+        float** texcoors; // 2D
 
         unsigned int num_texcoors2;
-        float **texcoors2; // 2D
+        float** texcoors2; // 2D
 
         //! Arrays of rectangle indices sorted by texture
         unsigned int num_quads;
-        unsigned int *quads; //!< ABCDABCDABCD...
+        unsigned int* quads; //!< ABCDABCDABCD...
 
         //! Arrays of alpha rectangle indices sorted by texture
         unsigned int num_alpha_quads;
-        unsigned int *alpha_quads; //!< ABCDABCDABCD...
+        unsigned int* alpha_quads; //!< ABCDABCDABCD...
 
     } rect_t;
 
 
     void allocateVertices(unsigned int n);
 
-    void bufferColorArray(unsigned int colorCount, float *colors);
+    void bufferColorArray(unsigned int colorCount, float* colors);
 
-    void bufferNormalArray(unsigned int normalCount, float *normals);
+    void bufferNormalArray(unsigned int normalCount, float* normals);
 
     void bufferTriangles(unsigned int count,
-                            unsigned int *indices, float *texCoords,
-                            int *textures, unsigned int *flags);
+                         unsigned int* indices, float* texCoords,
+                         int* textures, unsigned int* flags);
 
-    void bufferVertexArray(unsigned int vertexCount, float *vertices);
+    void bufferVertexArray(unsigned int vertexCount, float* vertices);
 
     void setColor(unsigned int index, float r, float g, float b, float a);
 
     void sortFacesByTexture();
 
     void addFace(int textureIndex, int textureIndexB, unsigned int flags,
-                    unsigned int vertexIndexCount, float *vertexIndices);
+                 unsigned int vertexIndexCount, float* vertexIndices);
 
     void addTexTiledFace(int textureIndex, int textureIndexB,
-                            unsigned int flags, unsigned int indexCount,
-                            float *vertexIndices, float *texcoords);
+                         unsigned int flags, unsigned int indexCount,
+                         float* vertexIndices, float* texcoords);
 
-    void bufferTexcoords(unsigned int texcoordCount, float *texcoords);
+    void bufferTexcoords(unsigned int texcoordCount, float* texcoords);
 
     void duplicateArraysForTexTiledTexcoords();
 #endif
     MeshMode mMode;
 
     unsigned int mNumVertices;
-    float **mVertices; //!< XYZ
+    float** mVertices; //!< XYZ
 
     unsigned int mNumNormals;
-    float **mNormals; //!< IJK
+    float** mNormals; //!< IJK
 
     unsigned int mNumColors;
-    float **mColors; //!< RGBA
+    float** mColors; //!< RGBA
 
     unsigned int mNumTris;
-    tris_t *mTris;
+    tris_t* mTris;
 
     unsigned int mNumQuads;
-    rect_t *mQuads;
+    rect_t* mQuads;
 
     unsigned int mTriangleCount;
-    int *mTriangleTextures;
-    unsigned int *mTriangleIndices;
-    unsigned int *mTriangleFlags;
-    float *mTriangleTexCoordArray;
-
-    float *mVertexArray;
-    float *mNormalArray;
-    float *mColorArray;
+    int* mTriangleTextures;
+    unsigned int* mTriangleIndices;
+    unsigned int* mTriangleFlags;
+    float* mTriangleTexCoordArray;
+
+    float* mVertexArray;
+    float* mNormalArray;
+    float* mColorArray;
 };
 
 #endif

include/Render.h

  * \brief OpenRaider Renderer class
  */
 class Render {
-public:
+  public:
 
     typedef enum {
         modeDisabled,
      * \brief Makes a screenshot, writes to disk
      * \param filenameBase basename of file to be written
      */
-    void screenShot(const char *filenameBase);
+    void screenShot(const char* filenameBase);
 
     /*!
      * \brief Gets current rendering mode
      */
     bool isVisible(float x, float y, float z, float radius);
 
-    bool isVisible(BoundingBox &box);
+    bool isVisible(BoundingBox& box);
 
     //! \fixme should be private
     ViewVolume mViewVolume; //!< View Volume for frustum culling
 
-private:
+  private:
 
-    static void lightRoom(Room &room);
+    static void lightRoom(Room& room);
 
     void drawLoadScreen();
 
      * only considers its linked rooms and their linked rooms.
      * \param room First room in list
      */
-    void buildRoomRenderList(Room &room);
+    void buildRoomRenderList(Room& room);
 
     /*!
      * \brief Renders Sky domes/boxes/etc by scaling factor.
      */
     void updateViewVolume();
 
-    std::vector<Room *> mRoomRenderList;
+    std::vector<Room*> mRoomRenderList;
 
     unsigned int mFlags;                  //!< Rendering flags
     unsigned int mMode;                   //!< Rendering mode
     bool mSkyMeshRotation;                //!< Should Skymesh be rotated?
 };
 
-Render &getRender();
+Render& getRender();
 
 #endif

include/Room.h

 } RoomFlags;
 
 class Room {
-public:
-    Room(TombRaider &tr, unsigned int index);
+  public:
+    Room(TombRaider& tr, unsigned int index);
     ~Room();
 
-    BoundingBox &getBoundingBox();
-    Mesh &getMesh();
+    BoundingBox& getBoundingBox();
+    Mesh& getMesh();
     void display(bool alpha);
 
     bool isWall(unsigned long sector);
-    long getSector(float x, float z, float *floor, float *ceiling);
+    long getSector(float x, float z, float* floor, float* ceiling);
     long getSector(float x, float z);
-    void getHeightAtPosition(float x, float *y, float z);
+    void getHeightAtPosition(float x, float* y, float z);
     int getAdjoiningRoom(float x, float y, float z,
-        float x2, float y2, float z2);
+                         float x2, float y2, float z2);
 
     unsigned int getNumXSectors();
     unsigned int getNumZSectors();
     long getAdjacentRoom(unsigned long index);
 
     unsigned long sizePortals();
-    Portal &getPortal(unsigned long index);
+    Portal& getPortal(unsigned long index);
 
     unsigned long sizeSectors();
-    Sector &getSector(unsigned long index);
+    Sector& getSector(unsigned long index);
 
     unsigned long sizeBox();
-    Box &getBox(unsigned long index);
+    Box& getBox(unsigned long index);
 
     unsigned long sizeModels();
-    StaticModel &getModel(unsigned long index);
+    StaticModel& getModel(unsigned long index);
 
     unsigned long sizeLights();
-    Light &getLight(unsigned long index);
+    Light& getLight(unsigned long index);
 
     unsigned long sizeSprites();
-    Sprite &getSprite(unsigned long index);
+    Sprite& getSprite(unsigned long index);
 
-private:
+  private:
     void sortModels();
 
     unsigned int flags;
     Mesh mesh;
 
     std::vector<long> adjacentRooms;
-    std::vector<Sprite *> sprites;
-    std::vector<StaticModel *> models;
-    std::vector<Portal *> portals;
-    std::vector<Box *> boxes;
-    std::vector<Sector *> sectors;
-    std::vector<Light *> lights;
+    std::vector<Sprite*> sprites;
+    std::vector<StaticModel*> models;
+    std::vector<Portal*> portals;
+    std::vector<Box*> boxes;
+    std::vector<Sector*> sectors;
+    std::vector<Light*> lights;
 
     // Was used for "depth sorting" render list, but never assigned...?!
     //float dist; // Distance to near plane, move to room?

include/RoomData.h

 #include "TombRaider.h"
 
 class BoundingBox {
-public:
+  public:
     BoundingBox();
     void getBoundingBox(float box[2][3]);
     void setBoundingBox(float min[3], float max[3]);
     bool inBox(float x, float y, float z);
     bool inBoxPlane(float x, float z);
 
-private:
+  private:
     float a[3], b[3];
 };
 
 class Light {
-public:
+  public:
     /*!
      * \brief Type a light can be of
      */
         typeDirectional = 3  //!< Directional light
     } LightType;
 
-    Light(TombRaider &tr, unsigned int room, unsigned int index);
+    Light(TombRaider& tr, unsigned int room, unsigned int index);
 
     void getPos(float p[4]);
     void getDir(float d[3]);
     float getCutoff();
     LightType getType();
 
-private:
+  private:
     float pos[4]; //! Light position in 3 space
     float dir[3]; //! Light direction
     float att;
 };
 
 class StaticModel {
-public:
-    StaticModel(TombRaider &tr, unsigned int room, unsigned int i);
+  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);
+    bool operator<(const StaticModel& other);
+    static bool compare(StaticModel* a, StaticModel* b);
 
-private:
+  private:
     int index;
     float yaw;
     float pos[3];
 };
 
 class Portal {
-public:
-    Portal(TombRaider &tr, unsigned int room, unsigned int index, Matrix &transform);
+  public:
+    Portal(TombRaider& tr, unsigned int room, unsigned int index, Matrix& transform);
 
     void getVertices(float vert[4][3]);
     int getAdjoiningRoom();
 
-private:
+  private:
     float vertices[4][3];
     float normal[3];
     int adjoiningRoom;
 };
 
 class Box {
-public:
-    Box(TombRaider &tr, unsigned int room, unsigned int index);
+  public:
+    Box(TombRaider& tr, unsigned int room, unsigned int index);
 
-private:
+  private:
     float a[3], b[3], c[3], d[3];
 };
 
 class Sector {
-public:
-    Sector(TombRaider &tr, unsigned int room, unsigned int index);
+  public:
+    Sector(TombRaider& tr, unsigned int room, unsigned int index);
     float getFloor();
     float getCeiling();
     bool isWall();
 
-private:
+  private:
     float floor;
     float ceiling;
     bool wall;

include/RunTime.h

  * \brief Main Game Singleton
  */
 class RunTime {
-public:
+  public:
 
     RunTime();
 
     bool getFPS();
     void setFPS(bool fps);
 
-private:
+  private:
     std::string baseDir;
     std::string pakDir;
     std::string audioDir;
     bool showFPS;
 };
 
-RunTime &getRunTime();
+RunTime& getRunTime();
 
 #endif
 

include/Script.h

  * \brief Game script loader
  */
 class Script {
-public:
+  public:
 
     typedef enum {
         S_English  = 0,
     Script();
     ~Script();
 
-    int load(const char *file);
+    int load(const char* file);
 
     unsigned int levelCount();
     std::string getLevelName(unsigned int i);
     void registerScriptHandler(ScriptOpCode op, std::function<int (bool, uint16_t)> func);
     int runScript(unsigned int level);
 
-private:
+  private:
 
     typedef enum {
         S_DemoVersion            = (1 << 0),  //!< Don't load a MAIN.SFX
         S_EnableCheatCode        = (1 << 11)  //!< No known effect
     } ScriptFlag;
 
-    void readStringPackage(BinaryFile &f, std::vector<std::string> &v, unsigned int n);
-    void readScriptPackage(BinaryFile &f, std::vector<std::vector<uint16_t>> &v, unsigned int n);
+    void readStringPackage(BinaryFile& f, std::vector<std::string>& v, unsigned int n);
+    void readScriptPackage(BinaryFile& f, std::vector<std::vector<uint16_t>>& v, unsigned int n);
 
     const bool opcodeHasOperand[OP_UNKNOWN] {
         true, true, true, true, true, true,

include/SkeletalModel.h

 #include "TombRaider.h"
 
 class BoneTag {
-public:
-    BoneTag(TombRaider &tr, unsigned int index, unsigned int j, unsigned int *l, unsigned int frame_offset);
+  public:
+    BoneTag(TombRaider& tr, unsigned int index, unsigned int j, unsigned int* l,
+            unsigned int frame_offset);
     void display();
 
     void getOffset(float o[3]);
     void getRotation(float r[3]);
     char getFlag();
 
-private:
+  private:
     int mesh;
     float off[3];
     float rot[3];
 };
 
 class BoneFrame {
-public:
-    BoneFrame(TombRaider &tr, unsigned int index, unsigned int frame_offset);
+  public:
+    BoneFrame(TombRaider& tr, unsigned int index, unsigned int frame_offset);
     ~BoneFrame();
 
     void getPosition(float p[3]);
 
     unsigned long size();
-    BoneTag &get(unsigned long i);
+    BoneTag& get(unsigned long i);
 
-private:
+  private:
     float pos[3];
-    std::vector<BoneTag *> tag;
+    std::vector<BoneTag*> tag;
 };
 
 class AnimationFrame {
-public:
-    AnimationFrame(TombRaider &tr, unsigned int index, int a, unsigned int *frame_offset, int frame_step);
+  public:
+    AnimationFrame(TombRaider& tr, unsigned int index, int a, unsigned int* frame_offset,
+                   int frame_step);
     ~AnimationFrame();
 
     unsigned long size();
-    BoneFrame &get(unsigned long i);
+    BoneFrame& get(unsigned long i);
 
-private:
+  private:
     char rate;
-    std::vector<BoneFrame *> frame;
+    std::vector<BoneFrame*> frame;
 };
 
 class SkeletalModel {
-public:
-    SkeletalModel(TombRaider &tr, unsigned int index, int objectId);
+  public:
+    SkeletalModel(TombRaider& tr, unsigned int index, int objectId);
     ~SkeletalModel();
     void display(unsigned long aframe, unsigned long bframe);
 
     void setPonyPos(float x, float y, float z, float angle);
 
     unsigned long size();
-    AnimationFrame &get(unsigned long i);
+    AnimationFrame& get(unsigned long i);
 
-private:
+  private:
     int id;
     bool tr4Overlay;
     bool pigtails;
     float ponytailAngle;
     float ponyOff;
     float ponyOff2;
-    std::vector<AnimationFrame *> animation;
+    std::vector<AnimationFrame*> animation;
 };
 
 #endif

include/Sound.h

  * \brief This is the audio manager for OpenRaider
  */
 class Sound {
-public:
+  public:
 
     typedef enum {
         SoundFlagsNone = 0,       //!< No effect
      * \param flags set options. Use SoundFlags enum bitwise OR-ed
      * \returns 0 for no error or < 0 error flag
      */
-    virtual int addFile(const char *filename, unsigned long *source, unsigned int flags) = 0;
+    virtual int addFile(const char* filename, unsigned long* source, unsigned int flags) = 0;
 
     /*!
      * \brief Load wav file from buffer
      * \param flags set options. Use SoundFlags enum bitwise OR-ed
      * \returns 0 for no error or < 0 error flag
      */
-    virtual int addWave(unsigned char *wav, unsigned int length, unsigned long *source, unsigned int flags) = 0;
+    virtual int addWave(unsigned char* wav, unsigned int length, unsigned long* source,
+                        unsigned int flags) = 0;
 
     /*!
      * \brief Play sound source
     virtual void stop(unsigned long source) = 0;
 };
 
-Sound &getSound();
+Sound& getSound();
 
 #endif
 

include/SoundAL.h

  * \brief This is the OpenAL audio manager
  */
 class SoundAL : public Sound {
-public:
+  public:
 
     /*!
      * \brief Constructs an object of SoundAL
      * \param flags set options. Use SoundFlags enum bitwise OR-ed
      * \returns 0 for no error or < 0 error flag
      */
-    virtual int addFile(const char *filename, unsigned long *source, unsigned int flags);
+    virtual int addFile(const char* filename, unsigned long* source, unsigned int flags);
 
     /*!
      * \brief Load wav file from buffer
      * \param flags set options. Use SoundFlags enum bitwise OR-ed
      * \returns 0 for no error or < 0 error flag
      */
-    virtual int addWave(unsigned char *wav, unsigned int length, unsigned long *source, unsigned int flags);
+    virtual int addWave(unsigned char* wav, unsigned int length, unsigned long* source,
+                        unsigned int flags);
 
     /*!
      * \brief Play sound source
      */
     virtual void stop(unsigned long source);
 
-private:
+  private:
 
     bool mEnabled;
     bool mInit;                         //!< Guard to ensure ausio system is active

include/SoundNull.h

  * \brief This is the null audio manager
  */
 class SoundNull : public Sound {
-public:
+  public:
 
     /*!
      * \brief Constructs an object of SoundNull
      * \param flags set options. Use SoundFlags enum bitwise OR-ed
      * \returns 0 for no error or < 0 error flag
      */
-    virtual int addFile(const char *filename, unsigned long *source, unsigned int flags);
+    virtual int addFile(const char* filename, unsigned long* source, unsigned int flags);
 
     /*!
      * \brief Load wav file from buffer
      * \param flags set options. Use SoundFlags enum bitwise OR-ed
      * \returns 0 for no error or < 0 error flag
      */
-    virtual int addWave(unsigned char *wav, unsigned int length, unsigned long *source, unsigned int flags);
+    virtual int addWave(unsigned char* wav, unsigned int length, unsigned long* source,
+                        unsigned int flags);
 
     /*!
      * \brief Play sound source
      */
     virtual void stop(unsigned long source);
 
-private:
+  private:
     unsigned long sources;
 };
 

include/Sprite.h

 #include "TombRaider.h"
 
 class Sprite {
-public:
-    Sprite(TombRaider &tr, unsigned int room, unsigned int index);
-    Sprite(TombRaider &tr, unsigned int item, unsigned int sequence, unsigned int index);
+  public:
+    Sprite(TombRaider& tr, unsigned int room, unsigned int index);
+    Sprite(TombRaider& tr, unsigned int item, unsigned int sequence, unsigned int index);
     void display();
 
-private:
+  private:
     float vertex[4][3];
     float texel[4][2];
     float pos[3];
 };
 
 class SpriteSequence {
-public:
-    SpriteSequence(TombRaider &tr, unsigned int item, unsigned int sequence);
+  public:
+    SpriteSequence(TombRaider& tr, unsigned int item, unsigned int sequence);
     ~SpriteSequence();
 
     unsigned long size();
-    Sprite &get(unsigned long index);
+    Sprite& get(unsigned long index);
 
-private:
-    std::vector<Sprite *> sprites;
+  private:
+    std::vector<Sprite*> sprites;
 };
 
 #endif

include/StaticMesh.h

 #include "TombRaider.h"
 
 class TexturedTriangle {
-public:
+  public:
     TexturedTriangle(int i[3], float s[6], int tex, unsigned short trans);
-    void display(float *vertices, float *colors, float *normals);
+    void display(float* vertices, float* colors, float* normals);
 
-private:
+  private:
     int index[3];
     float st[6];
     int texture;
 };
 
 class StaticMesh {
-public:
-    StaticMesh(TombRaider &tr, unsigned int index);
+  public:
+    StaticMesh(TombRaider& tr, unsigned int index);
     ~StaticMesh();
     void display();
     float getRadius();
 
-private:
+  private:
     bool dontshow;
     float center[3];
     float radius;
     unsigned int colorCount;
     unsigned int normalCount;
 
-    float *vertices;
-    float *colors;
-    float *normals;
+    float* vertices;
+    float* colors;
+    float* normals;
 
-    std::vector<TexturedTriangle *> triangles;
+    std::vector<TexturedTriangle*> triangles;
 };
 
 #endif

include/TextureManager.h

  * \brief Texture registry
  */
 class TextureManager {
-public:
+  public:
 
     enum TextureFlag {
         fUseMultiTexture = (1 << 0),
     */
     TextureManager();
 
-   /*!
-    * \brief Deconstructs an object of Texture
-    */
+    /*!
+     * \brief Deconstructs an object of Texture
+     */
     ~TextureManager();
 
     /*!
      * \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,
-                        unsigned int slot, bool filter = true);
+    int loadBufferSlot(unsigned char* image,
+                       unsigned int width, unsigned int height,
+                       ColorMode mode, unsigned int bpp,
+                       unsigned int slot, bool filter = true);
 
-    int loadImage(const char *filename);
+    int loadImage(const char* filename);
 
     /*!
      * \brief Sets an option flag
 
     void useMultiTexture(float aU, float aV, float bU, float bV);
 
-private:
-    int loadTGA(const char *filename);
-    int loadPCX(const char *filename);
-    int loadPNG(const char *filename);
+  private:
+    int loadTGA(const char* filename);
+    int loadPCX(const char* filename);
+    int loadPNG(const char* filename);
 
     std::vector<unsigned int> mTextureIds;
     unsigned int mFlags;
 };
 
-TextureManager &getTextureManager();
+TextureManager& getTextureManager();
 
 #endif
 

include/TombRaider.h

  * \brief Loads maps, meshes, textures...
  */
 class TombRaider {
-public:
+  public:
 
     /*!
      * \brief Constructs an object of TombRaider
 
     tr2_version_type Engine();
 
-    unsigned short *Frame();
+    unsigned short* Frame();
 
-    tr2_animation_t *Animation();
+    tr2_animation_t* Animation();
 
-    tr2_item_t *Item();
+    tr2_item_t* Item();
 
-    tr2_object_texture_t *ObjectTextures();
+    tr2_object_texture_t* ObjectTextures();
 
     /*!
      * \brief Get number of boxes
      */
     unsigned int getNumBoxes();
 
-    tr2_box_t *Box();
+    tr2_box_t* Box();
 
-    tr2_mesh_t *Mesh();
+    tr2_mesh_t* Mesh();
 
     /*!
      * \brief Get number of animations for a moveable
      */
     int getNumAnimsForMoveable(int moveable_index);
 
-    tr2_staticmesh_t *StaticMesh();
+    tr2_staticmesh_t* StaticMesh();
 
-    tr2_moveable_t *Moveable();
+    tr2_moveable_t* Moveable();
 
-    tr2_meshtree_t *MeshTree();
+    tr2_meshtree_t* MeshTree();
 
     /*!
      * \brief Get the sprites
      * \returns the sprite array
      */
-    tr2_sprite_texture_t *Sprite();
+    tr2_sprite_texture_t* Sprite();
 
-    tr2_sprite_sequence_t *SpriteSequence();
+    tr2_sprite_sequence_t* SpriteSequence();
 
     /*!
      * \brief Makes a 32bit RGBA image from a stexture/bmap
      * \param texture valid index into tex_special list
      * \returns 32bit RGBA image or NULL on error
      */
-    unsigned char *SpecialTexTile(int texture);
+    unsigned char* SpecialTexTile(int texture);
 
     /*!
      * \brief Get copies of texture and it's bumpmap
      * \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);
+    void Texture(int texture, unsigned char** image, unsigned char** bumpmap);
 
-    unsigned int *Palette16();
+    unsigned int* Palette16();
 
-    unsigned char *Palette8();
+    unsigned char* Palette8();
 
-    tr2_room_t *Room();
+    tr2_room_t* Room();
 
     /*!
      * \brief Check if a file is a TombRaider pak
      * \param filename file to check
      * \returns 0 if it is a TombRaider pak
      */
-    static int checkMime(const char *filename);
+    static int checkMime(const char* filename);
 
     /*!
      * \brief Loads TombRaider 1-5 pak into memory
      * \returns 0 on success, < 0 on error
      * \sa TombRaider::loadTR5()
      */
-    int Load(const char *filename);
+    int Load(const char* filename);
 
     /*!
      * \brief Makes a clamped 0.0 to 1.0 texel from coord pair
      * \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);
+    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 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 computeUV(tr2_object_texture_vert_t* st, float* u, float* v);
 
     /*!
      * \brief Get number of bump maps in loaded pak
      * \param radius will be filled with radius, not NULL
      */
     void getMeshCollisionInfo(unsigned int meshIndex,
-                                float center[3], float *radius);
+                              float center[3], float* radius);
 
     /*!
      * \brief Get SIGNED mesh count (TR encoded < 0 errors)
      * \fixme This method interface may change later
      */
     void getMeshColoredRectangle(unsigned int meshIndex,
-                                    unsigned int faceIndex,
-                                    int index[6], float color[4]);
+                                 unsigned int faceIndex,
+                                 int index[6], float color[4]);
 
     /*!
      * \brief This method is made to let you fill arrays or
      * \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);
+                                  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
      * \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);
+                                 unsigned int faceIndex,
+                                 int index[3], float st[6], int* texture,
+                                 unsigned short* transparency);
 
     /*!
      * \brief Get face counts for a given mesh.
      * \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);
+                             unsigned int* vertexCount, float** verts,
+                             unsigned int* normalCount, float** norms,
+                             unsigned int* colorCount, float** colors);
 
     /*!
      * \brief Get a single collision box from room (unified)
      * \returns 0 on success, < 0 on error
      */
     int getRoomBox(unsigned int roomIndex, unsigned int index,
-                    float *xyzA, float *xyzB, float *xyzC, float *xyzD);
+                   float* xyzA, float* xyzB, float* xyzC, float* xyzD);
 
     /*!
      * \brief Get number of collision boxes in room (unified)
     unsigned int getRoomBoxCount(unsigned int roomIndex);
 
     void getRoomInfo(unsigned int index,
-                        unsigned int *flags, float pos[3],
-                        float bboxMin[3], float bboxMax[3]);
+                     unsigned int* flags, float pos[3],
+                     float bboxMin[3], float bboxMax[3]);
 
     /*!
      * \brief Get a single light from a room (unified)
      * \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);
+                     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)
      * \returns 0 on success, < 0 on error
      */
     int getRoomModel(unsigned int roomIndex, unsigned int index,
-                        int *modelIndex, float pos[3], float *yaw);
+                     int* modelIndex, float pos[3], float* yaw);
 
     /*!
      * \brief Get number of room models in room (unified)
      * \returns 0 on success, < 0 on error
      */
     int getRoomPortal(unsigned int roomIndex, unsigned int index,
-                        int *adjoiningRoom, float normal[3], float vertices[12]);
+                      int* adjoiningRoom, float normal[3], float vertices[12]);
 
     /*!
      * \brief Get number of portals from room (unified)
      * \param flags will contain flags
      */
     void getRoomRectangle(unsigned int roomIndex, unsigned int rectangleIndex,
-                            unsigned int *indices, float *texCoords, int *texture,
-                            unsigned int *flags);
+                          unsigned int* indices, float* texCoords, int* texture,
+                          unsigned int* flags);
 
     /*!
      * \brief Get number of rectangles from room (unified)
      * \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);
+                      unsigned int* flags, float* ceiling, float* floor,
+                      int* floorDataIndex, int* boxIndex,
+                      int* roomBelow, int* roomAbove);
 
     /*!
      * \brief Get number of sectors in room (unified)
      * \returns number of sectors in room
      */
     unsigned int getRoomSectorCount(unsigned int roomIndex,
-                                    unsigned int *zSectorsCount,
-                                    unsigned int *xSectorsCount);
+                                    unsigned int* zSectorsCount,
+                                    unsigned int* xSectorsCount);
 
     void getRoomSprite(unsigned int roomIndex, unsigned int index,
-                        float scale, int *texture,
-                        float *pos, float *vertices, float *texcoords);
+                       float scale, int* texture,
+                       float* pos, float* vertices, float* texcoords);
 
     /*!
      * \brief Get number of sprites in room (unified)
      * \param flags will contain flags
      */
     void getRoomTriangle(unsigned int roomIndex, unsigned int triangleIndex,
-                            unsigned int *indices, float *texCoords, int *texture,
-                            unsigned int *flags);
+                         unsigned int* indices, float* texCoords, int* texture,
+                         unsigned int* flags);
 
     /*!
      * \brief Gets triangle data with texCoords for non-matching
      * \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);
+                          unsigned int* count, unsigned int** indices,
+                          float** texCoords, int** textures,
+                          unsigned int** flags);
 
     /*!
      * \brief Gets triangle data with duplicated vertex/color/normal
      * \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);
+                          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 rgba will contain vertex color, has to be allocated
      */
     void getRoomVertex(unsigned int roomIndex, unsigned int vertexIndex,
-                        float *xyz, float *rgba);
+                       float* xyz, float* rgba);
 
     /*!
      * \brief Get allocated vertex and color arrays and their element counts (unified)
      * \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);
+                             unsigned int* vertexCount, float** vertices,
+                             unsigned int* normalCount, float** normals,
+                             unsigned int* colorCount, float** colors);
 
     /*!
      * \brief Get number of lights in room (unified)
      * \param data will contain sound sample
      */
     void getSoundSample(unsigned int index,
-                        unsigned int *bytes, unsigned char **data);
+                        unsigned int* bytes, unsigned char** data);
 
     /*!
      * \brief Get number of loaded sound samples
      * \param filename pak to load
      * \returns < 0 on error
      */
-    int loadSFX(const char *filename);
+    int loadSFX(const char* filename);
 
     void reset();
 
      */
     void setTexelScalingFactor(float f);
 
-private:
+  private:
 
-    void extractMeshes(unsigned char *mesh_data,
-                        unsigned int num_mesh_pointers,
-                        unsigned int *mesh_pointers);
+    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);
+    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);
+    void getRiffData(unsigned int* bytes, unsigned char** data);
 
     /*!
      * \brief Get a copy of a TR4 sound sample
      * \param data will contain sound sample itself
      */
     void getRiffDataTR4(unsigned int index,
-                        unsigned int *bytes, unsigned char **data);
+                        unsigned int* bytes, unsigned char** data);
 
     /*!
      * \brief Get an array of offsets for a contiguous RIFF data stream in chunks.
      * \param numOffsets known number
      * \returns number of RIFFs found
      */
-    int getRiffOffsets(unsigned char *riffData, unsigned int riffDataBytes,
-                        unsigned int **offsets, unsigned int numOffsets);
+    int getRiffOffsets(unsigned char* riffData, unsigned int riffDataBytes,
+                       unsigned int** offsets, unsigned int numOffsets);
 
     /*!
      * \brief Makes a 32bit RGBA image from a textile.
      * \param texture valid index into textile list
      * \returns 32bit RGBA image or NULL on error
      */
-    unsigned char *getTexTile(int texture);
+    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);
+    int loadTR5(FILE* f);
 
-    static void print(const char *methodName, const char *s, ...) __attribute__((format(printf, 2, 3)));
+    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)));
+    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
     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
+    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 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
+    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
+    unsigned short* _floor_data;           //!< Floor data
     int mMeshCount;                        //!< Number of meshes this level
-    tr2_mesh_t *mMeshes;                   //!< list of meshes
+    tr2_mesh_t* mMeshes;                   //!< list of meshes
     unsigned int _num_animations;          //!< number of animations this level
-    tr2_animation_t *_animations;          //!< list of animations
+    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
+    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
+    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
+    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
+    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 short* _frames;               //!< frame data
     unsigned int _num_moveables;           //!< number of moveables this level
-    tr2_moveable_t *_moveables;            //!< list of moveables
+    tr2_moveable_t* _moveables;            //!< list of moveables
 
     uint32_t numMoveablesTR5;
-    tr5_moveable_t *moveablesTR5;
+    tr5_moveable_t* moveablesTR5;
 
     uint32_t numAnimationsTR5;
-    tr5_animation_t *animationsTR5;
+    tr5_animation_t* animationsTR5;
 
     uint32_t numObjectTexturesTR5;
-    tr5_object_texture_t *objectTexturesTR5;
+    tr5_object_texture_t* objectTexturesTR5;
 
     uint32_t numCinematicFramesTR5;
-    tr5_cinematic_frame_t *cinematicFramesTR5;
+    tr5_cinematic_frame_t* cinematicFramesTR5;
 
     uint32_t numFlyByCamerasTR5;
-    tr5_flyby_camera_t *flyByCamerasTR5;
+    tr5_flyby_camera_t* flyByCamerasTR5;
 
     unsigned int _num_static_meshes;        //!< number of static meshes this level
-    tr2_staticmesh_t *_static_meshes;       //!< static meshes
+    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
+    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
+    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
+    tr2_sprite_sequence_t* _sprite_sequences; //!< sprite sequence data
     int  _num_cameras;                        //!< Number of Cameras
-    tr2_camera_t  *_cameras;                  //!< cameras
+    tr2_camera_t*  _cameras;                  //!< cameras
     int  _num_sound_sources;                  //!< Number of Sounds
-    tr2_sound_source_t *_sound_sources;       //!< sounds
+    tr2_sound_source_t* _sound_sources;       //!< sounds
     int  _num_boxes;                          //!< Number of Boxes
-    tr2_box_t *_boxes;                        /*!< boxes - looks like
+    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 -
+    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
+    short*  _zones;                           //!< Boxes2
     int  _num_animated_textures;              //!< Number of AnimTextures
-    short  *_animated_textures;               //!< Animtextures
+    short*  _animated_textures;               //!< Animtextures
     int  _num_items;                          //!< Number of Items
-    tr2_item_t *_items;                       //!< Items
-    unsigned char  *_light_map;               //!< Colour-light maps
+    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
+    tr2_cinematic_frame_t* _cinematic_frames; //!< Cut-scene frames
     short  _num_demo_data;                    //!< Number of Demo Data
-    unsigned char  *_demo_data;               //!< Demo data
+    unsigned char*  _demo_data;               //!< Demo data
     float mRoomVertexLightingFactor;
     float mTexelScale;
 
     // Sound data
-    short  *mSoundMap;                   //!< Sound map
+    short*  mSoundMap;                   //!< Sound map
     int  mNumSoundDetails;               //!< Number of SampleModifiers
-    tr2_sound_details_t *mSoundDetails;  //!< Sample modifiers
+    tr2_sound_details_t* mSoundDetails;  //!< Sample modifiers
     int  mNumSampleIndices;              //!< Number of Sample Indices
-    int  *mSampleIndices;                //!< Sample indices
-    unsigned int *mSampleIndicesTR5;
+    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
+    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 char* mRiffData;            //!< SFX RIFF data in chunks
     unsigned int mNumTR4Samples;
-    unsigned char **mTR4Samples;
-    unsigned int *mTR4SamplesSz;
+    unsigned char** mTR4Samples;
+    unsigned int* mTR4SamplesSz;
 
     // For packed Fread emu/wrapper
-    unsigned char *mCompressedLevelData;     //!< Buffer used to emulate fread with uncompressed libz data
+    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

include/TombRaiderData.h

     unsigned char r; //!< Red part
     unsigned char g; //!< Green part
     unsigned char b; //!< Blue part
-} __attribute__ ((packed)) tr2_colour_t;
+} __attribute__((packed)) tr2_colour_t;
 
 /*!
  * \brief Basic vertex structure.
     short x;
     short y;
     short z;
-} __attribute__ ((packed)) tr2_vertex_t;
+} __attribute__((packed)) tr2_vertex_t;
 
 /*!
  * \brief A rectangular (quad) face definition.
 typedef struct {
     unsigned short vertices[4];
     unsigned short texture;
-} __attribute__ ((packed)) tr2_quad_t; // was tr2_face4
+} __attribute__((packed)) tr2_quad_t;  // was tr2_face4
 
 typedef struct {
     unsigned short vertices[4]; //!< The 4 vertices of a quad
      * the strength of this effect:
      * the more bigger the value is, the more visible is the effect.
      */
-} __attribute__ ((packed)) tr4_quad_t;
+} __attribute__((packed)) tr4_quad_t;
 
 /*!
  * \brief A triangular face definition.
 typedef struct {
     unsigned short vertices[3];
     unsigned short texture;
-} __attribute__ ((packed)) tr2_tri_t; // was tr2_face3
+} __attribute__((packed)) tr2_tri_t;  // was tr2_face3
 
 typedef struct {
     unsigned short vertices[3]; //!< The 3 vertices of a tri
     unsigned short texture;     //!< Object-texture index
     unsigned short lighting;    //!< Transparency flag & strength of the highlight
-} __attribute__ ((packed)) tr4_tri_t;
+} __attribute__((packed)) tr4_tri_t;
 
 /*!
  * \brief An 8-bit texture tile (65536 bytes).
  */
 typedef struct {
     unsigned char tile[256 * 256];
-} __attribute__ ((packed)) tr2_textile8_t;
+} __attribute__((packed)) tr2_textile8_t;
 
 /*!
  * \brief A 16-bit texture tile (131072 bytes).
  */
 typedef struct {
     unsigned short tile[256 * 256];
-} __attribute__ ((packed)) tr2_textile16_t;
+} __attribute__((packed)) tr2_textile16_t;
 
 /*!
  * \brief A 32-bit texture tile (262144 bytes).
  */
 typedef struct {
     unsigned int tile[256 * 256];
-} __attribute__ ((packed)) tr2_textile32_t;
+} __attribute__((packed)) tr2_textile32_t;
 
 /*!
  * \brief The "header" of a room.
     int z;        //!< Z-offset of room (world coordinates)
     int y_bottom; //!< Y-offset of lowest point in room (world coordinates, actually highest value)
     int y_top;    //!< Y-offset of highest point in room (world coordinates, actually lowest value)
-} __attribute__ ((packed)) tr2_room_info_t;
+} __attribute__((packed)) tr2_room_info_t;
 
 /*!
  * \brief Portal structure.
     unsigned short adjoining_room; //!< Which room this "door" leads to
     tr2_vertex_t normal;           //!< Which way the "door" faces
     tr2_vertex_t vertices[4];      //!< The corners of the "door"
-} __attribute__ ((packed)) tr2_room_portal_t;
+} __attribute__((packed)) tr2_room_portal_t;
 
 /*!
  * \brief Room sector structure.
     char floor;                //!< Absolute height of floor (Multiply by 256 for world coordinates)
     unsigned char  room_above; //!< The number of the room above this one (-1 or 255 if none)
     char ceiling;              //!< Absolute height of ceiling (multiply by 256 for world coordinates)
-} __attribute__ ((packed)) tr2_room_sector_t;
+} __attribute__((packed)) tr2_room_sector_t;
 
 /*!
  * \brief Room lighting structure.
     unsigned short intensity2;
     unsigned int fade1;
     unsigned int fade2;
-} __attribute__ ((packed)) tr2_room_light_t;
+} __attribute__((packed)) tr2_room_light_t;
 
 typedef struct {
     int xPosition;           //!< World coords
     float length;
     float cutoff;
     float xDir, yDir, zDir;  //!< Direction?
-} __attribute__ ((packed)) tr4_room_light_t;
+} __attribute__((packed)) tr4_room_light_t;
 
 /*!
  * \brief Room vertex structure.
 typedef struct {
     tr2_vertex_t vertex;
     short lighting1;           //!< Values range from 0 to 32767 in TR3, 0=dark.
-                               /*!< I think the values ranged from 0 to 8192
-                                * in TR1/2, 0=bright.  */
+    /*!< I think the values ranged from 0 to 8192
+     * in TR1/2, 0=bright.  */
     unsigned short attributes; /*!<
                                 * * 0x8000 Something to do with water surface
                                 * * 0x4000 Under water lighting modulation
                                 */
 
     short lighting2;           //!< Seems to be the same as lighting1
-} __attribute__ ((packed)) tr2_vertex_room_t;
+} __attribute__((packed)) tr2_vertex_room_t;
 
 /*!
  * \brief Sprite structure
 typedef struct {
     short vertex;  //!< Offset into vertex list
     short texture; //!< Offset into texture list
-} __attribute__ ((packed)) tr2_room_sprite_t;
+} __attribute__((packed)) tr2_room_sprite_t;
 
 /*!
  * \brief Room mesh structure.
  */
 typedef struct tr2_room_data_s {
     short num_vertices;          //!< Number of vertices in the following list
-    tr2_vertex_room_t *vertices; //!< List of vertices (relative coordinates)
+    tr2_vertex_room_t* vertices; //!< List of vertices (relative coordinates)
     short num_rectangles;        //!< Number of textured rectangles
-    tr2_quad_t *rectangles;      //!< List of textured rectangles
+    tr2_quad_t* rectangles;      //!< List of textured rectangles
     short num_triangles;         //!< Number of textured triangles
-    tr2_tri_t *triangles;        //!< List of textured triangles
+    tr2_tri_t* triangles;        //!< List of textured triangles
     short num_sprites;           //!< Number of sprites
-    tr2_room_sprite_t *sprites;  //!< List of sprites
-} __attribute__ ((packed)) tr2_room_data_t;
+    tr2_room_sprite_t* sprites;  //!< List of sprites
+} __attribute__((packed)) tr2_room_data_t;
 
 /*!
  * \brief Room static mesh data.
     unsigned short intensity1;
     unsigned short intensity2;
     unsigned short object_id;  //!< Which StaticMesh item to draw
-} __attribute__ ((packed)) tr2_room_staticmesh_t;
+} __attribute__((packed)) tr2_room_staticmesh_t;
 
 
 /*!
 typedef struct {
     tr2_room_info_t info;                 //!< where the room exists, in world coordinates
     unsigned int num_data_words;          //!< number of data words (bitu16)
-    unsigned char *data;                  //!< the raw data from which the rest of this is derived
+    unsigned char* data;                  //!< the raw data from which the rest of this is derived
     tr2_room_data_t room_data;            //!< the room mesh
     unsigned short num_portals;           //!< number of visibility portals that leave this room
-    tr2_room_portal_t *portals;           //!< list of visibility portals
+    tr2_room_portal_t* portals;           //!< list of visibility portals
     unsigned short num_zsectors;          //!< width of sector list
     unsigned short num_xsectors;          //!< height of sector list
-    tr2_room_sector_t *sector_list;       //!< list of sectors in this room
+    tr2_room_sector_t* sector_list;       //!< list of sectors in this room
     short intensity1;
     short intensity2;
     short light_mode;
     unsigned short num_lights;            //!< number of lights in this room
-    tr2_room_light_t *lights;             //!< list of lights
+    tr2_room_light_t* lights;             //!< list of lights
     unsigned short num_static_meshes;     //!< number of static meshes
-    tr2_room_staticmesh_t *static_meshes; //!< static meshes
+    tr2_room_staticmesh_t* static_meshes; //!< static meshes
     short  alternate_room;
     short  flags;                         /*!< * 0x0001 - room is filled with water
                                            *   * 0x0020 - Lara's ponytail gets blown by the wind */
     tr2_colour_t room_light_colour;       //!< TR3 ONLY!
-    tr4_room_light_t *tr4Lights;          //!< TR4 ONLY!
-} __attribute__ ((packed)) tr2_room_t;
+    tr4_room_light_t* tr4Lights;          //!< TR4 ONLY!
+} __attribute__((packed)) tr2_room_t;
 
 /*!
  * \brief Animation structure up to TR3.
     short unknown3;
     short unknown4;
     unsigned short frame_start;         //!< first frame in this animation
-    unsigned short frame_end;           //!< last frame in this animation (numframes = (End - Start) + 1)
+    unsigned short
+    frame_end;           //!< last frame in this animation (numframes = (End - Start) + 1)
     unsigned short next_animation;
     unsigned short next_frame;
     unsigned short num_state_changes;
     unsigned short state_change_offset; //!< offset into StateChanges[]
     unsigned short num_anim_commands;
     unsigned short anim_command;        //!< offset into AnimCommands[]
-} __attribute__ ((packed)) tr2_animation_t;
+} __attribute__((packed)) tr2_animation_t;
 
 /*!
  * \brief Data for an animation structure (40 bytes in TR4 vice 32 in TR1/2/3)
     unsigned short state_change_offset; //!< same meaning as in TR3
     unsigned short num_anim_commands;   //!< same meaning as in TR3
     unsigned short anim_command;        //!< same meaning as in TR3
-} __attribute__ ((packed)) tr4_animation_t;
+} __attribute__((packed)) tr4_animation_t;
 
 /*!
  * \brief State Change structure
     unsigned short state_id;
     unsigned short num_anim_dispatches; //!< Number of dispatches (seems to always be 1..5)
     unsigned short anim_dispatch;       //!< Offset into AnimDispatches[]
-} __attribute__ ((packed)) tr2_state_change_t;
+} __attribute__((packed)) tr2_state_change_t;
 
 /*!
  * \brief Animation Dispatch structure
     short high;
     short next_animation;
     short next_frame;
-} __attribute__ ((packed)) tr2_anim_dispatch_t;
+} __attribute__((packed)) tr2_anim_dispatch_t;
 
 /*!
  * \brief AnimCommand structure
  */
 typedef struct {
     short value;
-} __attribute__ ((packed)) tr2_anim_command_t;
+} __attribute__((packed)) tr2_anim_command_t;
 
 /*!
  * \brief MeshTree structure.
     int x;
     int y;
     int z;
-} __attribute__ ((packed)) tr2_meshtree_t;
+} __attribute__((packed)) tr2_meshtree_t;
 
 /*!
  * \brief Moveable structure.
     unsigned int mesh_tree;       //!< offset into MeshTree[]
     unsigned int frame_offset;    //!< byte offset into Frames[] (divide by 2 for Frames[i])
     unsigned short animation;     //!< offset into Animations[]
-} __attribute__ ((packed)) tr2_moveable_t;
+} __attribute__((packed)) tr2_moveable_t;
 
 /*!
  * \brief StaticMesh structure.
     unsigned short starting_mesh;    //!< first mesh
     tr2_vertex_t bounding_box[2][2];
     unsigned short flags;
-} __attribute__ ((packed)) tr2_staticmesh_t;
+} __attribute__((packed)) tr2_staticmesh_t;
 
 /*!
  * \brief Object texture vertex structure.
     unsigned char xpixel;
     unsigned char ycoordinate;
     unsigned char ypixel;
-} __attribute__ ((packed)) tr2_object_texture_vert_t;
+} __attribute__((packed)) tr2_object_texture_vert_t;
 
 /*!
  * \brief Object texture structure.
                                             */
     unsigned short tile;                   //!< index into textile list
     tr2_object_texture_vert_t vertices[4]; //!< the four corners of the texture
-} __attribute__ ((packed)) tr2_object_texture_t;
+} __attribute__((packed)) tr2_object_texture_t;
 
 /*!
  * \brief Sprite texture structure.
     short top_side;
     short right_side;
     short bottom_side;
-} __attribute__ ((packed)) tr2_sprite_texture_t;
+} __attribute__((packed)) tr2_sprite_texture_t;
 
 /*!
  * \brief Sprite Sequence structure
     int object_id;         //!< Item identifier (same numbering as in tr2_moveable)
     short negative_length; //!< Negative of "how many sprites are in this sequence"
     short offset;          //!< Where (in sprite texture list) this sequence starts
-} __attribute__ ((packed)) tr2_sprite_sequence_t;
+} __attribute__((packed)) tr2_sprite_sequence_t;
 
 /*!
  * \brief Mesh structure.
                                       * (relative coordinates, just like the vertices) */
     int collision_size;              //!< radius of collisional sphere
     short num_vertices;              //!< number of vertices in this mesh
-    tr2_vertex_t *vertices;          //!< list of vertices (relative coordinates)
+    tr2_vertex_t* vertices;          //!< list of vertices (relative coordinates)
     short num_normals;               //!< number of normals in this mesh (should always equal NumVertices)
-    tr2_vertex_t *normals;           //!< list of normals (NULL if NumNormals < 0)
-    short *mesh_lights;              //!< if NumNormals < 0
+    tr2_vertex_t* normals;           //!< list of normals (NULL if NumNormals < 0)
+    short* mesh_lights;              //!< if NumNormals < 0
     short num_textured_rectangles;   //!< number of textured rectangles
-    tr2_quad_t *textured_rectangles; //!< list of textured rectangles
+    tr2_quad_t* textured_rectangles; //!< list of textured rectangles
     short num_textured_triangles;    //!< number of textured triangles in this mesh
-    tr2_tri_t *textured_triangles;   //!< list of textured triangles
+    tr2_tri_t* textured_triangles;   //!< list of textured triangles
     short num_coloured_rectangles;   //!< number of coloured rectangles
-    tr2_quad_t *coloured_rectangles; //!< list of coloured rectangles
+    tr2_quad_t* coloured_rectangles; //!< list of coloured rectangles
     short num_coloured_triangles;    //!< number of coloured triangles in this mesh
-    tr2_tri_t *coloured_triangles;   //!< list of coloured triangles
-} __attribute__ ((packed)) tr2_mesh_t;
+    tr2_tri_t* coloured_triangles;   //!< list of coloured triangles
+} __attribute__((packed)) tr2_mesh_t;
 
 /*!
  * \brief Frame structure.
 typedef struct {
     tr2_vertex_t vector[3];
     int num_words;
-    unsigned short *words;
-} __attribute__ ((packed)) tr2_frame_t;
+    unsigned short* words;
+} __attribute__((packed)) tr2_frame_t;
 
 /*!
  * \brief Item structure
     short intensity1;
     short intensity2;
     short flags;      //!< 0x0100 indicates "inactive" or "invisible"
-} __attribute__ ((packed)) tr2_item_t;
+} __attribute__((packed)) tr2_item_t;
 
 /*!
  * \brief SoundSource structure
     int z;
     unsigned short sound_id; //!< internal sound index
     unsigned short flags;    //!< 0x40, 0x80, or 0xc0
-} __attribute__ ((packed)) tr2_sound_source_t;
+} __attribute__((packed)) tr2_sound_source_t;
 
 /*!
  * \brief Boxes structure
     unsigned char xmax;
     short true_floor;    //!< Y value (no scaling)
     short overlap_index; //!< index into Overlaps[]
-} __attribute__ ((packed)) tr2_box_t;
+} __attribute__((packed)) tr2_box_t;
 
 /*!
  * \brief AnimatedTexture structure.
  */
 typedef struct {
     short num_texture_ids; //!< Number of Texture IDs - 1
-    short *texture_list;   //!< list of textures to cycle through
-} __attribute__ ((packed)) tr2_animated_texture_t;
+    short* texture_list;   //!< list of textures to cycle through
+} __attribute__((packed)) tr2_animated_texture_t;
 
 /*!
  * \brief Camera structure
     int z;
     short room;
     unsigned short unknown1; //!< correlates to Boxes[]?
-} __attribute__ ((packed)) tr2_camera_t;
+} __attribute__((packed)) tr2_camera_t;
 
 /*
  * \brief Data for a flyby camera (40 bytes)
     unsigned char index[2];    //!< A pair of indices
     unsigned short unknown[5]; //!< ??
     int id;                    //!< Index of something
-} __attribute__ ((packed)) tr4_extra_camera_t;
+} __attribute__((packed)) tr4_extra_camera_t;
 
 /*!
  * \brief Sound sample structure
     short sound_range;
     short flags;       /*!< \ brief bits 8-15: priority?, 2-7: number of sound samples
                         * in this group, bits 0-1: channel number */
-} __attribute__ ((packed)) tr2_sound_details_t;
+} __attribute__((packed)) tr2_sound_details_t;
 
 /*!
  * \brief Cutscene Camera structure
     short posx;     //!< X position of camera, relative to something
     short unknown1;
     short rotx;     //!< Rotation about X axis, +/-32767 ::= +/- 180 degrees
-} __attribute__ ((packed)) tr2_cinematic_frame_t;
+} __attribute__((packed)) tr2_cinematic_frame_t;
 
 /*!
  * \brief Data for a AI object (24 bytes).
  */
 typedef struct {
     unsigned short int object_id; //!< the objectID from the AI object
-                                  //!< (AI_FOLLOW is 402)
+    //!< (AI_FOLLOW is 402)
     unsigned short int room;
     int x, y, a;
     unsigned short int ocb;
     unsigned short int flags;     //!< The trigger flags
-                                  //!< (button 1-5, first button has value 2)
+    //!< (button 1-5, first button has value 2)
     int angle;                    //!< rotation
-} __attribute__ ((packed)) tr4_ai_object_t;
+} __attribute__((packed)) tr4_ai_object_t;
 
 /*!
  * \brief Used to read packed TR4 texels
     tr2_object_texture_vert_t vertices[4]; //!< same meaning as in TR3
     unsigned int unknown1, unknown2;       //!< new in TR4: x & y offset in something
     unsigned int xsize, ysize;             //!< new in TR4: width-1 & height-1 of the object texture
-} __attribute__ ((packed)) tr4_object_texture_t;
+} __attribute__((packed)) tr4_object_texture_t;
 
 /*!
  * \brief TR5 Room Layer (56 bytes)
     uint16_t numLayerRectangles; //!< number of rectangles in this layer (2 bytes)
     uint16_t numLayerTriangles;  //!< number of triangles in this layer (2 bytes)
     uint16_t unknownL2;          //!< appears to be the number of 2 sided textures
-                                  //!< in this layer, however is sometimes 1 off (2 bytes)
+    //!< in this layer, however is sometimes 1 off (2 bytes)
     uint16_t filler;             //!< always 0 (2 bytes)
     uint16_t filler2;            //!< always 0 (2 bytes)
 
  */
 typedef struct {
     uint16_t vertices[4]; //!< the values are the indices into the
-                           //!< appropriate layer vertice list. (2 bytes each)
+    //!< appropriate layer vertice list. (2 bytes each)
     uint16_t texture;     //!< the texture number for this face. Needs to be masked
-                           //!< with 0xFFF as the high 4 bits are flags (2 bytes)
+    //!< with 0xFFF as the high 4 bits are flags (2 bytes)
     uint16_t unknownF4;   //!< unknown (2 bytes)
 } tr5_face4_t;
 
  */
 typedef struct {
     uint16_t vertices[3]; //!< the values are the indices into the
-                           //!< appropriate layer vertice list (2 bytes each)
+    //!< appropriate layer vertice list (2 bytes each)
     uint16_t texture;     //!< the texture number for this face. Needs to be masked
-                           //!< with 0xFFF as the high 4 bits are flags (2 bytes)
+    //!< with 0xFFF as the high 4 bits are flags (2 bytes)
     uint16_t unknownF3;   //!< unknown (2 bytes)
 } tr5_face3_t;
 
  * \brief This is to help store and manage TR5 layer based polgons for rooms
  */
 typedef struct {
-    tr5_face4_t *quads;
-    tr5_face3_t *tris;
-    tr5_vertex_t *verts;
+    tr5_face4_t* quads;
+    tr5_face3_t* tris;
+    tr5_vertex_t* verts;
 } tr5_room_geometry_t;
 
 /*!
     uint32_t seperator8;          //!< 0xCDCDCDCD (4 bytes)
     uint32_t unknownR6;           //!< unknown (4 bytes)
     float roomX;                   //!< X position of room in world coordinates
-                                   //!< If  null room then this data will be 0xCDCDCDCD (4 bytes)
+    //!< If  null room then this data will be 0xCDCDCDCD (4 bytes)
     uint32_t seperator9;          //!< 0x00000000 or 0xCDCDCDCD if null room. (4 bytes)
     float roomZ;                   //!< Z position of room in world coordinates
-                                   //!< If null room then will be bitu32 0xCDCDCDCD (4 bytes)
+    //!< If null room then will be bitu32 0xCDCDCDCD (4 bytes)
     uint32_t seperator10;         //!< 0xCDCDCDCD (4 bytes)
     uint32_t seperator11;         //!< 0xCDCDCDCD (4 bytes)
     uint32_t seperator12;         //!< 0xCDCDCDCD (4 bytes)
     uint32_t numTotalRoomLights;  //!< total number of lights this room (4 bytes)
     uint32_t unknownR7;           //!< unknown, usually equals 0, 1, 2, or 3 (4 bytes)
     int32_t unknownR8;             //!< usually equals room yTop. Sometimes a few blocks off.
-                                   //!< If null room then 0xCDCDCDCD
+    //!< If null room then 0xCDCDCDCD
     int32_t lyBottom;              //!< equals room yBottom. If null room then 0xCDCDCDCD (4 bytes)
     uint32_t numLayers;           //!< number of layers (pieces) this room (4 bytes)
     uint32_t layerOffset;         //!< this number + 216 will give you an offset from the start
-                                   //!< of the room data to the start of the layer data (4 bytes)
+    //!< of the room data to the start of the layer data (4 bytes)
     uint32_t verticesOffset;      //!< this number + 216 will give you an offset from the start
-                                   //!< of the room data to the start of the verex data (4 bytes)
+    //!< of the room data to the start of the verex data (4 bytes)
     uint32_t polyOffset;          //!< this number + 216 will give you an offset from the start
-                                   //!< of the room data to the start of the rectangle/triangle data (4 bytes)
+    //!< of the room data to the start of the rectangle/triangle data (4 bytes)
     uint32_t polyOffset2;         //!< same as above ? (4 bytes)
     uint32_t verticesSize;        //!< size of vertices data block (4 bytes)
     uint32_t seperator17;         //!< 0xCDCDCDCD (4 bytes)
     uint32_t seperator18;         //!< 0xCDCDCDCD (4 bytes)
     uint32_t seperator19;         //!< 0xCDCDCDCD (4 bytes)
     uint32_t seperator20;         //!< 0xCDCDCDCD (4 bytes)
-    tr5_light_t *lights;           //!< [LightSize];
-                                   //!< data for the lights (88 bytes * NumRoomLights)
-    tr2_room_sector_t *sectors;    //!< Data[(NumXSectors * NumZSectors) * 8];
-                                   //!< normal sector data structure
+    tr5_light_t* lights;           //!< [LightSize];
+    //!< data for the lights (88 bytes * NumRoomLights)
+    tr2_room_sector_t* sectors;    //!< Data[(NumXSectors * NumZSectors) * 8];
+    //!< normal sector data structure
     uint16_t numDoors;            //!< number of portals (2 bytes)
-    tr2_room_portal_t *doors;      //!< [NumDoors];
-                                   //!< normal portal structure (32 bytes * NumDoors)
+    tr2_room_portal_t* doors;      //!< [NumDoors];
+    //!< normal portal structure (32 bytes * NumDoors)
     uint16_t seperator21;         //!< 0xCDCD (2 bytes)
-    tr2_room_staticmesh_t *meshes; //!< [NumStaticMeshes];
-                                   //!< normal room static mesh structure (20 bytes * NumRoomStaticMeshes)
-    tr5_room_layer_t *layers;      //!< [NumLayers];
-                                   //!< data for the room layers (pieces) (56 bytes * NumLayers)
-    tr5_room_geometry_t *faces;    //!< [NumRoomRectangles + NumRoomTriangles];
-                                   /* Data for the room polys (face4 and face3).
-                                    * Structured as first layers rectangles
-                                    * then triangles, followed by the
-                                    * next layers rectangles and triangles, etc.,
-                                    * until all layers are done.
-                                    * (12 bytes each rectangle. 10 bytes each triangle)
-                                    */
-    tr5_vertex_t *vertices;        //!< [VerticesSize];
-                                   /*!< Data for the room vertices.
-                                    * Structured as vertices for the first layer,
-                                    * then vertices for the second layer, etc.,
-                                    * until all layers are done.
-                                    * (28 bytes each vertex.
-                                    */
+    tr2_room_staticmesh_t* meshes; //!< [NumStaticMeshes];
+    //!< normal room static mesh structure (20 bytes * NumRoomStaticMeshes)
+    tr5_room_layer_t* layers;      //!< [NumLayers];
+    //!< data for the room layers (pieces) (56 bytes * NumLayers)
+    tr5_room_geometry_t* faces;    //!< [NumRoomRectangles + NumRoomTriangles];
+    /* Data for the room polys (face4 and face3).
+     * Structured as first layers rectangles
+     * then triangles, followed by the
+     * next layers rectangles and triangles, etc.,
+     * until all layers are done.
+     * (12 bytes each rectangle. 10 bytes each triangle)
+     */
+    tr5_vertex_t* vertices;        //!< [VerticesSize];
+    /*!< Data for the room vertices.
+     * Structured as vertices for the first layer,
+     * then vertices for the second layer, etc.,
+     * until all layers are done.
+     * (28 bytes each vertex.
+     */
 } tr5_room_t;
 
 /*!
  */
 typedef struct {
     uint8_t xCoordinate; //!< 0 if Xpixel is the low value,
-                          //!< 255 if Xpixel is the high value in the object texture (1 byte)
+    //!< 255 if Xpixel is the high value in the object texture (1 byte)
     uint8_t xPixel;      //!< (1 byte)
     uint8_t yCoordinate; //!< 0 if Ypixel is the low value,
-                          //!< 255 if Ypixel is the high value in the object texture (1 byte)
+    //!< 255 if Ypixel is the high value in the object texture (1 byte)
     uint8_t yPixel;      //!< (1 byte)
 } tr5_object_texture_vertex_t;
 
 typedef struct {
     uint16_t attribute;                     //!< 0, 1, or 2 (2 means 2 sided) (2 bytes)
     uint32_t tile;                          //!< need to mask with 0xFF as other bits are flags.
-                                             //!< ie int15_t seems to indicate triangle (4 bytes)
+    //!< ie int15_t seems to indicate triangle (4 bytes)
     tr5_object_texture_vertex_t vertices[4]; //!< Vertices[4] (16 bytes)
     uint32_t uv1;                           //!< unknown how used (4 bytes)
     uint32_t uv2;                           //!< unknown how used (4 bytes)
     tr2_vertex_t center;             //!< relative coordinates of mesh centre (6 bytes)
     uint8_t unknown1[4];            //!< unknown (4 bytes)
     int16_t numVertices;             //!< number of vertices to follow (2 bytes)
-    tr2_vertex_t *vertices;          //!< list of vertices (NumVertices * 6 bytes)
+    tr2_vertex_t* vertices;          //!< list of vertices (NumVertices * 6 bytes)
     int16_t numNormals;              //!< number of normals to follow (2 bytes)
-    tr2_vertex_t *normals;           //!< list of normals (NumNormals * 6 bytes)
-                                     //!< (becomes Lights if NumNormals < 0; 2 bytes)
+    tr2_vertex_t* normals;           //!< list of normals (NumNormals * 6 bytes)
+    //!< (becomes Lights if NumNormals < 0; 2 bytes)
     int16_t numTexturedRectangles;   //!< number of textured rectangles to follow (2 bytes)
-    tr5_face4_t *texturedRectangles; //!< list of textured rectangles (NumTexturedRectangles * 12 bytes)
+    tr5_face4_t* texturedRectangles; //!< list of textured rectangles (NumTexturedRectangles * 12 bytes)
     int16_t numTexturedTriangles;    //!< number of textured triangles to follow (2 bytes)
-    tr5_face3_t *texturedTriangles;  //!< list of textured triangles (NumTexturedTriangles * 10 bytes)
+    tr5_face3_t* texturedTriangles;  //!< list of textured triangles (NumTexturedTriangles * 10 bytes)
 } tr5_mesh_t;
 
 /*!

include/UI.h

 #include "imgui/imgui.h"
 
 class UI {
-public:
+  public:
     static int initialize();
     static void eventsFinished();
     static void display();
     static bool isVisible();
 
     static void handleKeyboard(KeyboardButton key, bool pressed);
-    static void handleText(char *text, bool notFinished);
+    static void handleText(char* text, bool notFinished);
     static void handleMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released);
     static void handleMouseMotion(int xrel, int yrel, int xabs, int yabs);
     static void handleMouseScroll(int xrel, int yrel);
 
     static void renderImGui(ImDrawList** const draw_lists, int count);
 
-private:
+  private:
     static bool visible;
     static unsigned int fontTex;
     static std::string iniFilename;

include/ViewVolume.h

  * \brief Viewing Volume for culling use
  */
 class ViewVolume {
-public:
+  public:
 
     /*!
      * \brief Sides of the view volume
      */
     void setProjection(float proj[16]);
 
-private:
+  private:
 
     /*!
      * \brief Computes clipping matrix.

include/Window.h

  * \brief Windowing interface
  */
 class Window {
-public:
+  public:
 
     virtual ~Window() {}
 
     virtual void glExit2D();
 
     static void lookAt(float eyeX, float eyeY, float eyeZ,
-                        float lookAtX, float lookAtY, float lookAtZ,
-                        float upX, float upY, float upZ);
+                       float lookAtX, float lookAtY, float lookAtZ,
+                       float upX, float upY, float upZ);
 
-protected:
+  protected:
     bool mInit;
     bool mFullscreen;
     bool mMousegrab;
     unsigned int mHeight;
 };
 
-Window &getWindow();
+Window& getWindow();
 
 #endif
 

include/WindowGLUT.h

  * \brief GLUT windowing implementation
  */
 class WindowGLUT : public Window {
-public:
+  public:
 
     WindowGLUT();
 
 
     virtual void swapBuffersGL();
 
-private:
+  private:
     static void reshapeCallback(int width, int height);
     static void keyboardCallback(unsigned char key, int x, int y);
     static void keyboardUpCallback(unsigned char key, int x, int y);

include/WindowSDL.h

  * \brief SDL windowing implementation
  */
 class WindowSDL : public Window {
-public:
+  public:
 
     /*!
      * \brief Constructs an object of WindowSDL
 
     virtual void swapBuffersGL();
 
-private:
-    SDL_Window *mWindow;      //!< This is the pointer to the SDL surface
+  private:
+    SDL_Window* mWindow;      //!< This is the pointer to the SDL surface
     SDL_GLContext mGLContext; //!< The OpenGL Context
 };
 

include/World.h

  * \brief The game world (model)
  */
 class World {
-public:
+  public:
 
     /*!
      * \brief Deconstructs an object of World
      */
     void destroy();
 
-    void addRoom(Room &room);
+    void addRoom(Room& room);
     unsigned long sizeRoom();
-    Room &getRoom(unsigned long index);
+    Room& getRoom(unsigned long index);
 
-    void addSprite(SpriteSequence &sprite);
+    void addSprite(SpriteSequence& sprite);
     unsigned long sizeSprite();
-    SpriteSequence &getSprite(unsigned long index);
+    SpriteSequence& getSprite(unsigned long index);
 
-    void addEntity(Entity &entity);
+    void addEntity(Entity& entity);
     unsigned long sizeEntity();
-    Entity &getEntity(unsigned long index);
+    Entity& getEntity(unsigned long index);
 
-    void addSkeletalModel(SkeletalModel &model);
+    void addSkeletalModel(SkeletalModel& model);
     unsigned long sizeSkeletalModel();
-    SkeletalModel &getSkeletalModel(unsigned long index);
+    SkeletalModel& getSkeletalModel(unsigned long index);
 
-    void addStaticMesh(StaticMesh &model);
+    void addStaticMesh(StaticMesh& model);
     unsigned long sizeStaticMesh();
-    StaticMesh &getStaticMesh(unsigned long index);
+    StaticMesh& getStaticMesh(unsigned long index);
 
     /*!
      * \brief Find room a location is in.
      */
     long getRoomByLocation(float x, float y, float z);
 
-private:
+  private:
     std::vector<std::unique_ptr<Room>> mRooms;
     std::vector<std::unique_ptr<SpriteSequence>> mSprites;
     std::vector<std::unique_ptr<Entity>> mEntities;
     std::vector<std::unique_ptr<StaticMesh>> mMeshes;
 };
 
-World &getWorld();
+World& getWorld();
 
 #endif

include/commands/Command.h

 #include <vector>
 
 class Command {
-public:
+  public:
     virtual ~Command();
     virtual std::string name() = 0;
     virtual std::string brief() = 0;
     static int command(std::string c);
     static int executeFile(std::string file);
 
-private:
+  private:
     static std::vector<std::shared_ptr<Command>> commands;
 };
 

include/commands/CommandAnimate.h

 #include "commands/Command.h"
 
 class CommandAnimate : public Command {
-public:
+  public:
     virtual std::string name();
     virtual std::string brief();
     virtual void printHelp();

include/commands/CommandBind.h

 #include "commands/Command.h"
 
 class CommandBind : public Command {
-public:
+  public:
     virtual std::string name();
     virtual std::string brief();
     virtual void printHelp();
     virtual int execute(std::istream& args);
 
-private:
+  private:
     ActionEvents stringToActionEvent(std::string action);
     KeyboardButton stringToKeyboardButton(std::string key);
 };

include/commands/CommandEngine.h

 #include "commands/Command.h"
 
 class CommandLoad : public Command {
-public:
+  public:
     virtual std::string name();
     virtual std::string brief();
     virtual void printHelp();
 };
 
 class CommandScreenshot : public Command {
-public:
+  public:
     virtual std::string name();
     virtual std::string brief();
     virtual void printHelp();
 };
 
 class CommandQuit : public Command {
-public:
+  public:
     virtual std::string name();
     virtual std::string brief();
     virtual int execute(std::istream& args);

include/commands/CommandGame.h

 #include "commands/Command.h"
 
 class CommandPos : public Command {
-public:
+  public:
     virtual std::string name();
     virtual std::string brief();
     virtual int execute(std::istream& args);
 };
 
 class CommandViewmodel : public Command {
-public:
+  public:
     virtual std::string name();
     virtual std::string brief();
     virtual int execute(std::istream& args);
 };
 
 class CommandPigtail : public Command {
-public:
+  public:
     virtual std::string name();
     virtual std::string brief();
     virtual int execute(std::istream& args);
 };
 
 class CommandPonypos : public Command {
-public:
+  public:
     virtual std::string name();
     virtual std::string brief();
     virtual int execute(std::istream& args);

include/commands/CommandMove.h

 #include "commands/Command.h"
 
 class CommandMove : public Command {
-public:
+  public:
     virtual std::string name();
     virtual std::string brief();
     virtual void printHelp();

include/commands/CommandRender.h

 #include "commands/Command.h"
 
 class CommandMode : public Command {
-public:
+  public:
     virtual std::string name();
     virtual std::string brief();
     virtual void printHelp();
 };
 
 class CommandRenderflag : public Command {
-public:
+  public:
     virtual std::string name();
     virtual std::string brief();
     virtual void printHelp();
     virtual int execute(std::istream& args);
 
-private:
+  private:
     int stringToFlag(std::string flag);
 };
 

include/commands/CommandSet.h

 #include "commands/Command.h"
 
 class CommandSet : public Command {
-public:
+  public:
     virtual std::string name();
     virtual std::string brief();
     virtual void printHelp();

include/commands/CommandSound.h

 #include "commands/Command.h"
 
 class CommandSound : public Command {
-public:
+  public:
     virtual std::string name();
     virtual std::string brief();
     virtual void printHelp();

include/games/TombRaider1.h

  * \brief Tomb Raider 1 items and states
  */
 class TombRaider1 {
-public:
+  public:
 
     /*!
      * \brief States of a Wolf (Item 7)

include/global.h

 #include <execinfo.h>
 
 template<typename T, typename U>
-[[noreturn]] void assertEqualImplementation(const char *exp, T a, U b, const char *file, int line, bool print) {
+[[noreturn]] void assertEqualImplementation(const char* exp, T a, U b, const char* file, int line,
+        bool print) {
     const unsigned int maxSize = 128;
-    void *callstack[maxSize];
+    void* callstack[maxSize];
     int frames = backtrace(callstack, maxSize);
-    char **strs = backtrace_symbols(callstack, frames);
+    char** strs = backtrace_symbols(callstack, frames);
 
     std::cout << std::endl << "assertion failed:" << std::endl;
     std::cout << "\t" << exp << std::endl;
 }
 
 template<typename T, typename U>
-[[noreturn]] void assertNotEqualImplementation(const char *exp, T a, U b, const char *file, int line, bool print) {
+[[noreturn]] void assertNotEqualImplementation(const char* exp, T a, U b, const char* file,
+        int line, bool print) {
     const unsigned int maxSize = 128;
-    void *callstack[maxSize];
+    void* callstack[maxSize];
     int frames = backtrace(callstack, maxSize);
-    char **strs = backtrace_symbols(callstack, frames);
+    char** strs = backtrace_symbols(callstack, frames);
 
     std::cout << std::endl << "assertion failed:" << std::endl;
     std::cout << "\t" << exp << std::endl;

include/loader/Loader.h

 #include "utils/binary.h"
 
 class Loader {
-public:
+  public:
 
     typedef enum {
         TR_UNKNOWN = 0,
 
     virtual int load(std::string f) = 0;
 
-protected:
+  protected:
     BinaryFile file;
 };
 

include/loader/LoaderTR1.h

 #include "loader/Loader.h"
 
 class LoaderTR1 : public Loader {
-public:
+  public:
     LoaderTR1();
     virtual ~LoaderTR1();
 
     virtual int load(std::string f);
 
-private:
+  private:
 
 };
 

include/loader/LoaderTR2.h

 #include "loader/Loader.h"
 
 class LoaderTR2 : public Loader {
-public:
+  public:
     LoaderTR2();
     virtual ~LoaderTR2();
 
     virtual int load(std::string f);
 
-private:
+  private:
     void loadPaletteTextiles();
     void loadRooms();
     void loadFloorData();

include/loader/LoaderTR3.h

 #include "loader/Loader.h"
 
 class LoaderTR3 : public Loader {
-public:
+  public:
     LoaderTR3();
     virtual ~LoaderTR3();
 
     virtual int load(std::string f);
 
-private:
+  private:
 
 };
 

include/math/Matrix.h

  *     ///////////////////////////////////////////////
  */
 class Matrix {
-public:
+  public:
 
     /*!
      * \brief Constructs an object of Matrix
      * \brief Constructs an object of Matrix
      * \param q Converts and assigns the Quaternion to the Matrix
      */
-    Matrix(Quaternion &q);
+    Matrix(Quaternion& q);
 
     /*!
      * \brief Returns this matrix copy
      * \param b second matrix
      * \returns resultant matrix
      */
-    static Matrix multiply(const Matrix &a, const Matrix &b);
+    static Matrix multiply(const Matrix& a, const Matrix& b);
 
     /*!
      * \brief Multiplies v vector and this matrix
      * \param a matrix to multiply with
      * \returns resultant matrix
      */
-    Matrix operator *(const Matrix &a);
+    Matrix operator *(const Matrix& a);
 
     /*!
      * \brief Multiply vector by this matrix
      * \brief Rotate object in 3D space
      * \param xyz rotation in radians
      */
-    void rotate(const float *xyz);
+    void rotate(const float* xyz);
 
     /*!
      * \brief Scale object in 3D space
      * \brief Scale object in 3D space
      * \param xyz scaling factors
      */
-    void scale(const float *xyz);
+    void scale(const float* xyz);
 
     /*!
      * \brief Translate (move) object in 3D space
      * \brief Translate (move) object in 3D space
      * \param xyz translations
      */
-    void translate(const float *xyz);
+    void translate(const float* xyz);
 
     /*!
      * \brief Transpose this matrix
 
     float mMatrix[16]; //!< Data model, moved public for faster external renderer feedback use
 
-private:
+  private:
 
     /*!
      * \brief Copys value from source to dest

include/math/Quaternion.h

  * \brief Quaternion
  */
 class Quaternion {
-public:
+  public:
 
     /*!
      * \brief Constructs an object of Quaternion
      * \returns resultant quaternion
      * \sa Quaternion::normalize()
      */
-    Quaternion operator *(const Quaternion &q);
+    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);
+    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);
+    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);
+    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);
+    bool operator ==(const Quaternion& q);
 
     /*!
      * \brief Conjugate this quaternion
      */
     void setByMatrix(float m[16]);
 
-private:
+  private:
 
     /*!
      * \brief Multiplies two quaternions

include/math/Vector3d.h

  * \brief 3D Math Vector
  */
 class Vector3d {
-public:
+  public:
 
     /*!
      * \brief Constructs an object of Vector3d
      * \brief Constructs an object of Vector3d
      * \param v contents of new Vector3d
      */
-    Vector3d(const Vector3d &v);
+    Vector3d(const Vector3d& v);
 
     /*!
      * \brief Calculate dot product
      * \param v second argument
      * \returns dot product of u and v vectors
      */
-    static float dot(const Vector3d &u, const Vector3d &v);
+    static float dot(const Vector3d& u, const Vector3d& v);
 
     /*!
      * \brief Calculate cross product
      * \param v second argument
      * \returns cross product of u and v vectors
      */
-    static Vector3d cross(const Vector3d &u, const Vector3d &v);
+    static Vector3d cross(const Vector3d& u, const Vector3d& v);
 
     /*!
      * \brief Get Magnitude
      * \param v addend
      * \returns a vector = this vector + v
      */
-    Vector3d operator +(const Vector3d &v);
+    Vector3d operator +(const Vector3d& v);
 
     /*!
      * \brief Subtract from this vector
      * \param v subtrahend
      * \returns a vector = this vector - v
      */
-    Vector3d operator -(const Vector3d &v);
+    Vector3d operator -(const Vector3d& v);
 
     /*!
      * \brief Negate this vector
      * \param v second vector for dot product
      * \returns dot product of V by this vector
      */
-    float operator *(const Vector3d &v);
+    float operator *(const Vector3d& v);
 
     /*!
      * \brief Normalizes this vector
      * \param v what this vector will be set to
      * \returns this vector, now equal to v
      */
-    Vector3d &operator =(const Vector3d &v);
+    Vector3d& operator =(const Vector3d& v);
 
     /*!
      * \brief Add to this vector, in place
      * \param v what will be added to this vector
      * \returns this vector, with v added
      */
-    Vector3d &operator +=(const Vector3d &v);
+    Vector3d& operator +=(const Vector3d& v);
 
     /*!
      * \brief Subtract from this vector, in place
      * \param v what will be subtracted from this vector
      * \returns this vector, with v subtracted
      */
-    Vector3d &operator -=(const Vector3d &v);
+    Vector3d& operator -=(const Vector3d& v);
 
     /*!
      * \brief Scale this vector, in place
      * \param s scaling factor
      * \returns this vactor multiplied by s
      */
-    Vector3d &operator *=(float s);
+    Vector3d& operator *=(float s);
 
     float mVec[3]; //!< Vector data
 };

include/utils/File.h

 class Folder;
 
 class File {
-public:
+  public:
     File(std::string file);
 
-    std::string &getName();
-    std::string &getPath();
+    std::string& getName();
+    std::string& getPath();
 
-private:
+  private:
     std::string name;
     std::string path;
 };

include/utils/Folder.h

 #include <vector>
 
 class Folder {
-public:
+  public:
     Folder(std::string folder, bool listDotFiles = false);
 
-    std::string &getName();
-    std::string &getPath();
+    std::string& getName();
+    std::string& getPath();
 
     unsigned long fileCount();
-    File &getFile(unsigned long i);
+    File& getFile(unsigned long i);
 
     unsigned long folderCount();
-    Folder &getFolder(unsigned long i);
+    Folder& getFolder(unsigned long i);
 
     Folder getParent();
 
-    void executeRemoveFiles(std::function<bool (File &f)> func);
+    void executeRemoveFiles(std::function<bool (File& f)> func);
 
     // Accessing a folder recursively
     // This treats all files in all subfolders as if they were in this folder
     unsigned long countRecursiveFiles();
-    void executeRemoveRecursiveFiles(std::function<bool (File &f)> func);
+    void executeRemoveRecursiveFiles(std::function<bool (File& f)> func);
     std::string getRecursiveFileName(unsigned long i);
-    File &getRecursiveFile(unsigned long i);
+    File& getRecursiveFile(unsigned long i);
 
-private:
+  private:
 
     void createFolderItems();
-    int readFolderItems(std::vector<std::string> &foundFiles, std::vector<std::string> &foundFolders);
+    int readFolderItems(std::vector<std::string>& foundFiles, std::vector<std::string>& foundFolders);
 
     std::string name; //!< Only last part of path
     std::string path; //!< Full path, with name and '/' at end

include/utils/binary.h

 #include <fstream>
 
 class BinaryFile {
-public:
+  public:
 
     ~BinaryFile();
 
-    int open(const char *f);
+    int open(const char* f);
 
     long long tell();
     void seek(long long pos);
 
     float readFloat();
 
-private:
+  private:
     std::ifstream file;
 };
 

include/utils/pcx.h

  * \param filename path of file to read
  * \returns 0 on success
  */
-int pcxCheck(const char *filename);
+int pcxCheck(const char* filename);
 
 /*!
  * \brief Load a PCX image file into a buffer
  * \param bpp place where pixel width will be stored (8, 24, 32)
  * \returns 0 on success
  */
-int pcxLoad(const char *filename, unsigned char **image,
-        unsigned int *width, unsigned int *height, ColorMode *mode, unsigned int *bpp);
+int pcxLoad(const char* filename, unsigned char** image,
+            unsigned int* width, unsigned int* height, ColorMode* mode, unsigned int* bpp);
 
 #endif
 

include/utils/pixel.h

 #ifndef _UTILS_PIXEL_H_
 #define _UTILS_PIXEL_H_
 
-unsigned char *generateColorTexture(const unsigned char *rgba, unsigned int width,
-        unsigned int height, unsigned int bpp);
+unsigned char* generateColorTexture(const unsigned char* rgba, unsigned int width,
+                                    unsigned int height, unsigned int bpp);
 
-void bgr2rgb24(unsigned char *image, unsigned int w, unsigned int h);
-void bgra2rgba32(unsigned char *image, unsigned int w, unsigned int h);
-void argb2rgba32(unsigned char *image, unsigned int w, unsigned int h);
+void bgr2rgb24(unsigned char* image, unsigned int w, unsigned int h);
+void bgra2rgba32(unsigned char* image, unsigned int w, unsigned int h);
+void argb2rgba32(unsigned char* image, unsigned int w, unsigned int h);
 
-unsigned char *scaleBuffer(unsigned char *image, unsigned int *w, unsigned int *h, unsigned int bpp);
+unsigned char* scaleBuffer(unsigned char* image, unsigned int* w, unsigned int* h,
+                           unsigned int bpp);
 
 #endif
 

include/utils/png.h

  * \param filename path of file to read
  * \returns 0 on success
  */
-int pngCheck(const char *filename);
+int pngCheck(const char* filename);
 
 /*!
  * \brief Load a PNG image file into an RGBA buffer
  * \param bpp place where pixel width will be stored (8, 24, 32)
  * \returns 0 on success
  */
-int pngLoad(const char *filename, unsigned char **image,
-        unsigned int *width, unsigned int *height, ColorMode *mode, unsigned int *bpp);
+int pngLoad(const char* filename, unsigned char** image,
+            unsigned int* width, unsigned int* height, ColorMode* mode, unsigned int* bpp);
 
 /*!
  * \brief Create a PNG image file from an RGBA buffer
  * \param bpp bits per pixel (8, 24, 32)
  * \returns 0 on success
  */
-int pngSave(const char *filename, unsigned char *image,
-        unsigned int width, unsigned int height, ColorMode mode, unsigned int bpp);
+int pngSave(const char* filename, unsigned char* image,
+            unsigned int width, unsigned int height, ColorMode mode, unsigned int bpp);
 
 #endif
 

include/utils/tga.h

  * \param filename path to file
  * \returns 0 if valid, else error condition
  */
-int tgaCheck(const char *filename);
+int tgaCheck(const char* filename);
 
 /*!
  * \brief Load a TGA image from file
  * \param type where the type will be stored (tga_type_t)
  * \returns 0 on success, else error condition
  */
-int tgaLoad(const char *filename, unsigned char **image,
-                unsigned int *width, unsigned int *height, char *type);
+int tgaLoad(const char* filename, unsigned char** image,
+            unsigned int* width, unsigned int* height, char* type);
 
 /*!
  * \brief Save a pixel buffer into a file on disk
  * \param type tga type to use
  * \returns 0 on success, else error condition
  */
-int tgaSave(const char *filename, unsigned char *image,
-                unsigned int width, unsigned int height, char type);
+int tgaSave(const char* filename, unsigned char* image,
+            unsigned int width, unsigned int height, char type);
 
 #endif
 

src/Console.cpp

         }
 
         if (ImGui::InputText("Command", buffer, bufferLength,
-                    ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_EnterReturnsTrue)) {
+                             ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_EnterReturnsTrue)) {
             getLog() << "> " << buffer << Log::endl;
             int error = Command::command(buffer);
             if (error != 0) {

src/Entity.cpp

 
 #include "games/TombRaider1.h"
 
-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();
+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;
     state = 0;
 }
 
-bool Entity::operator<(Entity &o) {
+bool Entity::operator<(Entity& o) {
     float distA = getRender().mViewVolume.getDistToSphereFromNear(pos[0], pos[1], pos[2], 1.0f);
     float distB = getRender().mViewVolume.getDistToSphereFromNear(o.pos[0], o.pos[1], o.pos[2], 1.0f);
     return (distA < distB);
 }
 
-bool Entity::compare(Entity *a, Entity *b) {
+bool Entity::compare(Entity* a, Entity* b) {
     return (*b) < (*a);
 }
 
 
     if (roomNew == -1) { // Will we hit a portal?
         roomNew = getWorld().getRoom(room).getAdjoiningRoom(pos[0], pos[1], pos[2],
-                x, y, z);
+                  x, y, z);
 
         if (roomNew > -1)
             getLog() << "Crossing from room " << room << " to " << roomNew << Log::endl;
     // Mongoose 2002.09.02, Add check for room -> room transition
     // (Only allow by movement between rooms by using portals)
     if (((moveType == MoveTypeNoClipping) ||
-                (moveType == MoveTypeFly) ||
-                (moveType == MoveTypeSwim)) ||
-            ((roomNew > -1) && (!wall))) {
+         (moveType == MoveTypeFly) ||
+         (moveType == MoveTypeSwim)) ||
+        ((roomNew > -1) && (!wall))) {
         room = roomNew;
 
         switch (movement) {
 
 void Entity::print() {
     getLog() << "Entity " << objectId << ":" << Log::endl
-        << "  Room " << room << " (" << getWorld().getRoom(room).getFlags()
-        << ")" << Log::endl
-        << "  " << pos[0] << "x " << pos[1] << "y " << pos[2] << "z"
-        << Log::endl
-        << "  " << OR_RAD_TO_DEG(angles[1]) << " Yaw" << Log::endl;
+             << "  Room " << room << " (" << getWorld().getRoom(room).getFlags()
+             << ")" << Log::endl
+             << "  " << pos[0] << "x " << pos[1] << "y " << pos[2] << "z"
+             << Log::endl
+             << "  " << OR_RAD_TO_DEG(angles[1]) << " Yaw" << Log::endl;
 }
 
-SkeletalModel &Entity::getModel() {
+SkeletalModel& Entity::getModel() {
     return getWorld().getSkeletalModel(skeletalModel);
 }
 

src/Exception.cpp

 
 std::string Exception::lastException("No custom exception since start!");
 
-Exception::Exception(const char *what) : runtime_error(what) {
+Exception::Exception(const char* what) : runtime_error(what) {
     lastException = what;
 }
 
-Exception::Exception(const std::string &what) : runtime_error(what) {
+Exception::Exception(const std::string& what) : runtime_error(what) {
     lastException = what;
 }
 

src/Font.cpp

 }
 
 void Font::drawText(unsigned int x, unsigned int y, float scale,
-        const unsigned char color[4], std::string s) {
+                    const unsigned char color[4], std::string s) {
     if (stringEndsWith(fontName, ".pc")) {
         FontTRLE::drawText(x, y, scale, color, s);
 #ifdef USING_SDL_FONT
 }
 
 void Font::drawTextWrapped(unsigned int x, unsigned int y, float scale,
-        const unsigned char color[4], unsigned int maxWidth, std::string s) {
+                           const unsigned char color[4], unsigned int maxWidth, std::string s) {
     if (stringEndsWith(fontName, ".pc")) {
         FontTRLE::drawTextWrapped(x, y, scale, color, maxWidth, s);
 #ifdef USING_SDL_FONT
 }
 
 void Font::drawTextCentered(unsigned int x, unsigned int y, float scale,
-        const unsigned char color[4], unsigned int width, std::string s) {
+                            const unsigned char color[4], unsigned int width, std::string s) {
     drawText(x + ((width / 2) - (widthText(scale, s) / 2)), y, scale, color, s);
 }
 

src/FontImGui.cpp

 
 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());
+    ImVec2 size = io.Font->CalcTextSizeA(scale * SCALE_CALC, 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,
-        const unsigned char color[4], std::string s) {
+                         const unsigned char color[4], std::string s) {
     ImGuiIO& io = ImGui::GetIO();
     ImVec2 pos = ImVec2(x, y);
     ImU32 col = color[0] | (color[1] << 8) | (color[2] << 16) | (color[3] << 24);
 
 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());
+    ImVec2 size = io.Font->CalcTextSizeA(scale * SCALE_CALC, 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) {
+                                const unsigned char color[4], unsigned int maxWidth, std::string s) {
     drawText(x, y, scale, color, s);
 }
 

src/FontSDL.cpp

 }
 
 void FontSDL::drawText(unsigned int x, unsigned int y, float scale,
-        const unsigned char color[4], std::string s) {
+                       const unsigned char color[4], std::string s) {
     assert(mFontInit == true);
     assert(mFont != nullptr);
     assert(s.length() > 0);
     col.b = color[2];
     col.a = color[3];
 
-    SDL_Surface *surface = TTF_RenderUTF8_Blended(mFont, s.c_str(), col);
+    SDL_Surface* surface = TTF_RenderUTF8_Blended(mFont, s.c_str(), col);
     if (surface == nullptr) {
         std::cout << "TTF_RenderUTF8_Blended Error: " << TTF_GetError() << std::endl;
         return;
     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);
+    glTexImage2D(GL_TEXTURE_2D, 0, surface->format->BytesPerPixel, surface->w, surface->h, 0,
+                 textureFormat, GL_UNSIGNED_BYTE, surface->pixels);
     SDL_FreeSurface(surface);
 
     GLuint xMin = x;
     assert(maxWidth > 0);
 
     SDL_Color col;
-    SDL_Surface *surface = TTF_RenderUTF8_Blended_Wrapped(mFont, s.c_str(), col, maxWidth);
+    SDL_Surface* surface = TTF_RenderUTF8_Blended_Wrapped(mFont, s.c_str(), col, maxWidth);
     if (surface == nullptr) {
         std::cout << "TTF_RenderUTF8_Blended_Wrapped Error: " << TTF_GetError() << std::endl;
         return 0;
 }
 
 void FontSDL::drawTextWrapped(unsigned int x, unsigned int y, float scale,
-        const unsigned char color[4], unsigned int maxWidth, std::string s) {
+                              const unsigned char color[4], unsigned int maxWidth, std::string s) {
     assert(mFontInit == true);
     assert(mFont != nullptr);
     assert(s.length() > 0);
     col.b = color[2];
     col.a = color[3];
 
-    SDL_Surface *surface = TTF_RenderUTF8_Blended_Wrapped(mFont, s.c_str(), col, maxWidth);
+    SDL_Surface* surface = TTF_RenderUTF8_Blended_Wrapped(mFont, s.c_str(), col, maxWidth);
     if (surface == nullptr) {
         std::cout << "TTF_RenderUTF8_Blended_Wrapped Error: " << TTF_GetError() << std::endl;
         return;
     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);
+    glTexImage2D(GL_TEXTURE_2D, 0, surface->format->BytesPerPixel, surface->w, surface->h, 0,
+                 textureFormat, GL_UNSIGNED_BYTE, surface->pixels);
     SDL_FreeSurface(surface);
 
     GLuint xMin = x;

src/FontTRLE.cpp

 
     // Load .pc file...
     std::ifstream file(font, std::ios::in | std::ios::binary);
-    unsigned char *pixels = new unsigned char[256 * 256 * 4];
-    if (!file.read((char *)pixels, 256 * 256 * 4)) {
+    unsigned char* pixels = new unsigned char[256 * 256 * 4];
+    if (!file.read((char*)pixels, 256 * 256 * 4)) {
         delete [] pixels;
         return -1;
     }
 }
 
 void FontTRLE::writeChar(unsigned int index, unsigned int xDraw, unsigned int yDraw,
-        float scale, const unsigned char color[4]) {
+                         float scale, const unsigned char color[4]) {
     assert(mFontInit == true);
 
     int width = (int)(((float)offsets[index][2]) * scale * SCALING);
 }
 
 void FontTRLE::drawText(unsigned int x, unsigned int y, float scale,
-        const unsigned char color[4], std::string s) {
+                        const unsigned char color[4], std::string s) {
     assert(mFontInit == true);
     assert(s.length() > 0);
 
 }
 
 void FontTRLE::drawTextWrapped(unsigned int x, unsigned int y, float scale,
-        const unsigned char color[4], unsigned int maxWidth, std::string s) {
+                               const unsigned char color[4], unsigned int maxWidth, std::string s) {
     assert(mFontInit == true);
     assert(s.length() > 0);
 

src/Game.cpp

     return mLoaded;
 }
 
-int Game::loadLevel(const char *level) {
+int Game::loadLevel(const char* level) {
     if (mLoaded)
         destroy();
 
     }
 }
 
-Entity &Game::getLara() {
+Entity& Game::getLara() {
     assert(mLara >= 0);
     assert(mLara < (int)getWorld().sizeEntity());
     return getWorld().getEntity(mLara);
     getLog() << "Found " << mTombRaider.getMeshCount() << " meshes." << Log::endl;
 }
 
-void Game::processPakSounds()
-{
-    unsigned char *riff;
+void Game::processPakSounds() {
+    unsigned char* riff;
     unsigned int riffSz;
     //tr2_sound_source_t *sound;
     //tr2_sound_details_t *detail;
     // in this group, bits 0-1: channel number
     */
 
-    for (i = 0; i < mTombRaider.getSoundSamplesCount(); ++i)
-    {
+    for (i = 0; i < mTombRaider.getSoundSamplesCount(); ++i) {
         mTombRaider.getSoundSample(i, &riffSz, &riff);
 
         getSound().addWave(riff, riffSz, &id, Sound::SoundFlagsNone);
 
         //if (((i + 1) == TR_SOUND_F_PISTOL) && (id > 0))
         //{
-            //m_testSFX = id;
+        //m_testSFX = id;
         //}
 
         delete [] riff;
     getLog() << "Found " << mTombRaider.getSoundSamplesCount() << " sound samples." << Log::endl;
 }
 
-void Game::processTextures()
-{
-    unsigned char *image;
-    unsigned char *bumpmap;
+void Game::processTextures() {
+    unsigned char* image;
+    unsigned char* bumpmap;
     int i;
 
     //if ( mTombRaider.getNumBumpMaps())
     //  gBumpMapStart = mTombRaider.NumTextures();
 
-    for (i = 0; i < mTombRaider.NumTextures(); ++i)
-    {
+    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, (mTextureStart - 1) + i);
+                                           RGBA, 32, (mTextureStart - 1) + i);
 
 #ifdef MULTITEXTURE
         gMapTex2Bump[(mTextureStart - 1) + i] = -1;
 #endif
 
-        if (bumpmap)
-        {
+        if (bumpmap) {
 #ifdef MULTITEXTURE
             gMapTex2Bump[(mTextureStart - 1) + i] = (mTextureStart - 1) + i +
-                    mTombRaider.NumTextures();
+                                                    mTombRaider.NumTextures();
 #endif
             getTextureManager().loadBufferSlot(bumpmap, 256, 256,
-                    RGBA, 32,
-                    (mTextureStart - 1) + i + mTombRaider.NumTextures());
+                                               RGBA, 32,
+                                               (mTextureStart - 1) + i + mTombRaider.NumTextures());
         }
 
         if (image)
     getLog() << "Found " << mTombRaider.NumTextures() << " textures." << Log::endl;
 }
 
-void Game::processMoveables()
-{
+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();
+    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)
-    {
+    for (int i = 0; i < mTombRaider.NumItems(); ++i) {
         int j;
         int object_id = item[i].object_id;
 
         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);
+    Entity& entity = *new Entity(mTombRaider, index, i, model);
     getWorld().addEntity(entity);
 
     // Store reference to Lara
     // Store reference to the SkyMesh
     if (i == mTombRaider.getSkyModelId())
         getRender().setSkyMesh(i, //moveable[i].starting_mesh,
-                (mTombRaider.Engine() == TR_VERSION_2));
+                               (mTombRaider.Engine() == TR_VERSION_2));
 }
 

src/Menu.cpp

 #include "MenuFolder.h"
 
 void Menu::showDialog(std::string msg, std::string btn1, std::string btn2,
-        std::function<int (bool state)> callback) {
+                      std::function<int (bool state)> callback) {
     // Only show one dialog at a time
     assert(dialogText.length() == 0);
     assert(dialogButton1.length() == 0);
 }
 
 bool Menu::handleMouseClickDialog(unsigned int x, unsigned int y,
-            KeyboardButton button, bool released) {
+                                  KeyboardButton button, bool released) {
     //! \todo Allow mouse usage of Menu dialogs!
     return (dialogText.length() > 0);
 }
         if (dialogButton2.length() > 0) {
             if ((w1 + w2) <= wMax) {
                 Font::drawTextWrapped(xOverlay + 10, yOverlay + 10 + h0, 1.0f,
-                    dialogState ? BLUE : RED, w1, dialogButton1);
+                                      dialogState ? BLUE : RED, w1, dialogButton1);
                 Font::drawTextWrapped(xOverlay + 10 + w1, yOverlay + 10 + h0,
-                    1.0f, dialogState ? RED : BLUE, w2, dialogButton2);
+                                      1.0f, dialogState ? RED : BLUE, w2, dialogButton2);
             } else {
                 Font::drawTextWrapped((::getWindow().getWidth() - w1) / 2,
-                    yOverlay + 10 + h0, 1.0f, dialogState ? BLUE : RED, w1, dialogButton1);
+                                      yOverlay + 10 + h0, 1.0f, dialogState ? BLUE : RED, w1, dialogButton1);
                 Font::drawTextWrapped((::getWindow().getWidth() - w2) / 2,
-                    yOverlay + 10 + h0 + h1, 1.0f, dialogState ? RED : BLUE, w2, dialogButton2);
+                                      yOverlay + 10 + h0 + h1, 1.0f, dialogState ? RED : BLUE, w2, dialogButton2);
             }
         } else {
             Font::drawTextWrapped((::getWindow().getWidth() - w1) / 2,
-                    yOverlay + 10 + h0, 1.0f, RED, w1, dialogButton1);
+                                  yOverlay + 10 + h0, 1.0f, RED, w1, dialogButton1);
         }
     }
 }

src/MenuFolder.cpp

     return init(new Folder(s));
 }
 
-int MenuFolder::init(Folder *folder, bool filter) {
+int MenuFolder::init(Folder* folder, bool filter) {
     if (mapFolder != nullptr)
         delete mapFolder;
 
     mMin = mCursor = 0;
 
     if (filter) {
-        mapFolder->executeRemoveFiles([](File &f) {
+        mapFolder->executeRemoveFiles([](File & f) {
             // Filter files based on file name
             if ((f.getName().length() > 4)
                 && (f.getName().compare(f.getName().length() - 4, 4, ".phd") != 0)
             Loader::LoaderVersion version = Loader::checkFile(f.getPath());
             if (version == Loader::TR_UNKNOWN) {
                 getLog() << "Error: pak file '" << f.getName().c_str()
-                    << "' invalid" << Log::endl;
+                         << "' invalid" << Log::endl;
                 return true; // delete file from list
             }
 
 
     // Print list of "..", folders, files
     for (long i = mMin; (i < (mMin + items))
-                && (i < (mapFolder->folderCount() + mapFolder->fileCount() + 1)); i++) {
+         && (i < (mapFolder->folderCount() + mapFolder->fileCount() + 1)); i++) {
         if (i == 0) {
             Font::drawText(25, 50, 0.75f, (mCursor == i) ? RED : BLUE, "..");
         } else {
             Font::drawText(25, (unsigned int)(50 + (25 * (i - mMin))), 0.75f,
-                (mCursor == i) ? RED : BLUE,
-                ((i - 1) < mapFolder->folderCount()) ?
-                    (mapFolder->getFolder(i - 1).getName() + "/")
-                    : mapFolder->getFile(i - 1 - mapFolder->folderCount()).getName());
+                           (mCursor == i) ? RED : BLUE,
+                           ((i - 1) < mapFolder->folderCount()) ?
+                           (mapFolder->getFolder(i - 1).getName() + "/")
+                           : mapFolder->getFile(i - 1 - mapFolder->folderCount()).getName());
         }
     }
 
         }
     } else {
         int error = getGame().loadLevel(mapFolder->getFile((unsigned long)mCursor
-                    - 1 - mapFolder->folderCount()).getPath().c_str());
+                                        - 1 - mapFolder->folderCount()).getPath().c_str());
         if (error == 0) {
             visible = false;
         } else {
     }
 }
 
-void MenuFolder::handleMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released) {
+void MenuFolder::handleMouseClick(unsigned int x, unsigned int y, KeyboardButton button,
+                                  bool released) {
     if (handleMouseClickDialog(x, y, button, released))
         return;
 
         return;
 
     if ((y >= 50) && (y <= (unsigned int)(50 + (25 * items)))
-            && ((mMin + (y / 25)) <= (mapFolder->folderCount() + mapFolder->fileCount() + 2))) {
+        && ((mMin + (y / 25)) <= (mapFolder->folderCount() + mapFolder->fileCount() + 2))) {
         y -= 50;
         if (mCursor == (mMin + (y / 25)))
             loadOrOpen();

src/Mesh.cpp

 // Constructors
 ////////////////////////////////////////////////////////////
 
-Mesh::Mesh()
-{
+Mesh::Mesh() {
     mNumVertices = 0;
     mVertices = 0x0;
 
 }
 
 
-Mesh::~Mesh()
-{
+Mesh::~Mesh() {
     for (unsigned int i = 0; i < mNumVertices; i++)
         delete [] mVertices[i];
     delete [] mVertices;
     delete [] mColors;
     mColors = NULL;
 
-    if (mTris)
-    {
-        for (unsigned int i = 0; i < mNumTris; ++i)
-        {
+    if (mTris) {
+        for (unsigned int i = 0; i < mNumTris; ++i) {
             delete [] mTris[i].triangles;
             delete [] mTris[i].alpha_triangles;
             delete [] mTris[i].texcoors;
         mTris = NULL;
     }
 
-    if (mQuads)
-    {
-        for (unsigned int i = 0; i < mNumQuads; ++i)
-        {
+    if (mQuads) {
+        for (unsigned int i = 0; i < mNumQuads; ++i) {
             delete [] mQuads[i].quads;
             delete [] mQuads[i].alpha_quads;
             delete [] mQuads[i].texcoors;
 // Public Accessors
 ////////////////////////////////////////////////////////////
 
-void Mesh::drawAlpha()
-{
+void Mesh::drawAlpha() {
     unsigned int i, j, k, index;
 
 
     // Render quadralaterals
-    for (mQuads ? i = 0 : i = mNumQuads; i < mNumQuads; ++i)
-    {
-        switch (mMode)
-        {
+    for (mQuads ? i = 0 : i = mNumQuads; i < mNumQuads; ++i) {
+        switch (mMode) {
             case MeshModeWireframe:
                 glColor3f(0.0, 0.0, 1.0);
                 glBindTexture(GL_TEXTURE_2D, 0);
             case MeshModeTexture:
             case MeshModeMultiTexture:
                 // Bind texture id for textures
-                glBindTexture(GL_TEXTURE_2D, mQuads[i].texture+1);
+                glBindTexture(GL_TEXTURE_2D, mQuads[i].texture + 1);
                 break;
         }
 
         glBegin(GL_QUADS);
 
-        for (j = 0; j < mQuads[i].num_alpha_quads; ++j)
-        {
-            for (k = 0; k < 4; ++k)
-            {
-                index = mQuads[i].alpha_quads[j*4+k];
+        for (j = 0; j < mQuads[i].num_alpha_quads; ++j) {
+            for (k = 0; k < 4; ++k) {
+                index = mQuads[i].alpha_quads[j * 4 + k];
 
-                glTexCoord2fv(mQuads[i].texcoors2[j*4+k]);
+                glTexCoord2fv(mQuads[i].texcoors2[j * 4 + k]);
                 glColor4fv(mColors[index]);
                 glVertex3fv(mVertices[index]);
             }
     }
 
     // Render triangles
-    for (mTris ? i = 0 : i = mNumTris; i < mNumTris; ++i)
-    {
-        switch (mMode)
-        {
+    for (mTris ? i = 0 : i = mNumTris; i < mNumTris; ++i) {
+        switch (mMode) {
             case MeshModeWireframe:
                 glColor3f(0.0, 1.0, 0.0);
                 glBindTexture(GL_TEXTURE_2D, 0);
             case MeshModeTexture:
             case MeshModeMultiTexture:
                 // Bind texture id for textures
-                glBindTexture(GL_TEXTURE_2D, mTris[i].texture+1);
+                glBindTexture(GL_TEXTURE_2D, mTris[i].texture + 1);
                 break;
         }
 
         glBegin(GL_TRIANGLES);
 
-        for (j = 0; j < mTris[i].num_alpha_triangles; ++j)
-        {
-            for (k = 0; k < 3; ++k)
-            {
-                index = mTris[i].alpha_triangles[j*3+k];
+        for (j = 0; j < mTris[i].num_alpha_triangles; ++j) {
+            for (k = 0; k < 3; ++k) {
+                index = mTris[i].alpha_triangles[j * 3 + k];
 
-                glTexCoord2fv(mTris[i].texcoors2[j*3+k]);
+                glTexCoord2fv(mTris[i].texcoors2[j * 3 + k]);
                 glColor4fv(mColors[index]);
                 glVertex3fv(mVertices[index]);
             }
 }
 
 
-void Mesh::drawSolid()
-{
+void Mesh::drawSolid() {
     unsigned int i, j, k, index;
 
 
-    if (mFlags & fMesh_UseVertexArray)
-    {
+    if (mFlags & fMesh_UseVertexArray) {
         //glEnableClientState(GL_VERTEX_ARRAY);
         //glVertexPointer(3, GL_FLOAT, 0, mVertexArray);
 
         glColor3f(1.0f, 1.0f, 1.0f);
         glBegin(GL_TRIANGLES);
 
-        for (i = 0; i < mTriangleCount*3; ++i)
-        {
+        for (i = 0; i < mTriangleCount * 3; ++i) {
             //glArrayElement(mTriangleIndices[i]);
-            glVertex3fv(mVertexArray+mTriangleIndices[i]);
+            glVertex3fv(mVertexArray + mTriangleIndices[i]);
         }
 
         glEnd();
     }
 
     // Render quadralaterals
-    for (mQuads ? i = 0 : i = mNumQuads; i < mNumQuads; ++i)
-    {
-        switch (mMode)
-        {
+    for (mQuads ? i = 0 : i = mNumQuads; i < mNumQuads; ++i) {
+        switch (mMode) {
             case MeshModeSolid:
                 glColor3f(0.0, 0.0, 0.0);
                 break;
             case MeshModeMultiTexture:
                 glActiveTextureARB(GL_TEXTURE0_ARB);
                 glEnable(GL_TEXTURE_2D);
-                glBindTexture(GL_TEXTURE_2D, mQuads[i].texture+1);
+                glBindTexture(GL_TEXTURE_2D, mQuads[i].texture + 1);
 
                 glActiveTextureARB(GL_TEXTURE1_ARB);
                 glEnable(GL_TEXTURE_2D);
-                glBindTexture(GL_TEXTURE_2D, mQuads[i].bumpmap+1);
+                glBindTexture(GL_TEXTURE_2D, mQuads[i].bumpmap + 1);
                 break;
 #else
             case MeshModeMultiTexture:
             case MeshModeTexture:
                 // Bind texture id for textures
                 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-                glBindTexture(GL_TEXTURE_2D, mQuads[i].texture+1);
+                glBindTexture(GL_TEXTURE_2D, mQuads[i].texture + 1);
                 break;
         }
 
         glBegin(GL_QUADS);
 
-        for (j = 0; j < mQuads[i].num_quads; ++j)
-        {
-            for (k = 0; k < 4; ++k)
-            {
-                index = mQuads[i].quads[j*4+k];
+        for (j = 0; j < mQuads[i].num_quads; ++j) {
+            for (k = 0; k < 4; ++k) {
+                index = mQuads[i].quads[j * 4 + k];
 
                 glColor4fv(mColors[index]);
 
 #ifdef MULTITEXTURE
-                if (mMode == MeshModeMultiTexture)
-                {
+                if (mMode == MeshModeMultiTexture) {
                     glMultiTexCoord2fvARB(GL_TEXTURE0_ARB,
-                            mQuads[i].texcoors[j*4+k]);
+                                          mQuads[i].texcoors[j * 4 + k]);
                     glMultiTexCoord2fvARB(GL_TEXTURE1_ARB,
-                            mQuads[i].texcoors[j*4+k]);
-                }
-                else
+                                          mQuads[i].texcoors[j * 4 + k]);
+                } else
 #endif
-                    glTexCoord2fv(mQuads[i].texcoors[j*4+k]);
+                    glTexCoord2fv(mQuads[i].texcoors[j * 4 + k]);
 
                 glVertex3fv(mVertices[index]);
             }
     }
 
     // Render triangles
-    for (mTris ? i = 0 : i = mNumTris; i < mNumTris; ++i)
-    {
-        switch (mMode)
-        {
+    for (mTris ? i = 0 : i = mNumTris; i < mNumTris; ++i) {
+        switch (mMode) {
             case MeshModeSolid:
                 glColor3f(1.0, 0.0, 0.0);
                 break;
             case MeshModeMultiTexture:
                 glActiveTextureARB(GL_TEXTURE0_ARB);
                 glEnable(GL_TEXTURE_2D);
-                glBindTexture(GL_TEXTURE_2D, mTris[i].texture+1);
+                glBindTexture(GL_TEXTURE_2D, mTris[i].texture + 1);
 
                 glActiveTextureARB(GL_TEXTURE1_ARB);
                 glEnable(GL_TEXTURE_2D);
-                glBindTexture(GL_TEXTURE_2D, mTris[i].bumpmap+1);
+                glBindTexture(GL_TEXTURE_2D, mTris[i].bumpmap + 1);
                 break;
 #else
             case MeshModeMultiTexture:
             case MeshModeTexture:
                 // Bind texture id for textures
                 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-                glBindTexture(GL_TEXTURE_2D, mTris[i].texture+1);
+                glBindTexture(GL_TEXTURE_2D, mTris[i].texture + 1);
                 break;
         }
 
         glBegin(GL_TRIANGLES);
 
-        for (j = 0; j < mTris[i].num_triangles; ++j)
-        {
-            for (k = 0; k < 3; ++k)
-            {
-                index = mTris[i].triangles[j*3+k];
+        for (j = 0; j < mTris[i].num_triangles; ++j) {
+            for (k = 0; k < 3; ++k) {
+                index = mTris[i].triangles[j * 3 + k];
 
 #ifdef MULTITEXTURE
-                if (mMode == MeshModeMultiTexture)
-                {
+                if (mMode == MeshModeMultiTexture) {
                     glMultiTexCoord2fvARB(GL_TEXTURE0_ARB,
-                            mTris[i].texcoors[j*3+k]);
+                                          mTris[i].texcoors[j * 3 + k]);
                     glMultiTexCoord2fvARB(GL_TEXTURE1_ARB,
-                            mTris[i].texcoors[j*3+k]);
-                }
-                else
+                                          mTris[i].texcoors[j * 3 + k]);
+                } else
 #endif
-                    glTexCoord2fv(mTris[i].texcoors[j*3+k]);
+                    glTexCoord2fv(mTris[i].texcoors[j * 3 + k]);
 
                 glColor4fv(mColors[index]);
                 glVertex3fv(mVertices[index]);
     }
 
 #ifdef MULTITEXTURE
-    if (mMode == MeshModeMultiTexture)
-    {
+    if (mMode == MeshModeMultiTexture) {
         glDisable(GL_TEXTURE_2D);
         glActiveTextureARB(GL_TEXTURE0_ARB);
     }
 // Public Mutators
 ////////////////////////////////////////////////////////////
 
-void Mesh::allocateColors(unsigned int n)
-{
-    if (mColors)
-    {
+void Mesh::allocateColors(unsigned int n) {
+    if (mColors) {
         for (unsigned int i = 0; i < mNumColors; i++)
             delete [] mColors[i];
         delete [] mColors;
         mNumColors = 0;
     }
 
-    if (!n)
-    {
+    if (!n) {
         return;
     }
 
 }
 
 
-void Mesh::allocateNormals(unsigned int n)
-{
-    if (mNormals)
-    {
+void Mesh::allocateNormals(unsigned int n) {
+    if (mNormals) {
         for (unsigned int i = 0; i < mNumNormals; i++)
             delete [] mNormals[i];
         delete [] mNormals;
         mNumNormals = 0;
     }
 
-    if (!n)
-    {
+    if (!n) {
         return;
     }
 
 }
 
 
-void Mesh::allocateRectangles(unsigned int n)
-{
-    if (mQuads)
-    {
+void Mesh::allocateRectangles(unsigned int n) {
+    if (mQuads) {
         mNumQuads = 0;
         delete [] mQuads;
     }
 
-    if (!n)
-    {
+    if (!n) {
         return;
     }
 
 }
 
 
-void Mesh::allocateTriangles(unsigned int n)
-{
-    if (mTris)
-    {
+void Mesh::allocateTriangles(unsigned int n) {
+    if (mTris) {
         mNumTris = 0;
         delete [] mTris;
     }
 
-    if (!n)
-    {
+    if (!n) {
         return;
     }
 
 }
 
 
-void Mesh::allocateVertices(unsigned int n)
-{
-    if (mVertices)
-    {
+void Mesh::allocateVertices(unsigned int n) {
+    if (mVertices) {
         for (unsigned int i = 0; i < mNumVertices; i++)
             delete [] mVertices[i];
         delete [] mVertices;
         mNumVertices = 0;
     }
 
-    if (!n)
-    {
+    if (!n) {
         return;
     }
 
 }
 
 
-void Mesh::bufferColorArray(unsigned int colorCount, float *colors)
-{
-    if (mColors)
-    {
+void Mesh::bufferColorArray(unsigned int colorCount, float* colors) {
+    if (mColors) {
         for (unsigned int i = 0; i < mNumColors; i++)
             delete [] mColors[i];
         delete [] mColors;
         mNumColors = 0;
     }
 
-    if (!colorCount)
-    {
+    if (!colorCount) {
         return;
     }
 
 }
 
 
-void Mesh::bufferNormalArray(unsigned int normalCount, float *normals)
-{
-    if (mNormals)
-    {
+void Mesh::bufferNormalArray(unsigned int normalCount, float* normals) {
+    if (mNormals) {
         for (unsigned int i = 0; i < mNumNormals; i++)
             delete [] mNormals[i];
         delete [] mNormals;
         mNumNormals = 0;
     }
 
-    if (!normalCount)
-    {
+    if (!normalCount) {
         return;
     }
 
 
 
 void Mesh::bufferTriangles(unsigned int count,
-        unsigned int *indices, float *texCoords,
-        int *textures, unsigned int *flags)
-{
+                           unsigned int* indices, float* texCoords,
+                           int* textures, unsigned int* flags) {
 
     mTriangleCount = count;
     mTriangleTextures = textures;
 }
 
 
-void Mesh::bufferVertexArray(unsigned int vertexCount, float *vertices)
-{
-    if (mVertices)
-    {
+void Mesh::bufferVertexArray(unsigned int vertexCount, float* vertices) {
+    if (mVertices) {
         for (unsigned int i = 0; i < mNumVertices; i++)
             delete [] mVertices[i];
         delete [] mVertices;
         mNumVertices = 0;
     }
 
-    if (!vertexCount)
-    {
+    if (!vertexCount) {
         return;
     }
 
 
 
 void Mesh::setColor(unsigned int index,
-        float r, float g, float b, float a)
-{
+                    float r, float g, float b, float a) {
     assert(index < mNumColors);
 
     mColors[index][0] = r;
 }
 
 
-void Mesh::setColor(unsigned int index, float rgba[4])
-{
+void Mesh::setColor(unsigned int index, float rgba[4]) {
     assert(index < mNumColors);
 
     mColors[index][0] = rgba[0];
 }
 
 
-void Mesh::setNormal(unsigned int index, float i, float j, float k)
-{
+void Mesh::setNormal(unsigned int index, float i, float j, float k) {
     assert(index < mNumNormals);
 
     mNormals[index][0] = i;
 }
 
 
-void Mesh::setVertex(unsigned int index, float x, float y, float z)
-{
+void Mesh::setVertex(unsigned int index, float x, float y, float z) {
     assert(index < mNumVertices);
 
     mVertices[index][0] = x;

src/Render.cpp

     mRoomRenderList.clear();
 }
 
-void Render::screenShot(const char *filenameBase)
-{
+void Render::screenShot(const char* filenameBase) {
     int sz = getWindow().getWidth() * getWindow().getHeight();
-    unsigned char *image = new unsigned char[sz * 3];
+    unsigned char* image = new unsigned char[sz * 3];
     static int count = 0;
     bool done = false;
 
     while (!done) {
         filename << filenameBase << "-" << count++ << ".tga";
 
-        FILE *f = fopen(filename.str().c_str(), "rb");
+        FILE* f = fopen(filename.str().c_str(), "rb");
         if (f) {
             fclose(f);
         } else {
         }
     }
 
-    glReadPixels(0, 0, getWindow().getWidth(), getWindow().getHeight(), GL_BGR_EXT, GL_UNSIGNED_BYTE, image);
+    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;
 }
     return mFlags;
 }
 
-void Render::lightRoom(Room &room)
-{
-    for (unsigned int i = 0; i < room.sizeLights(); ++i)
-    {
-        Light &light = room.getLight(i);
+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);
 
         glEnable(GL_LIGHT0 + i);
 
-        switch (light.getType())
-        {
+        switch (light.getType()) {
             case Light::typeSpot:
                 glLightf(GL_LIGHT0 + i,  GL_SPOT_CUTOFF,    light.getCutoff());
                 glLightfv(GL_LIGHT0 + i, GL_POSITION,       pos);
     }
 }
 
-void Render::clearFlags(unsigned int flags)
-{
+void Render::clearFlags(unsigned int flags) {
     mFlags &= ~flags;
 
-    if (flags & Render::fFog)
-    {
-        if (glIsEnabled(GL_FOG))
-        {
+    if (flags & Render::fFog) {
+        if (glIsEnabled(GL_FOG)) {
             glDisable(GL_FOG);
         }
     }
 
-    if (flags & Render::fGL_Lights)
-    {
+    if (flags & Render::fGL_Lights) {
         glDisable(GL_LIGHTING);
     }
 }
 
-void Render::setFlags(unsigned int flags)
-{
+void Render::setFlags(unsigned int flags) {
     mFlags |= flags;
 
-    if (flags & Render::fFog)
-    {
+    if (flags & Render::fFog) {
         glEnable(GL_FOG);
         glFogf(GL_FOG_MODE, GL_EXP2);
         glFogf(GL_FOG_DENSITY, 0.00008f);
         glFogfv(GL_FOG_COLOR, color);
     }
 
-    if (flags & Render::fGL_Lights)
-    {
+    if (flags & Render::fGL_Lights) {
         float color[4];
         color[0] = WHITE[0] * 256.0f;
         color[1] = WHITE[1] * 256.0f;
     }
 }
 
-int Render::getMode()
-{
+int Render::getMode() {
     return mMode;
 }
 
-void Render::setMode(int n)
-{
+void Render::setMode(int n) {
     mMode = n;
 
-    switch (mMode)
-    {
+    switch (mMode) {
         case Render::modeDisabled:
             break;
         case Render::modeSolid:
         case Render::modeWireframe:
             glClearColor(PURPLE[0] * 256.0f, PURPLE[1] * 256.0f,
-                    PURPLE[2] * 256.0f, PURPLE[3] * 256.0f);
+                         PURPLE[2] * 256.0f, PURPLE[3] * 256.0f);
             glDisable(GL_TEXTURE_2D);
             break;
         default:
-            if (mMode == Render::modeLoadScreen)
-            {
+            if (mMode == Render::modeLoadScreen) {
                 glBlendFunc(GL_SRC_ALPHA, GL_ONE);
-            }
-            else
-            {
+            } else {
                 glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
             }
 
     }
 }
 
-void Render::display()
-{
-    switch (mMode)
-    {
+void Render::display() {
+    switch (mMode) {
         case Render::modeDisabled:
             return;
         case Render::modeLoadScreen:
 
     float camOffsetH = 0.0f;
 
-    switch (getGame().getLara().getMoveType())
-    {
+    switch (getGame().getLara().getMoveType()) {
         case Entity::MoveTypeFly:
         case Entity::MoveTypeNoClipping:
         case Entity::MoveTypeSwim:
 
     // Handle camera out of world
     if ((sector < 0) ||
-            ((unsigned int)sector >= getWorld().getRoom(index).sizeSectors()) ||
-            getWorld().getRoom(index).isWall(sector)) {
+        ((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));
 
     // 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];
+        Room& room = *mRoomRenderList[i];
 
         if (mFlags & Render::fGL_Lights)
             lightRoom(room);
 
     // Draw all visible enities
     if (mFlags & Render::fEntityModels) {
-        std::vector<Entity *> entityRenderList;
+        std::vector<Entity*> entityRenderList;
 
         for (unsigned int i = 0; i < getWorld().sizeEntity(); i++) {
-            Entity &e = getWorld().getEntity(i);
+            Entity& e = getWorld().getEntity(i);
 
             // Don't show Lara to the player
             if (&e == &getGame().getLara())
             // Mongoose 2002.08.15, Nothing to draw, skip
             // Mongoose 2002.12.24, Some entities have no animation =p
             if (e.getModel().size() == 0)
-                    continue;
+                continue;
 
             // Is it in view volume? ( Hack to use sphere )
             if (!isVisible(e.getPos(0), e.getPos(1), e.getPos(2), 512.0f))
 
         // Draw sprites after player to handle alpha
         for (unsigned int i = 0; i < getWorld().sizeSprite(); i++) {
-            SpriteSequence &sprite = getWorld().getSprite(i);
+            SpriteSequence& sprite = getWorld().getSprite(i);
             for (unsigned int j = 0; j < sprite.size(); j++)
                 sprite.get(j).display();
         }
     glFlush();
 }
 
-void Render::drawLoadScreen()
-{
+void Render::drawLoadScreen() {
     float x = 0.0f, y = 0.0f, z = 0.0f;
     float w = getWindow().getWidth(), h = getWindow().getHeight();
 
     glFlush();
 }
 
-void Render::newRoomRenderList(int index)
-{
+void Render::newRoomRenderList(int index) {
     static int currentRoomId = -1;
 
-    if (index == -1) // -1 is error, so draw room 0, for the hell of it
-    {
+    if (index == -1) { // -1 is error, so draw room 0, for the hell of it
         mRoomRenderList.clear();
         mRoomRenderList.push_back(&getWorld().getRoom(0));
-    }
-    else
-    {
+    } else {
         // Update room render list if needed
-        if (currentRoomId != index)
-        {
+        if (currentRoomId != index) {
             buildRoomRenderList(getWorld().getRoom(index));
         }
     }
     currentRoomId = index;
 }
 
-void Render::buildRoomRenderList(Room &room)
-{
+void Render::buildRoomRenderList(Room& room) {
 
     // Must be visible
     //! \fixme Add depth sorting here - remove multipass
         return;
 
     // Must not already be cached
-    for (unsigned int i = 0; i < mRoomRenderList.size(); i++)
-    {
-        Room *room2 = mRoomRenderList[i];
+    for (unsigned int i = 0; i < mRoomRenderList.size(); i++) {
+        Room* room2 = mRoomRenderList[i];
 
         if (room2 == &room)
             return;
     mRoomRenderList.push_back(&room);
 
     // Try to add adj rooms and their adj rooms, skip this room
-    for (unsigned int i = 1; i < room.sizeAdjacentRooms(); i++)
-    {
+    for (unsigned int i = 1; i < room.sizeAdjacentRooms(); i++) {
         if (room.getAdjacentRoom(i) < 0)
             continue;
 
-        Room &room2 = getWorld().getRoom(room.getAdjacentRoom(i));
+        Room& room2 = getWorld().getRoom(room.getAdjacentRoom(i));
 
         //! \fixme Add portal visibility check here
 
     }
 }
 
-void Render::drawSkyMesh(float scale)
-{
+void Render::drawSkyMesh(float scale) {
     //skeletal_model_t *model = getWorld().getModel(mSkyMesh);
     //if (!model)
     //    return;
     glEnable(GL_DEPTH_TEST);
 }
 
-void Render::setSkyMesh(int index, bool rot)
-{
+void Render::setSkyMesh(int index, bool rot) {
     mSkyMesh = index;
     mSkyMeshRotation = rot;
 }
 
-void Render::updateViewVolume()
-{
+void Render::updateViewVolume() {
     float proj[16], mdl[16];
 
     glGetFloatv(GL_PROJECTION_MATRIX, proj);
     mViewVolume.updateFrame(proj, mdl);
 }
 
-bool Render::isVisible(BoundingBox &box) {
+bool Render::isVisible(BoundingBox& box) {
     float bbox[2][3];
     box.getBoundingBox(bbox);
 
     return mViewVolume.isBboxInFrustum(bbox[0], bbox[1]);
 }
 
-bool Render::isVisible(float x, float y, float z)
-{
+bool Render::isVisible(float x, float y, float z) {
     // For debugging purposes
-    if (mMode == Render::modeWireframe)
-    {
+    if (mMode == Render::modeWireframe) {
         glPointSize(5.0);
         glColor3ubv(PINK);
         glBegin(GL_POINTS);
     return (mViewVolume.isPointInFrustum(x, y, z));
 }
 
-bool Render::isVisible(float x, float y, float z, float radius)
-{
+bool Render::isVisible(float x, float y, float z, float radius) {
     // For debugging purposes
-    if (mMode == Render::modeWireframe)
-    {
+    if (mMode == Render::modeWireframe) {
         glPointSize(5.0);
         glColor3ubv(PINK);
         glBegin(GL_POINTS);

src/Room.cpp

 extern std::map<int, int> gMapTex2Bump;
 #endif
 
-Room::Room(TombRaider &tr, unsigned int index) {
+Room::Room(TombRaider& tr, unsigned int index) {
     float box[2][3];
     Matrix transform;
 
 //#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;
+    float* vertexArray;
+    float* normalArray;
+    float* colorArray;
+    unsigned int* indices, *fflags;
+    float* texCoords;
+    int* textures;
 
     tr.getRoomVertexArrays(index,
-            &vertexCount, &vertexArray,
-            &normalCount, &normalArray,
-            &colorCount, &colorArray);
+                           &vertexCount, &vertexArray,
+                           &normalCount, &normalArray,
+                           &colorCount, &colorArray);
 
     mesh.bufferVertexArray(vertexCount, vertexArray);
     mesh.bufferNormalArray(normalCount, normalArray);
     mesh.bufferColorArray(vertexCount, colorArray);
 
     tr.getRoomTriangles(index, getGame().getTextureStart(),
-            &triCount, &indices, &texCoords, &textures,
-            &fflags);
+                        &triCount, &indices, &texCoords, &textures,
+                        &fflags);
 
     mesh.bufferTriangles(triCount, indices, texCoords, textures, fflags);
 #else
     mesh.allocateNormals(0); // count
     mesh.allocateColors(count);
 
-    for (unsigned int i = 0; i < count; ++i)
-    {
+    for (unsigned int i = 0; i < count; ++i) {
         tr.getRoomVertex(index, i, xyz, rgba);
 
         mesh.setVertex(i, xyz[0], xyz[1], xyz[2]);
     int tris_mesh_map[TextureLimit];
     int rect_mesh_map[TextureLimit];
 
-    for (unsigned int i = 0; i < TextureLimit; ++i)
-    {
+    for (unsigned int i = 0; i < TextureLimit; ++i) {
         triangle_counter[i]        = 0;
         triangle_counter_alpha[i]  = 0;
         rectangle_counter[i]       = 0;
     count = tr.getRoomTriangleCount(index);
 
     // Mongoose 2002.08.15, Presort by alpha and texture and setup mapping
-    for (t = 0; t < count; ++t)
-    {
+    for (t = 0; t < count; ++t) {
         tr.getRoomTriangle(index, t,
-                indices, texCoords, &texture, &flags);
+                           indices, texCoords, &texture, &flags);
 
         texture += getGame().getTextureStart();
 
-        if (texture > (int)TextureLimit)
-        {
+        if (texture > (int)TextureLimit) {
             getLog() << "Handling bad room[" << index << "].tris["
-                << t << "].texture = " << texture << Log::endl;
+                     << t << "].texture = " << texture << Log::endl;
             texture = TextureLimit - 1;
         }
 
         // Counters set up polygon allocation
         if (flags & tombraiderFace_Alpha ||
-                flags & tombraiderFace_PartialAlpha)
-        {
+            flags & tombraiderFace_PartialAlpha) {
             triangle_counter_alpha[texture] += 1;
-        }
-        else
-        {
+        } else {
             triangle_counter[texture] += 1;
         }
 
         // Counter sets up texture id to mesh id mapping
-        if (tris_mesh_map[texture] == -1)
-        {
+        if (tris_mesh_map[texture] == -1) {
             tris_mesh_map[texture] = ++numTris;
         }
     }
 
     count = tr.getRoomRectangleCount(index);
 
-    for (r = 0; r < count; ++r)
-    {
+    for (r = 0; r < count; ++r) {
         tr.getRoomRectangle(index, r,
-                indices, texCoords, &texture, &flags);
+                            indices, texCoords, &texture, &flags);
 
         texture += getGame().getTextureStart();
 
-        if (texture > (int)TextureLimit)
-        {
+        if (texture > (int)TextureLimit) {
             getLog() << "Handling bad room[" << index << "].quad["
-                << r << "].texture = " << texture << Log::endl;
+                     << r << "].texture = " << texture << Log::endl;
             texture = TextureLimit - 1;
         }
 
         if (flags & tombraiderFace_Alpha ||
-                flags & tombraiderFace_PartialAlpha)
-        {
+            flags & tombraiderFace_PartialAlpha) {
             rectangle_counter_alpha[texture] += 1;
-        }
-        else
-        {
+        } else {
             rectangle_counter[texture] += 1;
         }
 
-        if (rect_mesh_map[texture] == -1)
-        {
+        if (rect_mesh_map[texture] == -1) {
             rect_mesh_map[texture] = ++numQuads;
         }
     }
     mesh.allocateTriangles(numTris);
     mesh.allocateRectangles(numQuads);
 
-    for (unsigned int i = 0, j = 0; i < TextureLimit; ++i)
-    {
-        if (tris_mesh_map[i] > 0)
-        {
+    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].texcoors = 0x0;
             mesh.mTris[j].texcoors2 = 0x0;
 
-            if (t > 0)
-            {
+            if (t > 0) {
                 mesh.mTris[j].num_triangles = t;
-                mesh.mTris[j].triangles = new unsigned int[t*3];
+                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++)
 
             t = triangle_counter_alpha[i];
 
-            if (t > 0)
-            {
+            if (t > 0) {
                 mesh.mTris[j].num_alpha_triangles = t;
-                mesh.mTris[j].alpha_triangles = new unsigned int[t*3];
+                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++)
 
         ///////////////////////////////////////////
 
-        if (rect_mesh_map[i] > 0)
-        {
+        if (rect_mesh_map[i] > 0) {
             j = rect_mesh_map[i] - 1;
 
             r = rectangle_counter[i];
             mesh.mQuads[j].texcoors = 0x0;
             mesh.mQuads[j].texcoors2 = 0x0;
 
-            if (r > 0)
-            {
+            if (r > 0) {
                 mesh.mQuads[j].num_quads = r;
-                mesh.mQuads[j].quads = new unsigned int[r*4];
+                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++)
 
             r = rectangle_counter_alpha[i];
 
-            if (r > 0)
-            {
+            if (r > 0) {
                 mesh.mQuads[j].num_alpha_quads = r;
-                mesh.mQuads[j].alpha_quads = new unsigned int[r*4];
+                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++)
     // Generate textured triangles
     count = tr.getRoomTriangleCount(index);
 
-    for (t = 0; t < count; ++t)
-    {
+    for (t = 0; t < count; ++t) {
         tr.getRoomTriangle(index, t,
-                indices, texCoords, &texture, &flags);
+                           indices, texCoords, &texture, &flags);
 
         // Adjust texture id using getGame().getTextureStart() to map into
         // correct textures
         unsigned int j = tris_mesh_map[texture] - 1;
 
         // Setup per vertex
-        for (unsigned int i = 0; i < 3; ++i)
-        {
+        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;
+                 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].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];
+                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)
-            {
+            if (flags & tombraiderFace_PartialAlpha) {
                 //mesh.colors[v].rgba[3] = 0.45;
             }
         }
 
         if (flags & tombraiderFace_Alpha ||
-                flags & tombraiderFace_PartialAlpha)
-        {
+            flags & tombraiderFace_PartialAlpha) {
             mesh.mTris[j].cnum_alpha_triangles++;
-        }
-        else
-        {
+        } else {
             mesh.mTris[j].cnum_triangles++;
         }
     }
     // Generate textured quads
     count = tr.getRoomRectangleCount(index);
 
-    for (r = 0; r < count; ++r)
-    {
+    for (r = 0; r < count; ++r) {
         tr.getRoomRectangle(index, r,
-                indices, texCoords, &texture, &flags);
+                            indices, texCoords, &texture, &flags);
 
         // Adjust texture id using getGame().getTextureStart() to map into
         // correct textures
         texture += getGame().getTextureStart();
 
-        if (texture > (int)TextureLimit)
-        {
+        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)
+            mesh.mQuads[j].num_alpha_quads <= 0)
             continue;
 
         // Setup per vertex
-        for (unsigned int i = 0; i < 4; ++i)
-        {
+        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;
+                 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].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];
+                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)
-            {
+            if (flags & tombraiderFace_PartialAlpha) {
                 //rRoom->mesh.colors[v].rgba[3] = 0.45;
             }
         }
 
         if (flags & tombraiderFace_Alpha ||
-                flags & tombraiderFace_PartialAlpha)
-        {
+            flags & tombraiderFace_PartialAlpha) {
             mesh.mQuads[j].cnum_alpha_quads++;
-        }
-        else
-        {
+        } else {
             mesh.mQuads[j].cnum_quads++;
         }
     }
         glColor3ubv(RED);
 
         for (unsigned int i = 0; i < sizePortals(); i++) {
-            Portal &portal = getPortal(i);
+            Portal& portal = getPortal(i);
             float vertices[4][3];
             portal.getVertices(vertices);
 
     // Reset since GL_MODULATE used, reset to WHITE
     glColor3ubv(WHITE);
 
-    switch (getRender().getMode())
-    {
+    switch (getRender().getMode()) {
         case Render::modeWireframe:
             getMesh().mMode = Mesh::MeshModeWireframe;
             break;
 
     // Draw other room meshes and sprites
     if (alpha || (getRender().getMode() == Render::modeWireframe)
-            || (getRender().getMode() == Render::modeSolid)) {
+        || (getRender().getMode() == Render::modeSolid)) {
         sortModels();
         for (unsigned int i = 0; i < sizeModels(); i++)
             getModel(i).display();
     return ((sector > 0) && sectors.at(sector)->isWall());
 }
 
-long Room::getSector(float x, float z, float *floor, float *ceiling) {
+long Room::getSector(float x, float z, float* floor, float* ceiling) {
     assert(floor != NULL);
     assert(ceiling != NULL);
 
 
 long Room::getSector(float x, float z) {
     long sector = (((((int)x - (int)pos[0]) / 1024) *
-        numZSectors) + (((int)z - (int)pos[2]) / 1024));
+                    numZSectors) + (((int)z - (int)pos[2]) / 1024));
 
     if (sector < 0)
         return -1;
     return sector;
 }
 
-void Room::getHeightAtPosition(float x, float *y, float z) {
+void Room::getHeightAtPosition(float x, float* y, float z) {
     long sector = getSector(x, z);
     if ((sector >= 0) && (sector < (long)sectors.size()))
         *y = sectors.at(sector)->getFloor();
 }
 
 int Room::getAdjoiningRoom(float x, float y, float z,
-        float x2, float y2, float z2) {
+                           float x2, float y2, float z2) {
     float intersect[3], p1[3], p2[3];
     float vertices[4][3];
 
     for (unsigned long i = 0; i < portals.size(); i++) {
         portals.at(i)->getVertices(vertices);
         if (intersectionLinePolygon(intersect, p1, p2, //4,
-                    vertices))
+                                    vertices))
             return portals.at(i)->getAdjoiningRoom();
     }
 
     return portals.size();
 }
 
-Portal &Room::getPortal(unsigned long index) {
+Portal& Room::getPortal(unsigned long index) {
     assert(index < portals.size());
     return *portals.at(index);
 }
     return sectors.size();
 }
 
-Sector &Room::getSector(unsigned long index) {
+Sector& Room::getSector(unsigned long index) {
     assert(index < sectors.size());
     return *sectors.at(index);
 }
     return boxes.size();
 }
 
-Box &Room::getBox(unsigned long index) {
+Box& Room::getBox(unsigned long index) {
     assert(index < boxes.size());
     return *boxes.at(index);
 }
     return models.size();
 }
 
-StaticModel &Room::getModel(unsigned long index) {
+StaticModel& Room::getModel(unsigned long index) {
     assert(index < models.size());
     return *models.at(index);
 }
     return lights.size();
 }
 
-Light &Room::getLight(unsigned long index) {
+Light& Room::getLight(unsigned long index) {
     assert(index < lights.size());
     return *lights.at(index);
 }
     return sprites.size();
 }
 
-Sprite &Room::getSprite(unsigned long index) {
+Sprite& Room::getSprite(unsigned long index) {
     assert(index < sprites.size());
     return *sprites.at(index);
 }
 
-BoundingBox &Room::getBoundingBox() {
+BoundingBox& Room::getBoundingBox() {
     return bbox;
 }
 
-Mesh &Room::getMesh() {
+Mesh& Room::getMesh() {
     return mesh;
 }
 

src/RoomData.cpp

     glVertex3f(b[0], b[1], b[2]);
     glVertex3f(a[0], a[1], a[2]);
 
-    if (points)
-    {
+    if (points) {
         glVertex3f(b[0], a[1], b[2]);
         glVertex3f(a[0], b[1], b[2]);
         glVertex3f(b[0], b[1], a[2]);
 
 // ----------------------------------------------------------------------------
 
-Light::Light(TombRaider &tr, unsigned int room, unsigned int index) {
+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);
+                    dir, &att, &cutoff, &lightType, &lightFlags);
 
     switch (lightType) {
         case tombraiderLight_typeDirectional:
 
 // ----------------------------------------------------------------------------
 
-StaticModel::StaticModel(TombRaider &tr, unsigned int room, unsigned int i) {
+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);
+    StaticMesh& mesh = getWorld().getStaticMesh(index);
 
     if (!getRender().isVisible(pos[0], pos[1], pos[2], mesh.getRadius()))
         return;
     glPopMatrix();
 }
 
-bool StaticModel::operator<(const StaticModel &other) {
+bool StaticModel::operator<(const StaticModel& other) {
     float distA, distB;
     distA = getRender().mViewVolume.getDistToSphereFromNear(pos[0],
             pos[1], pos[2], 128.0f);
     return (distA < distB);
 }
 
-bool StaticModel::compare(StaticModel *a, StaticModel *b) {
+bool StaticModel::compare(StaticModel* a, StaticModel* b) {
     return (*b) < (*a);
 }
 
 // ----------------------------------------------------------------------------
 
-Portal::Portal(TombRaider &tr, unsigned int room, unsigned int index, Matrix &transform) {
+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];
+        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]);
 
 // ----------------------------------------------------------------------------
 
-Box::Box(TombRaider &tr, unsigned int room, unsigned int index) {
+Box::Box(TombRaider& tr, unsigned int room, unsigned int index) {
     tr.getRoomBox(room, index, a, b, c, d);
 }
 
 // ----------------------------------------------------------------------------
 
-Sector::Sector(TombRaider &tr, unsigned int room, unsigned int index) {
+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);
+                     &ceiling, &floor, &floorDataIndex, &boxIndex,
+                     &roomBelow, &roomAbove);
 
     wall = (sectorFlags & tombraiderSector_wall);
 }

src/Script.cpp

 
 }
 
-int Script::load(const char *file) {
+int Script::load(const char* file) {
     BinaryFile f;
 
     if (f.open(file) != 0)
     return 0;
 }
 
-void Script::readStringPackage(BinaryFile &f, std::vector<std::string> &v, unsigned int n) {
-    uint16_t *offset = new uint16_t[n];
+void Script::readStringPackage(BinaryFile& f, std::vector<std::string>& v, unsigned int n) {
+    uint16_t* offset = new uint16_t[n];
     for (unsigned int i = 0; i < n; i++)
         offset[i] = f.readU16();
 
     uint16_t numBytes = f.readU16();
 
-    char *list = new char[numBytes];
+    char* list = new char[numBytes];
     for (uint16_t i = 0; i < numBytes; i++) {
         list[i] = f.read8();
         if (flags & S_UseSecurityTag) {
     delete [] offset;
 }
 
-void Script::readScriptPackage(BinaryFile &f, std::vector<std::vector<uint16_t>> &v, unsigned int n) {
-    uint16_t *offset = new uint16_t[n];
+void Script::readScriptPackage(BinaryFile& f, std::vector<std::vector<uint16_t>>& v,
+                               unsigned int n) {
+    uint16_t* offset = new uint16_t[n];
     for (unsigned int i = 0; i < n; i++) {
         offset[i] = f.readU16();
         assertEqual(offset[i] % 2, 0);
     uint16_t numBytes = f.readU16();
     assertEqual(numBytes % 2, 0); // 16 bit opcodes and operands
 
-    uint16_t *list = new uint16_t[(numBytes + 6) / 2];
+    uint16_t* list = new uint16_t[(numBytes + 6) / 2];
     for (uint16_t i = 0; i < (numBytes / 2); i++) {
         list[i] = f.readU16();
     }
     hack[1] = f.readU16();
     hack[2] = f.readU16();
     if (((hack[0] == 19) && (hack[1] == 20) && (hack[2] == 21))
-            || ((hack[0] == 21) && (hack[1] == 22) && (hack[2] == 23))) {
+        || ((hack[0] == 21) && (hack[1] == 22) && (hack[2] == 23))) {
         list[numBytes / 2] = hack[0];
         list[(numBytes / 2) + 1] = hack[1];
         list[(numBytes / 2) + 2] = hack[2];

src/SkeletalModel.cpp

 #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();
+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;
 
         // 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));
+        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;
     return flag;
 }
 
-BoneFrame::BoneFrame(TombRaider &tr, unsigned int index, unsigned int frame_offset) {
-    tr2_moveable_t *moveable = tr.Moveable();
-    unsigned short *frame = tr.Frame();
+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];
     return tag.size();
 }
 
-BoneTag &BoneFrame::get(unsigned long i) {
+BoneTag& BoneFrame::get(unsigned long i) {
     assert(i < tag.size());
     return *tag.at(i);
 }
     p[2] = pos[2];
 }
 
-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();
+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;
 
         if (*frame_offset > tr.NumFrames()) {
             getLog() << "WARNING: Bad animation frame " << *frame_offset
-                << " > " << tr.NumFrames() << " (" << index << "." << a << ")"
-                << Log::endl;
+                     << " > " << tr.NumFrames() << " (" << index << "." << a << ")"
+                     << Log::endl;
             return;
         }
 
     return frame.size();
 }
 
-BoneFrame &AnimationFrame::get(unsigned long i) {
+BoneFrame& AnimationFrame::get(unsigned long i) {
     assert(i < frame.size());
     return *frame.at(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();
+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;
 
                 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);
+                                     moveable[index].num_meshes : 0);
                 ponytailAngle = -90.0f;
                 ponytail[0] = -3;
                 ponytail[1] = -22;
                 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);
+                                     moveable[index].num_meshes : 0);
                 ponytailAngle = -90.0f;
                 ponytail[0] = 0;
                 ponytail[1] = -20;
     assert(aframe < size());
     assert(bframe < get(aframe).size());
 
-    AnimationFrame &anim = get(aframe);
-    BoneFrame &boneframe = anim.get(bframe);
+    AnimationFrame& anim = get(aframe);
+    BoneFrame& boneframe = anim.get(bframe);
 
     float pos[3];
     boneframe.getPosition(pos);
     glTranslatef(pos[0], pos[1], pos[2]);
 
     for (unsigned int a = 0; a < boneframe.size(); a++) {
-        BoneTag &tag = boneframe.get(a);
+        BoneTag& tag = boneframe.get(a);
         float rot[3], off[3];
 
         tag.getRotation(rot);
 
         // Draw layered lara in TR4 (2 meshes per tag)
         if (tr4Overlay) {
-            BoneFrame &boneframe2 = get(0).get(0); //! \fixme Woot?
+            BoneFrame& boneframe2 = get(0).get(0); //! \fixme Woot?
             if (a < boneframe2.size())
                 boneframe2.get(a).display();
         }
     return animation.size();
 }
 
-AnimationFrame &SkeletalModel::get(unsigned long i) {
+AnimationFrame& SkeletalModel::get(unsigned long i) {
     assert(i < animation.size());
     return *animation.at(i);
 }

src/SoundAL.cpp

     if (!mEnabled)
         return 0;
 
-    ALCdevice *Device = alcOpenDevice(NULL);
-    ALCcontext *Context = alcCreateContext(Device, NULL);
+    ALCdevice* Device = alcOpenDevice(NULL);
+    ALCcontext* Context = alcCreateContext(Device, NULL);
     alcMakeContextCurrent(Context);
 
     if (alutInitWithoutContext(NULL, NULL) == AL_FALSE) {
 }
 
 //! \fixme Seperate sourcing and buffering, Mongoose 2002.01.04
-int SoundAL::addFile(const char *filename, unsigned long *source, unsigned int flags) {
+int SoundAL::addFile(const char* filename, unsigned long* source, unsigned int flags) {
     ALsizei size;
     ALfloat freq;
     ALenum format;
-    ALvoid *data;
+    ALvoid* data;
     unsigned long id;
 
     assert(mSource.size() == mBuffer.size());
     return 0;
 }
 
-int SoundAL::addWave(unsigned char *wav, unsigned int length, unsigned long *source, unsigned int flags) {
+int SoundAL::addWave(unsigned char* wav, unsigned int length, unsigned long* source,
+                     unsigned int flags) {
     ALsizei size;
     ALfloat freq;
     ALenum format;
-    ALvoid *data;
+    ALvoid* data;
     int error = 0;
     unsigned long id;
 

src/SoundNull.cpp

     assert(source < sources);
 }
 
-int SoundNull::addFile(const char *filename, unsigned long *source, unsigned int flags) {
+int SoundNull::addFile(const char* filename, unsigned long* source, unsigned int flags) {
     *source = sources;
     sources++;
     return 0;
 }
 
-int SoundNull::addWave(unsigned char *wav, unsigned int length, unsigned long *source, unsigned int flags) {
+int SoundNull::addWave(unsigned char* wav, unsigned int length, unsigned long* source,
+                       unsigned int flags) {
     *source = sources;
     sources++;
     return 0;

src/Sprite.cpp

 #include "Render.h"
 #include "Sprite.h"
 
-SpriteSequence::SpriteSequence(TombRaider &tr, unsigned int item, unsigned int sequence) {
+SpriteSequence::SpriteSequence(TombRaider& tr, unsigned int item, unsigned int sequence) {
     for (int i = 0; i < (-tr.SpriteSequence()[sequence].negative_length); i++)
         sprites.push_back(new Sprite(tr, item, sequence, i));
 }
     return sprites.size();
 }
 
-Sprite &SpriteSequence::get(unsigned long index) {
+Sprite& SpriteSequence::get(unsigned long index) {
     assert(index < sprites.size());
     return *sprites.at(index);
 }
 
-Sprite::Sprite(TombRaider &tr, unsigned int item, unsigned int sequence, unsigned int index) {
-    tr2_item_t *i = tr.Item();
-    tr2_sprite_texture_t *spriteTextures = tr.Sprite();
-    tr2_sprite_sequence_t *spriteSequence = tr.SpriteSequence();
+Sprite::Sprite(TombRaider& tr, unsigned int item, unsigned int sequence, unsigned int index) {
+    tr2_item_t* i = tr.Item();
+    tr2_sprite_texture_t* spriteTextures = tr.Sprite();
+    tr2_sprite_sequence_t* spriteSequence = tr.SpriteSequence();
 
     //! \fixme index was unused?!
-    tr2_sprite_texture_t *sprite = &spriteTextures[spriteSequence[sequence].offset + index];
+    tr2_sprite_texture_t* sprite = &spriteTextures[spriteSequence[sequence].offset + index];
 
     int width = sprite->width >> 8;
     int height = sprite->height >> 8;
     vertex[2][2] = 0;
     vertex[3][2] = 0;
 
-    texel[3][0] = (float)(x+width)/texelScale;
-    texel[3][1] = (float)(y+height)/texelScale;
+    texel[3][0] = (float)(x + width) / texelScale;
+    texel[3][1] = (float)(y + height) / texelScale;
 
-    texel[2][0] = (float)(x+width)/texelScale;
-    texel[2][1] = (float)(y)/texelScale;
+    texel[2][0] = (float)(x + width) / texelScale;
+    texel[2][1] = (float)(y) / texelScale;
 
-    texel[1][0] = (float)(x) /texelScale;
-    texel[1][1] = (float)(y) /texelScale;
+    texel[1][0] = (float)(x) / texelScale;
+    texel[1][1] = (float)(y) / texelScale;
 
     texel[0][0] = (float)(x) / texelScale;
-    texel[0][1] = (float)(y+height)/texelScale;
+    texel[0][1] = (float)(y + height) / texelScale;
 
     texture = sprite->tile + getGame().getTextureStart();
     radius = width2 / 2.0f;
 }
 
-Sprite::Sprite(TombRaider &tr, unsigned int room, unsigned int index) {
+Sprite::Sprite(TombRaider& tr, unsigned int room, unsigned int index) {
     float spriteVertices[12];
     float spriteTexCoords[8];
 
     tr.getRoomSprite(room, index,
-            10.0f, &texture, pos, spriteVertices, spriteTexCoords);
+                     10.0f, &texture, pos, spriteVertices, spriteTexCoords);
 
     texture += getGame().getTextureStart(); // OpenRaider preloads some textures
 
             glColor3ubv(WHITE);
             break;
         default:
-            glBindTexture(GL_TEXTURE_2D, texture+1);
+            glBindTexture(GL_TEXTURE_2D, texture + 1);
 
             glBegin(GL_TRIANGLE_STRIP);
             glTexCoord2fv(texel[0]);

src/StaticMesh.cpp

     transparency = trans;
 }
 
-void TexturedTriangle::display(float *vertices, float *colors, float *normals) {
+void TexturedTriangle::display(float* vertices, float* colors, float* normals) {
     assert(vertices != NULL);
 
     if ((getRender().getMode() != Render::modeWireframe)
-            && (getRender().getMode() != Render::modeSolid)) {
+        && (getRender().getMode() != Render::modeSolid)) {
         glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
         glBindTexture(GL_TEXTURE_2D, texture + 1);
     }
 #include <map>
 std::map<unsigned int, unsigned int> gColorTextureHACK;
 
-int setupTextureColor(float *colorf) {
+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);
+    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];
+    ((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);
+        unsigned char* image = generateColorTexture(color, 32, 32, 32);
         texture = getTextureManager().loadBufferSlot(image, 32, 32,
-                RGBA, 32, getTextureManager().getTextureCount());
+                  RGBA, 32, getTextureManager().getTextureCount());
         delete [] image;
     }
 
 
 #endif
 
-StaticMesh::StaticMesh(TombRaider &tr, unsigned int index) {
+StaticMesh::StaticMesh(TombRaider& tr, unsigned int index) {
     int count, texture;
     int vertexIndices[6];
     float st[12];
     //! \fixme Arrays don't work either  =)
     // Mesh geometery, colors, etc
     tr.getMeshVertexArrays(index,
-            &vertexCount, &vertices,
-            &normalCount, &normals,
-            &colorCount,  &colors);
+                           &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);
+                                   vertexIndices, st,
+                                   &texture, &transparency);
         triangles.push_back(
-                new TexturedTriangle(vertexIndices, st, texture + getGame().getTextureStart(), transparency));
+            new TexturedTriangle(vertexIndices, st, texture + getGame().getTextureStart(), transparency));
     }
 
     // Coloured Triangles
     count = tr.getMeshColoredTriangleCount(index);
     for (int i = 0; i < count; i++) {
         tr.getMeshColoredTriangle(index, i,
-                vertexIndices, color);
+                                  vertexIndices, color);
         st[0] = color[0];
         st[1] = color[1];
         st[2] = color[2];
         transparency = 0;
 
         triangles.push_back(
-                new TexturedTriangle(vertexIndices, st, texture + getGame().getTextureStart(), transparency));
+            new TexturedTriangle(vertexIndices, st, texture + getGame().getTextureStart(), transparency));
     }
 
     // Textured Rectangles
     count = tr.getMeshTexturedRectangleCount(index);
     for (int i = 0; i < count; i++) {
         tr.getMeshTexturedRectangle(index, i,
-                vertexIndices, st,
-                &texture, &transparency);
+                                    vertexIndices, st,
+                                    &texture, &transparency);
         triangles.push_back(
-                new TexturedTriangle(vertexIndices, st, texture + getGame().getTextureStart(), transparency));
+            new TexturedTriangle(vertexIndices, st, texture + getGame().getTextureStart(), transparency));
         triangles.push_back(
-                new TexturedTriangle(vertexIndices + 3, st + 6, texture + getGame().getTextureStart(), transparency));
+            new TexturedTriangle(vertexIndices + 3, st + 6, texture + getGame().getTextureStart(),
+                                 transparency));
     }
 
     // Coloured Rectangles
     count = tr.getMeshColoredRectangleCount(index);
     for (int i = 0; i < count; i++) {
         tr.getMeshColoredRectangle(index, i,
-                vertexIndices, color);
+                                   vertexIndices, color);
 
         st[0] = color[0];
         st[1] = color[1];
         transparency = 0;
 
         triangles.push_back(
-                new TexturedTriangle(vertexIndices, st, texture + getGame().getTextureStart(), transparency));
+            new TexturedTriangle(vertexIndices, st, texture + getGame().getTextureStart(), transparency));
         triangles.push_back(
-                new TexturedTriangle(vertexIndices + 3, st, texture + getGame().getTextureStart(), transparency));
+            new TexturedTriangle(vertexIndices + 3, st, texture + getGame().getTextureStart(), transparency));
     }
 }
 

src/TextureManager.cpp

 }
 
 int TextureManager::initialize() {
-    unsigned char *image = generateColorTexture(WHITE, 32, 32, 32);
+    unsigned char* image = generateColorTexture(WHITE, 32, 32, 32);
     loadBufferSlot(image, 32, 32, RGBA, 32, mTextureIds.size());
     delete [] image;
 
 #endif
 }
 
-int TextureManager::loadBufferSlot(unsigned char *image,
-        unsigned int width, unsigned int height,
-        ColorMode mode, unsigned int bpp,
-        unsigned int slot, bool filter) {
+int TextureManager::loadBufferSlot(unsigned char* image,
+                                   unsigned int width, unsigned int height,
+                                   ColorMode mode, unsigned int bpp,
+                                   unsigned 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));
+           || (mode == BGR) || (mode == ARGB)
+           || (mode == RGBA) || (mode ==  BGRA));
     assert((bpp == 8) || (bpp == 24) || (bpp == 32));
 
     while (mTextureIds.size() <= slot) {
     glBindTexture(GL_TEXTURE_2D, mTextureIds.at(n));
 }
 
-int TextureManager::loadImage(const char *filename) {
+int TextureManager::loadImage(const char* filename) {
     if (stringEndsWith(filename, ".pcx") || stringEndsWith(filename, ".PCX")) {
         return loadPCX(filename);
     } else if (stringEndsWith(filename, ".png") || stringEndsWith(filename, ".PNG")) {
     return -1;
 }
 
-int TextureManager::loadPCX(const char *filename) {
+int TextureManager::loadPCX(const char* filename) {
     assert(filename != NULL);
     assert(filename[0] != '\0');
 
-    unsigned char *image;
+    unsigned char* image;
     unsigned int w, h, bpp;
     ColorMode c;
     int id = -1;
     int error = pcxLoad(filename, &image, &w, &h, &c, &bpp);
 
     if (error == 0) {
-        unsigned char *image2 = scaleBuffer(image, &w, &h, bpp);
+        unsigned char* image2 = scaleBuffer(image, &w, &h, bpp);
         if (image2) {
             delete [] image;
             image = image2;
     return id;
 }
 
-int TextureManager::loadPNG(const char *filename) {
+int TextureManager::loadPNG(const char* filename) {
 #ifdef USING_PNG
     assert(filename != NULL);
     assert(filename[0] != '\0');
         return -1;
     }
 
-    unsigned char *image;
+    unsigned char* image;
     unsigned int w, h, bpp;
     ColorMode c;
     int id = -1;
     int error = pngLoad(filename, &image, &w, &h, &c, &bpp);
 
     if (error == 0) {
-        unsigned char *image2 = scaleBuffer(image, &w, &h, bpp);
+        unsigned char* image2 = scaleBuffer(image, &w, &h, bpp);
         if (image2) {
             delete [] image;
             image = image2;
 #endif
 }
 
-int TextureManager::loadTGA(const char *filename) {
+int TextureManager::loadTGA(const char* filename) {
     assert(filename != NULL);
     assert(filename[0] != '\0');
 
-    unsigned char *image;
+    unsigned char* image;
     unsigned int w, h;
     char type;
     int id = -1;
     if (!tgaCheck(filename)) {
         tgaLoad(filename, &image, &w, &h, &type);
 
-        unsigned char *image2 = scaleBuffer(image, &w, &h, (type == 2) ? 32 : 24);
+        unsigned char* image2 = scaleBuffer(image, &w, &h, (type == 2) ? 32 : 24);
         if (image2) {
             delete [] image;
             image = image2;
         }
         if (image) {
             id = loadBufferSlot(image, w, h,
-                    (type == 2) ? RGBA : RGB,
-                    (type == 2) ? 32 : 24,
-                    mTextureIds.size());
+                                (type == 2) ? RGBA : RGB,
+                                (type == 2) ? 32 : 24,
+                                mTextureIds.size());
             delete [] image;
         }
     }

src/UI.cpp

     ImGui::GetDefaultFontData(NULL, NULL, &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);
+                                           (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, 0, false);
+    //! \fixme TODO use proper texture slot
+    fontTex = getTextureManager().loadBufferSlot((unsigned char*)tex_data,
+              tex_x, tex_y, RGBA, 32, 0, false);
 
     stbi_image_free(tex_data);
 
             auto i = clickEvents.front();
             if (getMenu().isVisible()) {
                 getMenu().handleMouseClick(std::get<0>(i), std::get<1>(i),
-                        std::get<2>(i), std::get<3>(i));
+                                           std::get<2>(i), std::get<3>(i));
             }
             clickEvents.pop_front();
         }
             auto i = motionEvents.front();
             if (!getMenu().isVisible()) {
                 getGame().handleMouseMotion(std::get<0>(i), std::get<1>(i),
-                        std::get<2>(i), std::get<3>(i));
+                                            std::get<2>(i), std::get<3>(i));
             }
             motionEvents.pop_front();
         }
     }
 
     if (visible && (
-                ((!io.WantCaptureKeyboard) && io.KeysDown[escapeKey])
-                || ((!io.WantCaptureMouse) && clicked)
-            )) {
+            ((!io.WantCaptureKeyboard) && io.KeysDown[escapeKey])
+            || ((!io.WantCaptureMouse) && clicked)
+        )) {
         visible = false;
     }
 
         metaKeyIsActive = pressed;
 }
 
-void UI::handleText(char *text, bool notFinished) {
+void UI::handleText(char* text, bool notFinished) {
     if (notFinished)
         return;
 
         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));
+        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));
+                      (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;
         }

src/ViewVolume.cpp

 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) {
+            mFrustum[p][3] <= 0) {
             return false;
         }
     }
 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)
+            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)
+            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)
+            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)
+            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)
+            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)
+            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)
+            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)
+            mFrustum[p][1] * min[1] +
+            mFrustum[p][2] * max[2] + mFrustum[p][3] > 0)
             continue;
 
         return false;
 
     // 5 should be near plane
     d = (mFrustum[5][0] * center[0] +
-            mFrustum[5][1] * center[1] +
-            mFrustum[5][2] * center[2] +
-            mFrustum[5][3]);
+         mFrustum[5][1] * center[1] +
+         mFrustum[5][2] * center[2] +
+         mFrustum[5][3]);
 
     radius = distance(max, center);
 
 
     /* 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][1] * mFrustum[0][1] +
+              mFrustum[0][2] * mFrustum[0][2]);
     mFrustum[0][0] /= t;
     mFrustum[0][1] /= t;
     mFrustum[0][2] /= t;
 
     /* 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][1] * mFrustum[1][1] +
+              mFrustum[1][2] * mFrustum[1][2]);
     mFrustum[1][0] /= t;
     mFrustum[1][1] /= t;
     mFrustum[1][2] /= t;
 
     /* 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][1] * mFrustum[2][1] +
+              mFrustum[2][2] * mFrustum[2][2]);
     mFrustum[2][0] /= t;
     mFrustum[2][1] /= t;
     mFrustum[2][2] /= t;
 
     /* 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][1] * mFrustum[3][1] +
+              mFrustum[3][2] * mFrustum[3][2]);
     mFrustum[3][0] /= t;
     mFrustum[3][1] /= t;
     mFrustum[3][2] /= t;
 
     /* 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][1] * mFrustum[4][1] +
+              mFrustum[4][2] * mFrustum[4][2]);
     mFrustum[4][0] /= t;
     mFrustum[4][1] /= t;
     mFrustum[4][2] /= t;
 
     /* 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][1] * mFrustum[5][1] +
+              mFrustum[5][2] * mFrustum[5][2]);
     mFrustum[5][0] /= t;
     mFrustum[5][1] /= t;
     mFrustum[5][2] /= t;

src/Window.cpp

     // 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;
+    //! \todo MultiTexture flag
+    //if (strstr(s, "GL_ARB_multitexture"))
+    //mFlags |= Render::fMultiTexture;
     //}
 
     // Set up Z buffer
 // 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) {
+                    float lookAtX, float lookAtY, float lookAtZ,
+                    float upX, float upY, float upZ) {
     // calculating the viewing vector
     float f[3] = {
         lookAtX - eyeX,
     f[2] /= fMag;
 
     float s[3] = {
-        (f[1] * upZ) - (upY * f[2]),
-        (upX * f[2]) - (f[0] * upZ),
-        (f[0] * upY) - (upX * f[1])
+        (f[1] * upZ) - (upY* f[2]),
+        (upX* f[2]) - (f[0] * upZ),
+        (f[0] * upY) - (upX* f[1])
     };
 
     float u[3] = {
         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
+        0,    0,     0, 1
     };
     glMultMatrixf(m);
     glTranslatef(-eyeX, -eyeY, -eyeZ);

src/WindowGLUT.cpp

     assert(mInit == false);
 
     int argc = 1;
-    char *argv[] = { new char[11], nullptr };
+    char* argv[] = { new char[11], nullptr };
     strcpy(argv[0], "OpenRaider");
     glutInit(&argc, argv);
     glutInitWindowSize(mWidth, mHeight);
 
     // Alphanumerics can be returned as is
     if (((key >= '0') && (key <= '9'))
-            || ((key >= 'a') && (key <= 'z'))) {
+        || ((key >= 'a') && (key <= 'z'))) {
         return static_cast<KeyboardButton>(key);
     }
 

src/WindowSDL.cpp

     }
 
     mWindow = SDL_CreateWindow(VERSION, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
-                mWidth, mHeight, flags);
+                               mWidth, mHeight, flags);
     if (mWindow == NULL) {
         std::cout << "SDL_CreateWindow Error: " << SDL_GetError() << std::endl;
         return -3;
 
     assert(mInit == true);
 
-    while(SDL_PollEvent(&event)) {
+    while (SDL_PollEvent(&event)) {
         switch (event.type) {
             case SDL_MOUSEMOTION:
                 UI::handleMouseMotion(event.motion.xrel, event.motion.yrel, event.motion.x, event.motion.y);

src/World.cpp

     destroy();
 }
 
-void World::addRoom(Room &room) {
+void World::addRoom(Room& room) {
     mRooms.push_back(std::unique_ptr<Room>(&room));
 }
 
     return mRooms.size();
 }
 
-Room &World::getRoom(unsigned long index) {
+Room& World::getRoom(unsigned long index) {
     assert(index < mRooms.size());
     return *mRooms.at(index);
 }
 
-void World::addSprite(SpriteSequence &sprite) {
+void World::addSprite(SpriteSequence& sprite) {
     mSprites.push_back(std::unique_ptr<SpriteSequence>(&sprite));
 }
 
     return mSprites.size();
 }
 
-SpriteSequence &World::getSprite(unsigned long index) {
+SpriteSequence& World::getSprite(unsigned long index) {
     assert(index < mSprites.size());
     return *mSprites.at(index);
 }
 
-void World::addEntity(Entity &entity) {
+void World::addEntity(Entity& entity) {
     mEntities.push_back(std::unique_ptr<Entity>(&entity));
 }
 
     return mEntities.size();
 }
 
-Entity &World::getEntity(unsigned long index) {
+Entity& World::getEntity(unsigned long index) {
     assert(index < mEntities.size());
     return *mEntities.at(index);
 }
 
-void World::addSkeletalModel(SkeletalModel &model) {
+void World::addSkeletalModel(SkeletalModel& model) {
     mModels.push_back(std::unique_ptr<SkeletalModel>(&model));
 }
 
     return mModels.size();
 }
 
-SkeletalModel &World::getSkeletalModel(unsigned long index) {
+SkeletalModel& World::getSkeletalModel(unsigned long index) {
     assert(index < mModels.size());
     return *mModels.at(index);
 }
 
-void World::addStaticMesh(StaticMesh &model) {
+void World::addStaticMesh(StaticMesh& model) {
     mMeshes.push_back(std::unique_ptr<StaticMesh>(&model));
 }
 
     return mMeshes.size();
 }
 
-StaticMesh &World::getStaticMesh(unsigned long index) {
+StaticMesh& World::getStaticMesh(unsigned long index) {
     assert(index < mMeshes.size());
     return *mMeshes.at(index);
 }
 
 
-long World::getRoomByLocation(long index, float x, float y, float z)
-{
+long World::getRoomByLocation(long index, float x, float y, float z) {
     assert(index >= 0);
     assert(index < (long)mRooms.size());
-    Room &room = *mRooms.at(index);
+    Room& room = *mRooms.at(index);
 
     if (room.getBoundingBox().inBox(x, y, z))
         return index;

src/commands/Command.cpp

             getLog() << "Available commands:" << Log::endl;
             getLog() << std::right << std::setw(11);
             getLog() << "help" << " - print command help" << Log::endl;
-            for (auto &x : commands) {
+            for (auto& x : commands) {
                 if (x) {
                     getLog() << std::right << std::setw(11);
                     getLog() << x->name() << " - " << x->brief() << Log::endl;
             return 0;
         } else {
             // Show help for a specific command
-            for (auto &x : commands) {
+            for (auto& x : commands) {
                 if (x) {
                     if (x->name().compare(arg) == 0) {
                         x->printHelp();
     }
 
     // Execute command
-    for (auto &x : commands) {
+    for (auto& x : commands) {
         if (x) {
             if (x->name().compare(cmd) == 0) {
                 return x->execute(command);

src/commands/CommandAnimate.cpp

         // 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();
+                Entity& e = getWorld().getEntity(i);
+                SkeletalModel& m = e.getModel();
                 if (e.getAnimation() < (m.size() - 1))
                     e.setAnimation(e.getAnimation() + 1);
                 else
         // 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();
+                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 if (m.size() > 0)
+                    e.setAnimation(m.size() - 1);
             }
         } else {
             getLog() << "Animations need to be enabled!" << Log::endl;

src/commands/CommandSet.cpp

     std::string expandNames(std::string s) {
         // Remove quotes
         if ((s.length() >= 3) &&
-                (((s[0] == '"') && (s[s.length() - 1] == '"'))
-                || ((s[0] == '\'') && (s[s.length() - 1] == '\'')))) {
+            (((s[0] == '"') && (s[s.length() - 1] == '"'))
+             || ((s[0] == '\'') && (s[s.length() - 1] == '\'')))) {
             s.erase(0, 1);
             s.erase(s.length() - 1, 1);
         }

src/loader/LoaderTR2.cpp

 
     // Read the 16bit palette, 256 * 4 bytes, RGBA, A unused
     std::array<uint32_t, 256> palette; //!< RGBA, A unused
-    for (auto &x : palette)
+    for (auto& x : palette)
         x = file.readU32();
 
     uint32_t numTextiles = file.readU32();
     std::vector<std::array<uint16_t, 256 * 256>> textiles;
     for (unsigned int i = 0; i < numTextiles; i++) {
         std::array<uint16_t, 256 * 256> arr;
-        for (auto &x : arr) {
+        for (auto& x : arr) {
             x = file.readU16();
         }
         textiles.push_back(arr);
 
 void LoaderTR2::loadSoundMap() {
     std::array<int16_t, 370> soundMap;
-    for (auto &x : soundMap) {
+    for (auto& x : soundMap) {
         x = file.read16();
     }
 

src/main.cpp

 static std::shared_ptr<Window> gWindow;
 static std::shared_ptr<World> gWorld;
 
-Camera &getCamera() {
+Camera& getCamera() {
     return *gCamera;
 }
 
-Game &getGame() {
+Game& getGame() {
     return *gGame;
 }
 
-Log &getLog() {
+Log& getLog() {
     return *gLog;
 }
 
-Menu &getMenu() {
+Menu& getMenu() {
     return *gMenu;
 }
 
-Render &getRender() {
+Render& getRender() {
     return *gRender;
 }
 
-RunTime &getRunTime() {
+RunTime& getRunTime() {
     return *gRunTime;
 }
 
-Sound &getSound() {
+Sound& getSound() {
     return *gSound;
 }
 
-TextureManager &getTextureManager() {
+TextureManager& getTextureManager() {
     return *gTextureManager;
 }
 
-Window &getWindow() {
+Window& getWindow() {
     return *gWindow;
 }
 
-World &getWorld() {
+World& getWorld() {
     return *gWorld;
 }
 
     command_t cmd;
     command_init(&cmd, argv[0], VERSION);
     command_option(&cmd, "-c", "--config <file>", "select config file to use",
-            [](command_t *self) {
+    [](command_t* self) {
         configFileToUse = self->arg;
     });
     command_parse(&cmd, argc, argv);
 
     [[noreturn]] void terminateHandler() {
         const unsigned int maxSize = 128;
-        void *callstack[maxSize];
+        void* callstack[maxSize];
         int frames = backtrace(callstack, maxSize);
-        char **strs = backtrace_symbols(callstack, frames);
+        char** strs = backtrace_symbols(callstack, frames);
 
         std::cout << std::endl;
         for (int i = 0; i < frames; i++)

src/math/Matrix.cpp

     setMatrix(m);
 }
 
-Matrix::Matrix(Quaternion &q) {
+Matrix::Matrix(Quaternion& q) {
     float m[16];
     q.getMatrix(m);
     setMatrix(m);
 
     float wtmp[4][8];
     float m0, m1, m2, m3, s;
-    float *r0, *r1, *r2, *r3;
+    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,
+    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,
+                                                  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,
+                                                                          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;
+                                                                                                  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 (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];
+    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;
     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 (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];
+    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; }
+    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 (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];
+    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];
+                                  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 */
+    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];
+    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);
+            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;
+                                  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;
+                                  r0[6] -= r3[6] * m0, r0[7] -= r3[7] * m0;
 
     m1 = r1[2];                 /* now back substitute row 1 */
-    s  = 1.0f/r1[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);
+            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;
+                                  r0[6] -= r2[6] * m0, r0[7] -= r2[7] * m0;
 
     m0 = r0[1];                 /* now back substitute row 0 */
-    s  = 1.0f/r0[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];
+            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;
 #undef 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];
+    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 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) {
+Matrix Matrix::operator *(const Matrix& a) {
     return multiply(a, *this);
 }
 
     float x = v.mVec[0], y = v.mVec[1], z = v.mVec[2];
 
 #ifdef COLUMN_ORDER
-    return Vector3d(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]);
+    return Vector3d(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 Vector3d(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]);
+    return Vector3d(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];
+    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;
+    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]);
+           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]);
+           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
 }
 
             mMatrix[15] == 1)
         return true;
     */
-    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) &&
+    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;
 
     mMatrix[12] = 0; mMatrix[13] = 0; mMatrix[14] = 0; mMatrix[15] = 1;
 }
 
-void Matrix::scale(const float *xyz) {
+void Matrix::scale(const float* xyz) {
     scale(xyz[0], xyz[1], xyz[2]);
 }
 
     multiply(tmp, smatrix, mMatrix);
 }
 
-void Matrix::rotate(const float *xyz) {
+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;
+    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;
+    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;
+    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) {
+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;
+    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);

src/math/Quaternion.cpp

 }
 
 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[ 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[ 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[ 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[15] = 1.0f;
 }
 
-Quaternion Quaternion::operator *(const Quaternion &q) {
+Quaternion Quaternion::operator *(const Quaternion& q) {
     return multiply(*this, q);
 }
 
-Quaternion Quaternion::operator /(const Quaternion &q) {
+Quaternion Quaternion::operator /(const Quaternion& q) {
     return divide(*this, q);
 }
 
-Quaternion Quaternion::operator +(const Quaternion &q) {
+Quaternion Quaternion::operator +(const Quaternion& q) {
     return add(*this, q);
 }
 
-Quaternion Quaternion::operator -(const Quaternion &q) {
+Quaternion Quaternion::operator -(const Quaternion& q) {
     return subtract(*this, q);
 }
 
-bool Quaternion::operator ==(const Quaternion &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::inverse() {
-    return conjugate().scale(1/magnitude());
+    return conjugate().scale(1 / magnitude());
 }
 
 float Quaternion::dot(Quaternion a, Quaternion b) {
     float temp, dist;
 
     // Normalize
-    temp = x*x + y*y + z*z;
+    temp = x * x + y * y + z * z;
 
     dist = 1.0f / sqrtf(temp);
 
         // 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;
+            scale = (float)sqrt(1.0f + matrix[0] - matrix[5] - matrix[10]) * 2.0f;
 
             // Calculate the quaternion
             w = (matrix[9] - matrix[6]) / 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;
+            scale = (float)sqrt(1.0f + matrix[5] - matrix[0] - matrix[10]) * 2.0f;
 
             // Calculate the quaternion
             w = (matrix[2] - matrix[8]) / 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;
+            scale = (float)sqrt(1.0f + matrix[10] - matrix[0] - matrix[5]) * 2.0f;
 
             // Calculate the quaternion
             w = (matrix[4] - matrix[1]) / scale;
 
 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);
+                      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) {
 
 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);
+                      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);
+                      a.mX - b.mX,
+                      a.mY - b.mY,
+                      a.mZ - b.mZ);
 }
 

src/math/Vector3d.cpp

     mVec[2] = z;
 }
 
-Vector3d::Vector3d(const Vector3d &v) {
+Vector3d::Vector3d(const Vector3d& v) {
     mVec[0] = v.mVec[0];
     mVec[1] = v.mVec[1];
     mVec[2] = v.mVec[2];
 }
 
-float Vector3d::dot(const Vector3d &u, const Vector3d &v) {
-    return (u.mVec[0]*v.mVec[0] + u.mVec[1]*v.mVec[1] + u.mVec[2]*v.mVec[2]);
+float Vector3d::dot(const Vector3d& u, const Vector3d& v) {
+    return (u.mVec[0] * v.mVec[0] + u.mVec[1] * v.mVec[1] + u.mVec[2] * v.mVec[2]);
 }
 
-Vector3d Vector3d::cross(const Vector3d &u, const Vector3d &v) {
+Vector3d Vector3d::cross(const Vector3d& u, const Vector3d& v) {
     return Vector3d(u.mVec[1] * v.mVec[2] - u.mVec[2] * v.mVec[1],
-            u.mVec[2] * v.mVec[0] - u.mVec[0] * v.mVec[2],
-            u.mVec[0] * v.mVec[1] - u.mVec[1] * v.mVec[0]);
+                    u.mVec[2] * v.mVec[0] - u.mVec[0] * v.mVec[2],
+                    u.mVec[0] * v.mVec[1] - u.mVec[1] * v.mVec[0]);
 }
 
 float Vector3d::magnitude() {
-    return sqrtf(mVec[0]*mVec[0] + mVec[1]*mVec[1] + mVec[2]*mVec[2]);
+    return sqrtf(mVec[0] * mVec[0] + mVec[1] * mVec[1] + mVec[2] * mVec[2]);
 }
 
 Vector3d Vector3d::unit() {
     float norm = magnitude();
 
     return Vector3d(mVec[0] / norm,
-            mVec[1] / norm,
-            mVec[2] / norm);
+                    mVec[1] / norm,
+                    mVec[2] / norm);
 }
 
 Vector3d Vector3d::zeroVector() {
     return Vector3d(0, 0, 0);
 }
 
-Vector3d Vector3d::operator +(const Vector3d &v) {
+Vector3d Vector3d::operator +(const Vector3d& v) {
     return Vector3d(mVec[0] + v.mVec[0],
-            mVec[1] + v.mVec[1],
-            mVec[2] + v.mVec[2]);
+                    mVec[1] + v.mVec[1],
+                    mVec[2] + v.mVec[2]);
 }
 
-Vector3d Vector3d::operator -(const Vector3d &v) {
+Vector3d Vector3d::operator -(const Vector3d& v) {
     return Vector3d(mVec[0] - v.mVec[0],
-            mVec[1] - v.mVec[1],
-            mVec[2] - v.mVec[2]);
+                    mVec[1] - v.mVec[1],
+                    mVec[2] - v.mVec[2]);
 }
 
 Vector3d Vector3d::operator -() {
     return Vector3d(-mVec[0],
-            -mVec[1],
-            -mVec[2]);
+                    -mVec[1],
+                    -mVec[2]);
 }
 
 Vector3d Vector3d::operator *(float s) {
     return Vector3d(s * mVec[0],
-            s * mVec[1],
-            s * mVec[2]);
+                    s * mVec[1],
+                    s * mVec[2]);
 }
 
 Vector3d Vector3d::operator /(float s) {
     return Vector3d(mVec[0] / s,
-            mVec[1] / s,
-            mVec[2] / s);
+                    mVec[1] / s,
+                    mVec[2] / s);
 }
 
-float Vector3d::operator *(const Vector3d &v) {
+float Vector3d::operator *(const Vector3d& v) {
     return dot(*this, v);
 }
 
     mVec[2] = 0;
 }
 
-Vector3d &Vector3d::operator =(const Vector3d &v) {
+Vector3d& Vector3d::operator =(const Vector3d& v) {
     mVec[0] = v.mVec[0];
     mVec[1] = v.mVec[1];
     mVec[2] = v.mVec[2];
     return *this;
 }
 
-Vector3d &Vector3d::operator +=(const Vector3d &v) {
+Vector3d& Vector3d::operator +=(const Vector3d& v) {
     mVec[0] += v.mVec[0];
     mVec[1] += v.mVec[1];
     mVec[2] += v.mVec[2];
     return *this;
 }
 
-Vector3d &Vector3d::operator -=(const Vector3d &v) {
+Vector3d& Vector3d::operator -=(const Vector3d& v) {
     mVec[0] -= v.mVec[0];
     mVec[1] -= v.mVec[1];
     mVec[2] -= v.mVec[2];
     return *this;
 }
 
-Vector3d &Vector3d::operator *=(float s) {
+Vector3d& Vector3d::operator *=(float s) {
     mVec[0] *= s;
     mVec[1] *= s;
     mVec[2] *= s;

src/math/math.cpp

 }
 
 int intersectionLinePolygon(float intersect[3],
-        float p1[3], float p2[3], float polygon[3][3]) {
+                            float p1[3], float p2[3], float polygon[3][3]) {
     assert(polygon != NULL);
 
     // float normal[3], a[3], b[3];

src/utils/File.cpp

     std::transform(name.begin(), name.end(), name.begin(), ::tolower);
 }
 
-std::string &File::getName() {
+std::string& File::getName() {
     return name;
 }
 
-std::string &File::getPath() {
+std::string& File::getPath() {
     return path;
 }
 

src/utils/Folder.cpp

 Folder::Folder(std::string folder, bool listDotFiles) {
     if (((folder.length() == 0) || (folder.compare(".") == 0))
 #ifdef _WIN32
-            || ((folder.compare(1, 2, std::string(":\\")) != 0) && (folder.at(0) != '~'))
+        || ((folder.compare(1, 2, std::string(":\\")) != 0) && (folder.at(0) != '~'))
 #else
-            || ((folder.at(0) != '/') && (folder.at(0) != '~'))
+        || ((folder.at(0) != '/') && (folder.at(0) != '~'))
 #endif
-            ) {
+       ) {
         // Prepend current working directory
         path = getCurrentWorkingDirectory();
         if (folder.length() > 1)
     listDot = listDotFiles;
 }
 
-std::string &Folder::getName() {
+std::string& Folder::getName() {
     return name;
 }
 
-std::string &Folder::getPath() {
+std::string& Folder::getPath() {
     return path;
 }
 
     return files.size();
 }
 
-File &Folder::getFile(unsigned long i) {
+File& Folder::getFile(unsigned long i) {
     createFolderItems();
     assert(i < files.size());
     return files.at(i);
     return folders.size();
 }
 
-Folder &Folder::getFolder(unsigned long i) {
+Folder& Folder::getFolder(unsigned long i) {
     createFolderItems();
     assert(i < folders.size());
     return folders.at(i);
     return Folder(parent, listDot);
 }
 
-void Folder::executeRemoveFiles(std::function<bool (File &f)> func) {
+void Folder::executeRemoveFiles(std::function<bool (File& f)> func) {
     createFolderItems();
     for (unsigned long i = 0; i < fileCount(); i++) {
         if (func(getFile(i))) {
 
 #ifdef USE_DIRENT
 
-int Folder::readFolderItems(std::vector<std::string> &foundFiles, std::vector<std::string> &foundFolders) {
+int Folder::readFolderItems(std::vector<std::string>& foundFiles,
+                            std::vector<std::string>& foundFolders) {
     struct dirent entry;
-    struct dirent *ep = nullptr;
-    DIR *pakDir;
+    struct dirent* ep = nullptr;
+    DIR* pakDir;
 
     pakDir = opendir(path.c_str());
     if (pakDir != nullptr) {
         readdir_r(pakDir, &entry, &ep);
         while (ep != nullptr) {
             if ((strcmp(".", ep->d_name) != 0)
-                     && (strcmp("..", ep->d_name) != 0)) {
+                && (strcmp("..", ep->d_name) != 0)) {
                 std::string tmp(path);
                 if (tmp.back() != '/')
                     tmp += '/';
 
 #elif defined(USE_FINDFILE)
 
-int Folder::readFolderItems(std::vector<std::string> &foundFiles, std::vector<std::string> &foundFolders) {
+int Folder::readFolderItems(std::vector<std::string>& foundFiles,
+                            std::vector<std::string>& foundFolders) {
     std::string tmp(path);
     tmp += "/*";