Fixed indent [skip ci]

include/Mesh.h

     // Warning: texture is not the GL texture id,
     // it is an index into the object texture list!
     void addTexturedRectangle(struct vertex_t a, struct vertex_t b,
-            struct vertex_t c, struct vertex_t d, uint16_t texture);
+                              struct vertex_t c, struct vertex_t d, uint16_t texture);
     void addTexturedTriangle(struct vertex_t a, struct vertex_t b,
-            struct vertex_t c, uint16_t texture);
+                             struct vertex_t c, uint16_t texture);
 
     std::vector<struct rectangle_t> texturedRectangles;
     std::vector<struct rectangle_t> coloredRectangles;

include/Render.h

     float getDistToSphereFromNear(float x, float y, float z, float radius);
 
     void debugDisplayTexture(int texture = -1,
-            TextureManager::TextureStorage s = TextureManager::TextureStorage::GAME,
+                             TextureManager::TextureStorage s = TextureManager::TextureStorage::GAME,
-            float x = 0.0f, float y = 0.0f, float w = 256.0f, float h = 256.0f);
+                             float x = 0.0f, float y = 0.0f, float w = 256.0f, float h = 256.0f);
 
     void debugDisplayTextile(int texture = -1,
-            float x = 0.0f, float y = 0.0f, float w = 64.0f, float h = 64.0f);
+                             float x = 0.0f, float y = 0.0f, float w = 64.0f, float h = 64.0f);
 
   private:
 
     void drawTexture(float x, float y, float w, float h,
-            unsigned int texture, TextureManager::TextureStorage s);
+                     unsigned int texture, TextureManager::TextureStorage s);
 
     void drawTextile(float x, float y, float w, float h, unsigned int textile);
 

src/Mesh.cpp

 #include "Mesh.h"
 
 void Mesh::addTexturedRectangle(struct vertex_t a, struct vertex_t b,
-        struct vertex_t c, struct vertex_t d, uint16_t texture) {
+                                struct vertex_t c, struct vertex_t d, uint16_t texture) {
     struct rectangle_t r;
     r.a = a;
     r.b = b;
 }
 
 void Mesh::addTexturedTriangle(struct vertex_t a, struct vertex_t b,
-        struct vertex_t c, uint16_t texture) {
+                               struct vertex_t c, uint16_t texture) {
     struct rectangle_t r;
     r.a = a;
     r.b = b;
 
 void Mesh::drawAlpha() {
     if ((texturedRectangles.size() == 0)
-            && (texturedTriangles.size() == 0)
+        && (texturedTriangles.size() == 0)
-            && (coloredRectangles.size() == 0)
+        && (coloredRectangles.size() == 0)
-            && (coloredTriangles.size() == 0)) {
+        && (coloredTriangles.size() == 0)) {
         drawAlphaOld();
         return;
     }
 
 void Mesh::drawSolid() {
     if ((texturedRectangles.size() == 0)
-            && (texturedTriangles.size() == 0)
+        && (texturedTriangles.size() == 0)
-            && (coloredRectangles.size() == 0)
+        && (coloredRectangles.size() == 0)
-            && (coloredTriangles.size() == 0)) {
+        && (coloredTriangles.size() == 0)) {
         drawSolidOld();
         return;
     }

src/Render.cpp

         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:
             }
 
             glClearColor(BLACK[0] / 256.0f, BLACK[1] / 256.0f,
-                    BLACK[2] / 256.0f, BLACK[3] / 256.0f);
+                         BLACK[2] / 256.0f, BLACK[3] / 256.0f);
 
             glEnable(GL_TEXTURE_2D);
     }
     getWindow().glEnter2D();
 
     drawTexture(0.0f, 0.0f, getWindow().getWidth(), getWindow().getHeight(),
-            TEXTURE_SPLASH, TextureManager::TextureStorage::SYSTEM);
+                TEXTURE_SPLASH, TextureManager::TextureStorage::SYSTEM);
 
     if (debugTexture >= 0)
         drawTexture(debugX, debugY, debugW, debugH, debugTexture, debugTextureStorage);
 }
 
 void Render::debugDisplayTexture(int texture, TextureManager::TextureStorage s,
-        float x, float y, float w, float h) {
+                                 float x, float y, float w, float h) {
     debugTexture = texture;
     debugTextureStorage = s;
     debugX = x;
 }
 
 void Render::drawTexture(float x, float y, float w, float h,
-        unsigned int texture, TextureManager::TextureStorage s) {
+                         unsigned int texture, TextureManager::TextureStorage s) {
     float z = 0.0f;
 
     glColor3ubv(WHITE);

src/TextureManager.cpp

 #endif
 
 TextureTileVertex::TextureTileVertex(uint8_t xc, uint8_t xp, uint8_t yc, uint8_t yp)
-        : xCoordinate(xc), xPixel(xp), yCoordinate(yc), yPixel(yp) { }
+    : xCoordinate(xc), xPixel(xp), yCoordinate(yc), yPixel(yp) { }
 
 // ----------------------------------------------------------------------------
 
     glBegin(GL_TRIANGLE_STRIP);
     for (int i = 0; i < 3; i++) {
         glTexCoord2f(vertices.at(i)->xPixel / 256.0f,
-                vertices.at(i)->yPixel / 256.0f);
+                     vertices.at(i)->yPixel / 256.0f);
 
         if (vertices.at(i)->xCoordinate == 255) {
             if (vertices.at(i)->yCoordinate == 255) {

src/UI.cpp

                     if (offset > 10)
                         offset = 10;
                     ImGui::PlotLines("FPS", &getRunTime().getHistoryFPS()[1],
-                            getRunTime().getHistoryFPS().size() - 1,
+                                     getRunTime().getHistoryFPS().size() - 1,
-                            getRunTime().getHistoryFPS().size() - offset - 1);
+                                     getRunTime().getHistoryFPS().size() - offset - 1);
                 } else {
                     ImGui::PlotLines("FPS", &getRunTime().getHistoryFPS()[1],
-                            getRunTime().getHistoryFPS().size() - 1);
+                                     getRunTime().getHistoryFPS().size() - 1);
                 }
                 ImGui::SameLine();
                 ImGui::Checkbox("Scroll##fpsscroll", &scroll);
             }
 
             float vol = getSound().getVolume();
