Fixed indentation [skip ci]

src/BoundingBox.cpp

 }
 
 bool BoundingBox::inBoxPlane(glm::vec3 p) {
-    return ((p.x >= corner[0].x) && (p.x <= corner[7].x) && (p.z >= corner[0].z) && (p.z <= corner[7].z));
+    return ((p.x >= corner[0].x) && (p.x <= corner[7].x) && (p.z >= corner[0].z)
+            && (p.z <= corner[7].z));
 }
 
 void BoundingBox::display(glm::mat4 VP, glm::vec3 colorLine, glm::vec3 colorDot) {

src/Mesh.cpp

     }
 
     if (indicesColorBuff.size() > 0)
-        Shader::drawGL(verticesColorBuff, colorsBuff, indicesColorBuff, MVP, gl::GL_TRIANGLES, shaderTexture);
+        Shader::drawGL(verticesColorBuff, colorsBuff, indicesColorBuff, MVP, gl::GL_TRIANGLES,
+                       shaderTexture);
 }
 

src/Render.cpp

 
             // Check if the portal lies behind the player
             if (!((newMin.z <= newMin.w) && (newMin.z >= -newMin.w)
-                && (newMax.z <= newMax.w) && (newMax.z >= -newMax.w))) {
+                  && (newMax.z <= newMax.w) && (newMax.z >= -newMax.w))) {
                 continue;
             }
 
 
             // Check if the portal intersects the portal leading into this room
             if (!((min.x < (newMax.x / newMax.w)) && (max.x > (newMin.x / newMin.w))
-                && (min.y < (newMax.y / newMax.w)) && (max.y > (newMin.y / newMin.w)))) {
+                  && (min.y < (newMax.y / newMax.w)) && (max.y > (newMin.y / newMin.w)))) {
                 continue;
             }
 
 
             // ...only render it if it is not
             if (!found) {
-                buildRoomList(VP, portal.getAdjoiningRoom(), glm::vec2(newMin) / newMin.w, glm::vec2(newMax) / newMax.w);
+                buildRoomList(VP, portal.getAdjoiningRoom(), glm::vec2(newMin) / newMin.w,
+                              glm::vec2(newMax) / newMax.w);
             }
         }
     }

src/RoomData.cpp

 
 Portal::Portal(int adj, glm::vec3 n, glm::vec3 v1, glm::vec3 v2, glm::vec3 v3,
                glm::vec3 v4) : adjoiningRoom(adj), normal(n), bbox(v1, v3),
-                               bboxNormal(v1 + ((v3 - v1) / 2.0f),
-                                          v1 + ((v3 - v1) / 2.0f)
-                                             + (normal * 1024.0f)) {
+    bboxNormal(v1 + ((v3 - v1) / 2.0f),
+               v1 + ((v3 - v1) / 2.0f)
+               + (normal * 1024.0f)) {
     vert[0] = v1; vert[1] = v2;
     vert[2] = v3; vert[3] = v4;
 }

src/TextureManager.cpp

     orAssertGreaterThan(width, 0);
     orAssertGreaterThan(height, 0);
     orAssert((mode == ColorMode::RGB)
-           || (mode == ColorMode::BGR)
-           || (mode == ColorMode::ARGB)
-           || (mode == ColorMode::RGBA)
-           || (mode ==  ColorMode::BGRA));
+             || (mode == ColorMode::BGR)
+             || (mode == ColorMode::ARGB)
+             || (mode == ColorMode::RGBA)
+             || (mode ==  ColorMode::BGRA));
     orAssert((bpp == 8) || (bpp == 24) || (bpp == 32));
 
     if (slot < 0)
 
     gl::glPixelStorei(gl::GL_UNPACK_ALIGNMENT, 1);
     bindTexture(slot, s);
