Remove indents on empty lines

diff --git a/src/engine/asset.c b/src/engine/asset.c
index 92f7b83ddfe24d165b1b3670fe1d331686d93939..11239acc56be4374299228f7be06d93d7e84cabc 100644 (file)
--- a/src/engine/asset.c
+++ b/src/engine/asset.c
@@ -86,30 +86,30 @@ const Solid* importSolid(const char* path) {
                logError("Failed to import solid from %s", path);
                return NULL;
        }
-       
+
 #if IMPORT_DEBUG_
        const struct aiMetadata* meta = scene->mMetaData;
        logDebug("Metadata from %s: %p", path, meta);
        printMetadata(meta);
        printAiNodeMetadata(scene->mRootNode);
 #endif // IMPORT_DEBUG_
-       
+
        const unsigned int numMeshes = scene->mNumMeshes;
        const unsigned int numMaterials = scene->mNumMaterials;
 
        // TODO Consider assets with some arrays empty, and prevent zero mallocs
-       
+
        Solid* solid = malloc(sizeof(Solid));
        solid->numMeshes = numMeshes;
        solid->meshes = malloc(numMeshes * sizeof(Mesh));
        solid->numMaterials = numMaterials;
        solid->materials = malloc(numMaterials * sizeof(Material));
-       
+
        for (unsigned int meshIndex = 0; meshIndex < numMeshes; ++meshIndex) {
                const struct aiMesh* aiMesh = scene->mMeshes[meshIndex];
                const unsigned int numVertices = aiMesh->mNumVertices;
                const unsigned int numFaces = aiMesh->mNumFaces;
-               
+
                Mesh mesh = { .numVertices = numVertices,
                              .vertices = malloc(numVertices * sizeof(Vector)),
                              .normals = NULL,
@@ -117,12 +117,12 @@ const Solid* importSolid(const char* path) {
                              .numFaces = numFaces,
                              .faces = malloc(numFaces * sizeof(Face)),
                              .materialIndex = aiMesh->mMaterialIndex };
-               
+
                for (unsigned int vertIndex = 0; vertIndex < numVertices; ++vertIndex) {
                        mesh.vertices[vertIndex] = convertAiVector3D(
                                        aiMesh->mVertices[vertIndex]);
                }
-               
+
                if (aiMesh->mNormals != NULL) {
                        mesh.normals = malloc(numVertices * sizeof(Vector));
                        for (unsigned int normIndex = 0; normIndex < numVertices; ++normIndex) {
@@ -130,25 +130,25 @@ const Solid* importSolid(const char* path) {
                                                aiMesh->mNormals[normIndex]);
                        }
                }
-               
+
                mesh.textureCoords = malloc(numVertices * sizeof(Vector));
                for (unsigned int texcIndex = 0; texcIndex < numVertices; ++texcIndex) {
                        mesh.textureCoords[texcIndex] = convertAiVector3D(
                                        aiMesh->mTextureCoords[0][texcIndex]);
                }
-               
+
                for (unsigned int faceIndex = 0; faceIndex < numFaces; ++faceIndex) {
                        const struct aiFace aiFace = aiMesh->mFaces[faceIndex];
                        const unsigned int numIndices = aiFace.mNumIndices;
-                       
+
                        Face face = { .numIndices = numIndices,
                                      .indices = malloc(numIndices * sizeof(size_t)),
                                      .normals = malloc(numIndices * sizeof(Vector)) };
-                       
+
                        for (unsigned int i = 0; i < numIndices; ++i) {
                                face.indices[i] = aiFace.mIndices[i];
                        }
-                       
+
                        if (numIndices == 3) {
                                Vector normal = triangleNormal(mesh.vertices[face.indices[0]],
                                                               mesh.vertices[face.indices[1]],
@@ -168,7 +168,7 @@ const Solid* importSolid(const char* path) {
                                        face.normals = NULL;
                                }
                        }
-                       
+
                        mesh.faces[faceIndex] = face;
                }
 
@@ -207,13 +207,13 @@ const Solid* importSolid(const char* path) {
                // TODO Actually clean up the stuff inside
                free(mesh.faces);
                mesh.faces = smoothedFaces;
-               
+
                solid->meshes[meshIndex] = mesh;
        }
-       
+
        GLuint* textureIds = malloc(numMaterials * sizeof(GLuint));
        glGenTextures(numMaterials, textureIds);
-       
+
        for (unsigned int matIndex = 0; matIndex < numMaterials; ++matIndex) {
                Material material = { .textureId = textureIds[matIndex] };
 
@@ -232,10 +232,10 @@ const Solid* importSolid(const char* path) {
 
                dropString(key);
 #endif // IMPORT_DEBUG_
-               
+
                glBindTexture(GL_TEXTURE_2D, material.textureId);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-               
+
                struct aiString originalTexturePath;
                if (aiGetMaterialTexture(scene->mMaterials[matIndex],
                                         aiTextureType_DIFFUSE,
@@ -247,7 +247,7 @@ const Solid* importSolid(const char* path) {
                        char* texturePath = malloc(strlen("assets/") + textureFilenameLength + 1);
                        strcpy(texturePath, "assets/");
                        strncat(texturePath, textureFilename, textureFilenameLength);
-                       
+
                        TgaImage* textureImage = readTga(texturePath);
                        if (textureImage == NULL) {
                                logError("Importing solid from %s: Cannot read texture file %s", path, texturePath);
@@ -266,11 +266,11 @@ const Solid* importSolid(const char* path) {
                                free(textureImage);
                        }
                }
-               
+
                solid->materials[matIndex] = material;
        }
        glBindTexture(GL_TEXTURE_2D, 0);
-       
+
        aiReleaseImport(scene);
        return solid;
 }
@@ -304,18 +304,18 @@ static Vector convertAiVector3D(struct aiVector3D vect) {
  */
 static const char* replaceFileExtension(const struct aiString path, const char* ext) {
                size_t lengthToCopy = path.length;
-               
+
                char* lastDotSubstr = strrchr(path.data, '.');
                if (lastDotSubstr != NULL) {
                        if (strpbrk(lastDotSubstr, "\\/") == NULL) {
                                lengthToCopy = lastDotSubstr - path.data;
                        }
                }
-               
+
                size_t extLength = strlen(ext) + 1;
                char* newPath = malloc(lengthToCopy + extLength);
                strncpy(newPath, path.data, lengthToCopy);
                strncpy(newPath + lengthToCopy, ext, extLength);
-               
+
                return newPath;
 }

diff --git a/src/engine/logger.c b/src/engine/logger.c
index 8ba286f1f22bdaf1a9fcbb93f62839d3a4584131..56ddd4c41c1f3eafe43a379ee4d1510cdb30af3b 100644 (file)
--- a/src/engine/logger.c
+++ b/src/engine/logger.c
@@ -11,7 +11,7 @@ void logMessage(LogLevel msgLevel, const char* func, const char* message, ...) {
        if (msgLevel > logLevel) {
                return;
        }
-       
+
        const char* msgLevelString;
        switch (msgLevel) {
                case LOGLEVEL_ERROR:
@@ -30,13 +30,13 @@ void logMessage(LogLevel msgLevel, const char* func, const char* message, ...) {
                        msgLevelString = "(invalid message level) ";
                        break;
        }
-       
+
        va_list args;
        va_start(args, message);
-       
+
        fprintf(stderr, "%s %s:: ", func, msgLevelString);
        vfprintf(stderr, message, args);
        fputc('\n', stderr);
-       
+
        va_end(args);
 }

diff --git a/src/engine/performance.c b/src/engine/performance.c
index 0281e6277b26fa4b855251e721851d22e4f343f9..2ff7084cfd1a170ab35404012cebc187694eec89 100644 (file)
--- a/src/engine/performance.c
+++ b/src/engine/performance.c
@@ -31,16 +31,16 @@ void frameRendered() {
        if (meteringEnabled) {
                ++frames;
                Timepoint now;
-               
+
                if (clock_gettime(CLOCK_MONOTONIC, &now) != 0) {
                        logWarning("Clock read failed, stopping performance metering");
                        meteringEnabled = false;
                        return;
                }
-               
+
                time_t fullSeconds = now.tv_sec - lastDisplayTime.tv_sec;
                if (now.tv_nsec < lastDisplayTime.tv_nsec) --fullSeconds;
-               
+
                if (fullSeconds > 0) {
                        float seconds = (now.tv_nsec - lastDisplayTime.tv_nsec) / 1000000000.0f;
                        seconds += (float) (now.tv_sec - lastDisplayTime.tv_sec);

diff --git a/src/engine/render.c b/src/engine/render.c
index 692f8fa89fd9491fdf207d0d1fad8878b795ed87..4188755d3fa51482ff7287a6bd51338c2e6c029e 100644 (file)
--- a/src/engine/render.c
+++ b/src/engine/render.c
@@ -20,21 +20,21 @@ static void drawSolid(const Solid* solid);
 
 void initRender() {
        glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
-       
+
        GLfloat light0_ambient[] = {0.1f, 0.1f, 0.1f, 1.0f};
        GLfloat light0_diffuse[] = {1.0f, 1.0f, 1.0f, 1.0f};
        GLfloat light0_specular[] = {0.96f, 0.98f, 1.0f, 1.0f};
        GLfloat light0_position[] = {5.0f, 10.0f, 5.0f, 0.0f}; // (w == 0.0f) == directional
-       
+
        glLightfv(GL_LIGHT0, GL_AMBIENT, light0_ambient);
        glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_diffuse);
        glLightfv(GL_LIGHT0, GL_SPECULAR, light0_specular);
        glLightfv(GL_LIGHT0, GL_POSITION, light0_position);
-       
+
        glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 1.0f);
        glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.05f);
        glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 0.005f);
-       
+
        //glShadeModel(GL_FLAT);
 }
 
@@ -135,18 +135,18 @@ static void drawSolid(const Solid* solid) {
        if (solid == NULL) {
                return;
        }
-       
+
        glMatrixMode(GL_MODELVIEW);
        glColor3f(0.5f, 1.0f, 0.0f);
-       
+
        for (size_t meshIndex = 0; meshIndex < solid->numMeshes; ++meshIndex) {
                const Mesh mesh = solid->meshes[meshIndex];
                glBindTexture(GL_TEXTURE_2D,
                              solid->materials[mesh.materialIndex].textureId);
-               
+
                for (size_t faceIndex = 0; faceIndex < mesh.numFaces; ++faceIndex) {
                        const Face face = mesh.faces[faceIndex];
-                       
+
                        if (debugRender && face.normals) {
                                glDisable(GL_LIGHTING);
                                glDisable(GL_TEXTURE_2D);
@@ -163,7 +163,7 @@ static void drawSolid(const Solid* solid) {
                                glEnable(GL_TEXTURE_2D);
                                glEnable(GL_LIGHTING);
                        }
-                       
+
                        GLenum faceMode;
                        switch (face.numIndices) {
                                case 1: faceMode = GL_POINTS; break;
@@ -171,9 +171,9 @@ static void drawSolid(const Solid* solid) {
                                case 3: faceMode = GL_TRIANGLES; break;
                                default: faceMode = GL_POLYGON; break;
                        }
-                       
+
                        glBegin(faceMode);
-                       
+
                        for (size_t i = 0; i < face.numIndices; ++i) {
                                size_t vertIndex = face.indices[i];
                                if (face.normals) {
@@ -188,7 +188,7 @@ static void drawSolid(const Solid* solid) {
                                Vector vertex = mesh.vertices[vertIndex];
                                glVertex3f(vertex.x, vertex.y, vertex.z);
                        }
-                       
+
                        glEnd();
                }
        }

diff --git a/src/engine/tga.c b/src/engine/tga.c
index 430fab7f8f22833dedf59c4f6f1238bd4e7bf4fd..8ad5725f6c77e65b0837395c292964b8fbae4fd5 100644 (file)
--- a/src/engine/tga.c
+++ b/src/engine/tga.c
@@ -8,17 +8,17 @@ TgaImage* readTga(const char* path) {
        if (tgaFile == NULL) {
                return NULL;
        }
-       
+
        TgaHeader header;
-       
+
        if (fread(&header, sizeof(TgaHeader), 1, tgaFile) != 1) {
                fclose(tgaFile);
                return NULL;
        }
-       
+
        GLenum imageFormat;
        GLint imageComponents;
-       
+
        switch (header.imageBpp) {
                case 32:
                        imageFormat = GL_BGRA;
@@ -36,32 +36,32 @@ TgaImage* readTga(const char* path) {
                        fclose(tgaFile);
                        return NULL;
        }
-       
+
        unsigned long imageSize = header.imageWidth * header.imageHeight * (header.imageBpp >> 3);
-       
+
        GLbyte* bytes = malloc(imageSize * sizeof(GLbyte));
        if (bytes == NULL) {
                fclose(tgaFile);
                return NULL;
        }
-       
+
        if (fread(bytes, imageSize, 1, tgaFile) != 1) {
                free(bytes);
                fclose(tgaFile);
                return NULL;
        }
-       
+
        fclose(tgaFile);
-       
+
        TgaImage* image = malloc(sizeof(TgaImage));
        if (image == NULL) {
                return NULL;
        }
-       
+
        (*image).header = header;
        (*image).imageFormat = imageFormat;
        (*image).imageComponents = imageComponents;
        (*image).bytes = bytes;
-       
+
        return image;
 }

diff --git a/src/game/level.c b/src/game/level.c
index fade95bf45ba018fadc5f49b5ded8a804c826784..0544ba8d8722635258254df52b17768851c7c3e0 100644 (file)
--- a/src/game/level.c
+++ b/src/game/level.c
@@ -61,23 +61,23 @@ static void buildLevelFromImage(const TgaImage* image) {
                logError("Null image received, cannot build level");
                return;
        }
-       
+
        if (image->header.imageBpp != 32) {
                logError("Invalid level image format (%d bpp)", image->header.imageBpp);
                return;
        }
-       
+
        BlockGrid newGrid = { .width = image->header.imageWidth,
                              .depth = image->header.imageHeight,
                              .blocks = malloc(image->header.imageWidth
                                               * image->header.imageHeight
                                               * sizeof(Block*)) };
-       
+
        for (size_t row = 0; row < newGrid.depth; ++row) {
                for (size_t x = 0; x < newGrid.width; ++x) {
                        // Flip the image vertically due to (0, 0) being bottom left
                        size_t z = newGrid.depth - row - 1;
-                       
+
                        uint32_t pixelColorARGB = ((uint32_t*) image->bytes)[(row * newGrid.width) + x];
                        Block* block;
                        switch (pixelColorARGB) {
@@ -98,7 +98,7 @@ static void buildLevelFromImage(const TgaImage* image) {
                        setBlockInGrid(newGrid, x, z, block);
                }
        }
-       
+
        levelGrid = newGrid;
 }