-            if (ImGui::InputFloat("Volume##runtime", &vol, 0.0f, 0.0f, 3, ImGuiInputTextFlags_EnterReturnsTrue)) {
+            if (ImGui::InputFloat("Volume##runtime", &vol, 0.0f, 0.0f, 3,
+                                  ImGuiInputTextFlags_EnterReturnsTrue)) {
                 if (vol < 0.0f)
                     vol = 0.0f;
                 if (vol > 1.0f)
             static int index = 0;
             ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.5f);
             ImGui::SliderInt("##texslide", &index, 0, getTextureManager().numTextures(
-                        game ? TextureManager::TextureStorage::GAME
+                                 game ? TextureManager::TextureStorage::GAME
-                        : TextureManager::TextureStorage::SYSTEM) - 1);
+                                 : TextureManager::TextureStorage::SYSTEM) - 1);
             ImGui::PopItemWidth();
             ImGui::SameLine();
             if (ImGui::Button("+##texplus", ImVec2(0, 0), true)) {
                 if (index < (getTextureManager().numTextures(
-                                game ? TextureManager::TextureStorage::GAME
+                                 game ? TextureManager::TextureStorage::GAME
-                                : TextureManager::TextureStorage::SYSTEM) - 1))
+                                 : TextureManager::TextureStorage::SYSTEM) - 1))
                     index++;
                 else
                     index = 0;
             }
             if (visibleTex) {
                 getRender().debugDisplayTexture(index,
-                        game ? TextureManager::TextureStorage::GAME
+                                                game ? TextureManager::TextureStorage::GAME
-                        : TextureManager::TextureStorage::SYSTEM,
+                                                : TextureManager::TextureStorage::SYSTEM,
-                        ImGui::GetWindowPos().x - ImGui::GetWindowWidth(),
+                                                ImGui::GetWindowPos().x - ImGui::GetWindowWidth(),
-                        ImGui::GetWindowPos().y,
+                                                ImGui::GetWindowPos().y,
-                        ImGui::GetWindowWidth(), ImGui::GetWindowWidth());
+                                                ImGui::GetWindowWidth(), ImGui::GetWindowWidth());
             }
         }
 
                 }
                 if (visibleTile) {
                     getRender().debugDisplayTextile(index,
-                            ImGui::GetWindowPos().x - (ImGui::GetWindowWidth() / 2),
+                                                    ImGui::GetWindowPos().x - (ImGui::GetWindowWidth() / 2),
-                            ImGui::GetWindowPos().y,
+                                                    ImGui::GetWindowPos().y,
-                            (ImGui::GetWindowWidth() / 2), (ImGui::GetWindowWidth() / 2));
+                                                    (ImGui::GetWindowWidth() / 2), (ImGui::GetWindowWidth() / 2));
                 }
             } else {
                 ImGui::Text("Please load a level using the new loader!");
                         fr--;
                     } else {
                         getRender().debugDisplayTextile(tile,
-                                ImGui::GetWindowPos().x - (ImGui::GetWindowWidth() / 2),
+                                                        ImGui::GetWindowPos().x - (ImGui::GetWindowWidth() / 2),
-                                ImGui::GetWindowPos().y,
+                                                        ImGui::GetWindowPos().y,
-                                (ImGui::GetWindowWidth() / 2), (ImGui::GetWindowWidth() / 2));
+                                                        (ImGui::GetWindowWidth() / 2), (ImGui::GetWindowWidth() / 2));
                         fr = getRunTime().getFPS() / 2;
                         tile = getTextureManager().getNextTileAnimation(tile);
                     }