-    gl::glTexImage2D(gl::GL_TEXTURE_2D, 0, gl::GLint(gl::GL_RGBA), width, height, 0, glcMode, gl::GL_UNSIGNED_BYTE, image);
+    gl::glTexImage2D(gl::GL_TEXTURE_2D, 0, gl::GLint(gl::GL_RGBA), width, height, 0, glcMode,
+                     gl::GL_UNSIGNED_BYTE, image);
 
     if (filter) {
         // Trilinear filtering
         gl::glTexParameteri(gl::GL_TEXTURE_2D, gl::GL_TEXTURE_WRAP_S, gl::GLint(gl::GL_REPEAT));
         gl::glTexParameteri(gl::GL_TEXTURE_2D, gl::GL_TEXTURE_WRAP_T, gl::GLint(gl::GL_REPEAT));
         gl::glTexParameteri(gl::GL_TEXTURE_2D, gl::GL_TEXTURE_MAG_FILTER, gl::GLint(gl::GL_LINEAR));
-        gl::glTexParameteri(gl::GL_TEXTURE_2D, gl::GL_TEXTURE_MIN_FILTER, gl::GLint(gl::GL_LINEAR_MIPMAP_LINEAR));
+        gl::glTexParameteri(gl::GL_TEXTURE_2D, gl::GL_TEXTURE_MIN_FILTER,
+                            gl::GLint(gl::GL_LINEAR_MIPMAP_LINEAR));
         gl::glGenerateMipmap(gl::GL_TEXTURE_2D);
     } else {
         gl::glTexParameteri(gl::GL_TEXTURE_2D, gl::GL_TEXTURE_MIN_FILTER, gl::GLint(gl::GL_NEAREST));

src/UI.cpp

 
     gl::glBindBuffer(gl::GL_ARRAY_BUFFER, vboHandle);
 
-    gl::glVertexAttribPointer(attribPos, 2, gl::GL_FLOAT, gl::GL_FALSE, sizeof(ImDrawVert), OFFSETOF(ImDrawVert, pos));
-    gl::glVertexAttribPointer(attribUV, 2, gl::GL_FLOAT, gl::GL_FALSE, sizeof(ImDrawVert), OFFSETOF(ImDrawVert, uv));
-    gl::glVertexAttribPointer(attribCol, 4, gl::GL_UNSIGNED_BYTE, gl::GL_TRUE, sizeof(ImDrawVert), OFFSETOF(ImDrawVert, col));
+    gl::glVertexAttribPointer(attribPos, 2, gl::GL_FLOAT, gl::GL_FALSE, sizeof(ImDrawVert),
+                              OFFSETOF(ImDrawVert, pos));
+    gl::glVertexAttribPointer(attribUV, 2, gl::GL_FLOAT, gl::GL_FALSE, sizeof(ImDrawVert),
+                              OFFSETOF(ImDrawVert, uv));
+    gl::glVertexAttribPointer(attribCol, 4, gl::GL_UNSIGNED_BYTE, gl::GL_TRUE, sizeof(ImDrawVert),
+                              OFFSETOF(ImDrawVert, col));
 
     imguiShader.use();
     imguiShader.loadUniform(0, Window::getSize());
         const ImDrawIdx* idx_buffer_offset = 0;
 
         gl::glBindBuffer(gl::GL_ARRAY_BUFFER, vboHandle);
-        gl::glBufferData(gl::GL_ARRAY_BUFFER, cmd_list->VtxBuffer.size() * sizeof(ImDrawVert), &cmd_list->VtxBuffer.front(), gl::GL_STREAM_DRAW);
+        gl::glBufferData(gl::GL_ARRAY_BUFFER, cmd_list->VtxBuffer.size() * sizeof(ImDrawVert),
+                         &cmd_list->VtxBuffer.front(), gl::GL_STREAM_DRAW);
 
         gl::glBindBuffer(gl::GL_ELEMENT_ARRAY_BUFFER, elementHandle);
-        gl::glBufferData(gl::GL_ELEMENT_ARRAY_BUFFER, cmd_list->IdxBuffer.size() * sizeof(ImDrawIdx), &cmd_list->IdxBuffer.front(), gl::GL_STREAM_DRAW);
+        gl::glBufferData(gl::GL_ELEMENT_ARRAY_BUFFER, cmd_list->IdxBuffer.size() * sizeof(ImDrawIdx),
+                         &cmd_list->IdxBuffer.front(), gl::GL_STREAM_DRAW);
 
-        for (const ImDrawCmd* pcmd = cmd_list->CmdBuffer.begin(); pcmd != cmd_list->CmdBuffer.end(); pcmd++) {
+        for (const ImDrawCmd* pcmd = cmd_list->CmdBuffer.begin(); pcmd != cmd_list->CmdBuffer.end();
+             pcmd++) {
             if (pcmd->UserCallback) {
                 pcmd->UserCallback(cmd_list, pcmd);
                 Log::get(LOG_INFO) << "renderImGui: did not draw (Callback)" << Log::endl;

src/main.cpp

     // Register global OpenGL after-callback for all GL functions except glGetError
     glbinding::setCallbackMaskExcept(glbinding::CallbackMask::After
                                      | glbinding::CallbackMask::ParametersAndReturnValue,
-                                     { "glGetError" });
+    { "glGetError" });
     glbinding::setAfterCallback(glErrorCallback);
     glbinding::setUnresolvedCallback(glUnresolvedCallback);
 #endif

src/system/Shader.cpp

     gl::glGenRenderbuffers(1, &depth);
     gl::glBindRenderbuffer(gl::GL_RENDERBUFFER, depth);
     gl::glRenderbufferStorage(gl::GL_RENDERBUFFER, gl::GL_DEPTH_COMPONENT, width, height);
-    gl::glFramebufferRenderbuffer(gl::GL_FRAMEBUFFER, gl::GL_DEPTH_ATTACHMENT, gl::GL_RENDERBUFFER, depth);
+    gl::glFramebufferRenderbuffer(gl::GL_FRAMEBUFFER, gl::GL_DEPTH_ATTACHMENT, gl::GL_RENDERBUFFER,
+                                  depth);
 
     gl::glFramebufferTexture(gl::GL_FRAMEBUFFER, gl::GL_COLOR_ATTACHMENT0,
-                         TextureManager::getTextureID(texture, TextureStorage::SYSTEM), 0);
+                             TextureManager::getTextureID(texture, TextureStorage::SYSTEM), 0);
 
     gl::GLenum drawBuffer = gl::GL_COLOR_ATTACHMENT0;
     gl::glDrawBuffers(1, &drawBuffer);
 void Shader::loadUniform(int uni, int texture, TextureStorage store) {
     if ((Render::getMode() == RenderMode::Solid)
         && (store == TextureStorage::GAME)) {
-        gl::glUniform1i(getUniform(uni), TextureManager::bindTexture(TEXTURE_SPLASH, TextureStorage::SYSTEM));
+        gl::glUniform1i(getUniform(uni), TextureManager::bindTexture(TEXTURE_SPLASH,
+                        TextureStorage::SYSTEM));
     } else {
         gl::glUniform1i(getUniform(uni), TextureManager::bindTexture(texture, store));
     }
     if (colorShader.addUniform("MVP") < 0)
         return -5;
 
-    if (transformedColorShader.compile(transformedColorShaderVertex, transformedColorShaderFragment) < 0)
+    if (transformedColorShader.compile(transformedColorShaderVertex,
+                                       transformedColorShaderFragment) < 0)
         return -6;
 
     return 0;
     drawGLOnly(indices, MVP, texture, store, mode, target, shader);
 }
 
-void Shader::drawGLBuffer(std::vector<glm::vec3>& vertices, std::vector<glm::vec2>& uvs, Shader& shader) {
+void Shader::drawGLBuffer(std::vector<glm::vec3>& vertices, std::vector<glm::vec2>& uvs,
+                          Shader& shader) {
     shader.vertexBuffer.bufferData(vertices);
     shader.otherBuffer.bufferData(uvs);
 }