src/loader/LoaderTR2.cpp

         // Convert 16bit textile to 32bit textile
         unsigned char* img = argb16to32(&arr[0], 256, 256);
         int r = getTextureManager().loadBufferSlot(img, 256, 256, ARGB, 32,
-                    TextureManager::TextureStorage::GAME, i);
+                TextureManager::TextureStorage::GAME, i);
         assert(r >= 0); //! \fixme properly handle error when texture could not be loaded!
         delete [] img;
     }
         int count = animatedTextures.at(pos) + 1;
         if ((pos + count) >= numWords) {
             getLog() << "LoaderTR2: Invalid AnimatedTextures ("
-                << pos + count << " >= " << numWords << ")!" << Log::endl;
+                     << pos + count << " >= " << numWords << ")!" << Log::endl;
             return;
         }
 
             uint16_t texture = file.readU16();
 
             room->getMesh().addTexturedRectangle(vertices.at(vertex1), vertices.at(vertex2),
-                    vertices.at(vertex3), vertices.at(vertex4), texture);
+                                                 vertices.at(vertex3), vertices.at(vertex4), texture);
         }
 
         uint16_t numTriangles = file.readU16();
             uint16_t texture = file.readU16();
 
             room->getMesh().addTexturedTriangle(vertices.at(vertex1), vertices.at(vertex2),
-                    vertices.at(vertex3), texture);
+                                                vertices.at(vertex3), texture);
         }
 
         uint16_t numSprites = file.readU16();
 
         if (std::string("RIFF") != std::string(test)) {
             getLog() << "LoaderTR2: External SFX invalid! (" << riffCount
-                << ", \"" << test << "\" != \"RIFF\")" << Log::endl;
+                     << ", \"" << test << "\" != \"RIFF\")" << Log::endl;
             return;
         }
 
 
     if (numCinematicFrames > 0)
         getLog() << "LoaderTR2: Found " << numCinematicFrames
-            << " CinematicFrames, not yet implemented!" << Log::endl;
+                 << " CinematicFrames, not yet implemented!" << Log::endl;
 }
 
 void LoaderTR2::loadDemoData() {
 
     // TODO store demo data somewhere, find out meaning
     if (numDemoData > 0)
-        getLog() << "LoaderTR2: Found " << numDemoData << " bytes DemoData, not yet implemented!" << Log::endl;
+        getLog() << "LoaderTR2: Found " << numDemoData << " bytes DemoData, not yet implemented!" <<
+                 Log::endl;
 }
 

src/utils/binary.cpp

     if ((offset + c) > max) {
         std::ostringstream ss;
         ss << "BinaryMemory read out of bounds ("
-            << offset << " + " << c << " > " << max;
+           << offset << " + " << c << " > " << max;
         throw new Exception(ss.str());
     }