diploma tilemap/palette

1 files changed, 237 insertions, 212 deletions

diff --git a/tools/gbagfx/main.c b/tools/gbagfx/main.c
index 54a3c600d..0624201df 100644
--- a/tools/gbagfx/main.c
+++ b/tools/gbagfx/main.c
@@ -14,280 +14,303 @@
 
 struct CommandHandler
 {
-	const char *inputFileExtension;
-	const char *outputFileExtension;
-	void(*function)(char *inputPath, char *outputPath, int argc, char **argv);
+    const char *inputFileExtension;
+    const char *outputFileExtension;
+    void(*function)(char *inputPath, char *outputPath, int argc, char **argv);
 };
 
 void ConvertGbaToPng(char *inputPath, char *outputPath, int width, int bitDepth, char *paletteFilePath, bool hasTransparency)
 {
-	struct Image image;
+    struct Image image;
 
-	if (paletteFilePath != NULL) {
-		ReadGbaPalette(paletteFilePath, &image.palette);
-		image.hasPalette = true;
-	} else {
-		image.hasPalette = false;
-	}
+    if (paletteFilePath != NULL)
+    {
+        ReadGbaPalette(paletteFilePath, &image.palette);
+        image.hasPalette = true;
+    }
+    else
+    {
+        image.hasPalette = false;
+    }
 
-	ReadImage(inputPath, width, bitDepth, &image, !image.hasPalette);
+    ReadImage(inputPath, width, bitDepth, &image, !image.hasPalette);
 
-	image.hasTransparency = hasTransparency;
+    image.hasTransparency = hasTransparency;
 
-	WritePng(outputPath, &image);
+    WritePng(outputPath, &image);
 
-	FreeImage(&image);
+    FreeImage(&image);
 }
 
 void ConvertPngToGba(char *inputPath, char *outputPath, int numTiles, int bitDepth)
 {
-	struct Image image;
+    struct Image image;
 
-	image.bitDepth = bitDepth;
+    image.bitDepth = bitDepth;
 
-	ReadPng(inputPath, &image);
+    ReadPng(inputPath, &image);
 
-	WriteImage(outputPath, numTiles, bitDepth, &image, !image.hasPalette);
+    WriteImage(outputPath, numTiles, bitDepth, &image, !image.hasPalette);
 
-	FreeImage(&image);
+    FreeImage(&image);
 }
 
 void HandleGbaToPngCommand(char *inputPath, char *outputPath, int argc, char **argv)
 {
-	char *inputFileExtension = GetFileExtension(inputPath);
-	int bitDepth = inputFileExtension[0] - '0';
-	char *paletteFilePath;
-	bool hasPalette = false;
-	bool hasTransparency = false;
-	int width = 1;
-
-	for (int i = 3; i < argc; i++) {
-		char *option = argv[i];
-
-		if (strcmp(option, "-palette") == 0) {
-			if (i + 1 >= argc)
-				FATAL_ERROR("No palette file path following \"-palette\".\n");
-
-			i++;
-
-			paletteFilePath = argv[i];
-
-			hasPalette = true;
-		} else if (strcmp(option, "-object") == 0) {
-			hasTransparency = true;
-		} else if (strcmp(option, "-width") == 0) {
-			if (i + 1 >= argc)
-				FATAL_ERROR("No width following \"-width\".\n");
-
-			i++;
-
-			if (!ParseNumber(argv[i], NULL, 10, &width))
-				FATAL_ERROR("Failed to parse width.\n");
-
-			if (width < 1)
-				FATAL_ERROR("Width must be positive.\n");
-		} else {
-			FATAL_ERROR("Unrecognized option \"%s\".\n", option);
-		}
-	}
-
-	ConvertGbaToPng(inputPath, outputPath, width, bitDepth, hasPalette ? paletteFilePath : NULL, hasTransparency);
+    char *inputFileExtension = GetFileExtension(inputPath);
+    int bitDepth = inputFileExtension[0] - '0';
+    char *paletteFilePath;
+    bool hasPalette = false;
+    bool hasTransparency = false;
+    int width = 1;
+
+    for (int i = 3; i < argc; i++)
+    {
+        char *option = argv[i];
+
+        if (strcmp(option, "-palette") == 0)
+        {
+            if (i + 1 >= argc)
+                FATAL_ERROR("No palette file path following \"-palette\".\n");
+
+            i++;
+
+            paletteFilePath = argv[i];
+
+            hasPalette = true;
+        }
+        else if (strcmp(option, "-object") == 0)
+        {
+            hasTransparency = true;
+        }
+        else if (strcmp(option, "-width") == 0)
+        {
+            if (i + 1 >= argc)
+                FATAL_ERROR("No width following \"-width\".\n");
+
+            i++;
+
+            if (!ParseNumber(argv[i], NULL, 10, &width))
+                FATAL_ERROR("Failed to parse width.\n");
+
+            if (width < 1)
+                FATAL_ERROR("Width must be positive.\n");
+        }
+        else
+        {
+            FATAL_ERROR("Unrecognized option \"%s\".\n", option);
+        }
+    }
+
+    ConvertGbaToPng(inputPath, outputPath, width, bitDepth, hasPalette ? paletteFilePath : NULL, hasTransparency);
 }
 
 void HandlePngToGbaCommand(char *inputPath, char *outputPath, int argc, char **argv)
 {
-	char *outputFileExtension = GetFileExtension(outputPath);
-	int bitDepth = outputFileExtension[0] - '0';
-	int numTiles = 0;
-
-	for (int i = 3; i < argc; i++) {
-		char *option = argv[i];
-
-		if (strcmp(option, "-num_tiles") == 0) {
-			if (i + 1 >= argc)
-				FATAL_ERROR("No number of tiles following \"-num_tiles\".\n");
-
-			i++;
-
-			if (!ParseNumber(argv[i], NULL, 10, &numTiles))
-				FATAL_ERROR("Failed to parse number of tiles.\n");
-
-			if (numTiles < 1)
-				FATAL_ERROR("Number of tiles must be positive.\n");
-		} else {
-			FATAL_ERROR("Unrecognized option \"%s\".\n", option);
-		}
-	}
-
-	ConvertPngToGba(inputPath, outputPath, numTiles, bitDepth);
+    char *outputFileExtension = GetFileExtension(outputPath);
+    int bitDepth = outputFileExtension[0] - '0';
+    int numTiles = 0;
+
+    for (int i = 3; i < argc; i++)
+    {
+        char *option = argv[i];
+
+        if (strcmp(option, "-num_tiles") == 0)
+        {
+            if (i + 1 >= argc)
+                FATAL_ERROR("No number of tiles following \"-num_tiles\".\n");
+
+            i++;
+
+            if (!ParseNumber(argv[i], NULL, 10, &numTiles))
+                FATAL_ERROR("Failed to parse number of tiles.\n");
+
+            if (numTiles < 1)
+                FATAL_ERROR("Number of tiles must be positive.\n");
+        }
+        else
+        {
+            FATAL_ERROR("Unrecognized option \"%s\".\n", option);
+        }
+    }
+
+    ConvertPngToGba(inputPath, outputPath, numTiles, bitDepth);
 }
 
 void HandleGbaToJascPaletteCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED)
 {
-	struct Palette palette;
+    struct Palette palette;
 
-	ReadGbaPalette(inputPath, &palette);
-	WriteJascPalette(outputPath, &palette);
+    ReadGbaPalette(inputPath, &palette);
+    WriteJascPalette(outputPath, &palette);
 }
 
 void HandleJascToGbaPaletteCommand(char *inputPath, char *outputPath, int argc, char **argv)
 {
-	int numColors = 0;
+    int numColors = 0;
 
-	for (int i = 3; i < argc; i++) {
-		char *option = argv[i];
+    for (int i = 3; i < argc; i++)
+    {
+        char *option = argv[i];
 
-		if (strcmp(option, "-num_colors") == 0) {
-			if (i + 1 >= argc)
-				FATAL_ERROR("No number of colors following \"-num_colors\".\n");
+        if (strcmp(option, "-num_colors") == 0)
+        {
+            if (i + 1 >= argc)
+                FATAL_ERROR("No number of colors following \"-num_colors\".\n");
 
-			i++;
+            i++;
 
-			if (!ParseNumber(argv[i], NULL, 10, &numColors))
-				FATAL_ERROR("Failed to parse number of colors.\n");
+            if (!ParseNumber(argv[i], NULL, 10, &numColors))
+                FATAL_ERROR("Failed to parse number of colors.\n");
 
-			if (numColors < 1)
-				FATAL_ERROR("Number of colors must be positive.\n");
-		} else {
-			FATAL_ERROR("Unrecognized option \"%s\".\n", option);
-		}
-	}
+            if (numColors < 1)
+                FATAL_ERROR("Number of colors must be positive.\n");
+        }
+        else
+        {
+            FATAL_ERROR("Unrecognized option \"%s\".\n", option);
+        }
+    }
 
-	struct Palette palette;
+    struct Palette palette;
 
-	ReadJascPalette(inputPath, &palette);
+    ReadJascPalette(inputPath, &palette);
 
-	if (numColors != 0)
-		palette.numColors = numColors;
+    if (numColors != 0)
+        palette.numColors = numColors;
 
-	WriteGbaPalette(outputPath, &palette);
+    WriteGbaPalette(outputPath, &palette);
 }
 
 void HandleLatinFontToPngCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED)
 {
-	struct Image image;
+    struct Image image;
 
-	ReadLatinFont(inputPath, &image);
-	WritePng(outputPath, &image);
+    ReadLatinFont(inputPath, &image);
+    WritePng(outputPath, &image);
 
-	FreeImage(&image);
+    FreeImage(&image);
 }
 
 void HandlePngToLatinFontCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED)
 {
-	struct Image image;
+    struct Image image;
 
-	image.bitDepth = 2;
+    image.bitDepth = 2;
 
-	ReadPng(inputPath, &image);
-	WriteLatinFont(outputPath, &image);
+    ReadPng(inputPath, &image);
+    WriteLatinFont(outputPath, &image);
 
-	FreeImage(&image);
+    FreeImage(&image);
 }
 
 void HandleHalfwidthJapaneseFontToPngCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED)
 {
-	struct Image image;
+    struct Image image;
 
-	ReadHalfwidthJapaneseFont(inputPath, &image);
-	WritePng(outputPath, &image);
+    ReadHalfwidthJapaneseFont(inputPath, &image);
+    WritePng(outputPath, &image);
 
-	FreeImage(&image);
+    FreeImage(&image);
 }
 
 void HandlePngToHalfwidthJapaneseFontCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED)
 {
-	struct Image image;
+    struct Image image;
 
-	image.bitDepth = 2;
+    image.bitDepth = 2;
 
-	ReadPng(inputPath, &image);
-	WriteHalfwidthJapaneseFont(outputPath, &image);
+    ReadPng(inputPath, &image);
+    WriteHalfwidthJapaneseFont(outputPath, &image);
 
-	FreeImage(&image);
+    FreeImage(&image);
 }
 
 void HandleFullwidthJapaneseFontToPngCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED)
 {
-	struct Image image;
+    struct Image image;
 
-	ReadFullwidthJapaneseFont(inputPath, &image);
-	WritePng(outputPath, &image);
+    ReadFullwidthJapaneseFont(inputPath, &image);
+    WritePng(outputPath, &image);
 
-	FreeImage(&image);
+    FreeImage(&image);
 }
 
 void HandlePngToFullwidthJapaneseFontCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED)
 {
-	struct Image image;
+    struct Image image;
 
-	image.bitDepth = 2;
+    image.bitDepth = 2;
 
-	ReadPng(inputPath, &image);
-	WriteFullwidthJapaneseFont(outputPath, &image);
+    ReadPng(inputPath, &image);
+    WriteFullwidthJapaneseFont(outputPath, &image);
 
-	FreeImage(&image);
+    FreeImage(&image);
 }
 
 void HandleLZCompressCommand(char *inputPath, char *outputPath, int argc, char **argv)
 {
-	int overflowSize = 0;
+    int overflowSize = 0;
 
-	for (int i = 3; i < argc; i++) {
-		char *option = argv[i];
+    for (int i = 3; i < argc; i++)
+    {
+        char *option = argv[i];
 
-		if (strcmp(option, "-overflow") == 0) {
-			if (i + 1 >= argc)
-				FATAL_ERROR("No size following \"-overflow\".\n");
+        if (strcmp(option, "-overflow") == 0)
+        {
+            if (i + 1 >= argc)
+                FATAL_ERROR("No size following \"-overflow\".\n");
 
-			i++;
+            i++;
 
-			if (!ParseNumber(argv[i], NULL, 10, &overflowSize))
-				FATAL_ERROR("Failed to parse overflow size.\n");
+            if (!ParseNumber(argv[i], NULL, 10, &overflowSize))
+                FATAL_ERROR("Failed to parse overflow size.\n");
 
-			if (overflowSize < 1)
-				FATAL_ERROR("Overflow size must be positive.\n");
-		} else {
-			FATAL_ERROR("Unrecognized option \"%s\".\n", option);
-		}
-	}
+            if (overflowSize < 1)
+                FATAL_ERROR("Overflow size must be positive.\n");
+        }
+        else
+        {
+            FATAL_ERROR("Unrecognized option \"%s\".\n", option);
+        }
+    }
 
-	// The overflow option allows a quirk in some of Ruby/Sapphire's tilesets
-	// to be reproduced. It works by appending a number of zeros to the data
-	// before compressing it and then amending the LZ header's size field to
-	// reflect the expected size. This will cause an overflow when decompressing
-	// the data.
+    // The overflow option allows a quirk in some of Ruby/Sapphire's tilesets
+    // to be reproduced. It works by appending a number of zeros to the data
+    // before compressing it and then amending the LZ header's size field to
+    // reflect the expected size. This will cause an overflow when decompressing
+    // the data.
 
-	int fileSize;
-	unsigned char *buffer = ReadWholeFileZeroPadded(inputPath, &fileSize, overflowSize);
+    int fileSize;
+    unsigned char *buffer = ReadWholeFileZeroPadded(inputPath, &fileSize, overflowSize);
 
-	int compressedSize;
-	unsigned char *compressedData = LZCompress(buffer, fileSize + overflowSize, &compressedSize);
+    int compressedSize;
+    unsigned char *compressedData = LZCompress(buffer, fileSize + overflowSize, &compressedSize);
 
-	compressedData[1] = (unsigned char)fileSize;
-	compressedData[2] = (unsigned char)(fileSize >> 8);
-	compressedData[3] = (unsigned char)(fileSize >> 16);
+    compressedData[1] = (unsigned char)fileSize;
+    compressedData[2] = (unsigned char)(fileSize >> 8);
+    compressedData[3] = (unsigned char)(fileSize >> 16);
 
-	free(buffer);
+    free(buffer);
 
-	WriteWholeFile(outputPath, compressedData, compressedSize);
+    WriteWholeFile(outputPath, compressedData, compressedSize);
 
-	free(compressedData);
+    free(compressedData);
 }
 
 void HandleLZDecompressCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED)
 {
-	int fileSize;
-	unsigned char *buffer = ReadWholeFile(inputPath, &fileSize);
+    int fileSize;
+    unsigned char *buffer = ReadWholeFile(inputPath, &fileSize);
 
-	int uncompressedSize;
-	unsigned char *uncompressedData = LZDecompress(buffer, fileSize, &uncompressedSize);
+    int uncompressedSize;
+    unsigned char *uncompressedData = LZDecompress(buffer, fileSize, &uncompressedSize);
 
-	free(buffer);
+    free(buffer);
 
-	WriteWholeFile(outputPath, uncompressedData, uncompressedSize);
+    WriteWholeFile(outputPath, uncompressedData, uncompressedSize);
 
-	free(uncompressedData);
+    free(uncompressedData);
 }
 
 void HandleRLCompressCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED)
@@ -322,50 +345,52 @@ void HandleRLDecompressCommand(char *inputPath, char *outputPath, int argc UNUSE
 
 int main(int argc, char **argv)
 {
-	if (argc < 3)
-		FATAL_ERROR("Usage: gbagfx INPUT_PATH OUTPUT_PATH [options...]\n");
-
-	struct CommandHandler handlers[] =
-	{
-		{ "1bpp", "png", HandleGbaToPngCommand },
-		{ "4bpp", "png", HandleGbaToPngCommand },
-		{ "8bpp", "png", HandleGbaToPngCommand },
-		{ "png", "1bpp", HandlePngToGbaCommand },
-		{ "png", "4bpp", HandlePngToGbaCommand },
-		{ "png", "8bpp", HandlePngToGbaCommand },
-		{ "gbapal", "pal", HandleGbaToJascPaletteCommand },
-		{ "pal", "gbapal", HandleJascToGbaPaletteCommand },
-		{ "latfont", "png", HandleLatinFontToPngCommand },
-		{ "png", "latfont", HandlePngToLatinFontCommand },
-		{ "hwjpnfont", "png", HandleHalfwidthJapaneseFontToPngCommand },
-		{ "png", "hwjpnfont", HandlePngToHalfwidthJapaneseFontCommand },
-		{ "fwjpnfont", "png", HandleFullwidthJapaneseFontToPngCommand },
-		{ "png", "fwjpnfont", HandlePngToFullwidthJapaneseFontCommand },
-		{ NULL, "lz", HandleLZCompressCommand },
-		{ "lz", NULL, HandleLZDecompressCommand },
+    if (argc < 3)
+        FATAL_ERROR("Usage: gbagfx INPUT_PATH OUTPUT_PATH [options...]\n");
+
+    struct CommandHandler handlers[] =
+    {
+        { "1bpp", "png", HandleGbaToPngCommand },
+        { "4bpp", "png", HandleGbaToPngCommand },
+        { "8bpp", "png", HandleGbaToPngCommand },
+        { "png", "1bpp", HandlePngToGbaCommand },
+        { "png", "4bpp", HandlePngToGbaCommand },
+        { "png", "8bpp", HandlePngToGbaCommand },
+        { "gbapal", "pal", HandleGbaToJascPaletteCommand },
+        { "pal", "gbapal", HandleJascToGbaPaletteCommand },
+        { "latfont", "png", HandleLatinFontToPngCommand },
+        { "png", "latfont", HandlePngToLatinFontCommand },
+        { "hwjpnfont", "png", HandleHalfwidthJapaneseFontToPngCommand },
+        { "png", "hwjpnfont", HandlePngToHalfwidthJapaneseFontCommand },
+        { "fwjpnfont", "png", HandleFullwidthJapaneseFontToPngCommand },
+        { "png", "fwjpnfont", HandlePngToFullwidthJapaneseFontCommand },
+        { NULL, "lz", HandleLZCompressCommand },
+        { "lz", NULL, HandleLZDecompressCommand },
         { NULL, "rl", HandleRLCompressCommand },
         { "rl", NULL, HandleRLDecompressCommand },
-		{ NULL, NULL, NULL }
-	};
-
-	char *inputPath = argv[1];
-	char *outputPath = argv[2];
-	char *inputFileExtension = GetFileExtension(inputPath);
-	char *outputFileExtension = GetFileExtension(outputPath);
-
-	if (inputFileExtension == NULL)
-		FATAL_ERROR("Input file \"%s\" has no extension.\n", inputPath);
-
-	if (outputFileExtension == NULL)
-		FATAL_ERROR("Output file \"%s\" has no extension.\n", outputPath);
-
-	for (int i = 0; handlers[i].function != NULL; i++) {
-		if ((handlers[i].inputFileExtension == NULL || strcmp(handlers[i].inputFileExtension, inputFileExtension) == 0)
-		 && (handlers[i].outputFileExtension == NULL || strcmp(handlers[i].outputFileExtension, outputFileExtension) == 0)) {
-			handlers[i].function(inputPath, outputPath, argc, argv);
-			return 0;
-		}
-	}
-
-	FATAL_ERROR("Don't know how to convert \"%s\" to \"%s\".\n", inputPath, outputPath);
+        { NULL, NULL, NULL }
+    };
+
+    char *inputPath = argv[1];
+    char *outputPath = argv[2];
+    char *inputFileExtension = GetFileExtension(inputPath);
+    char *outputFileExtension = GetFileExtension(outputPath);
+
+    if (inputFileExtension == NULL)
+        FATAL_ERROR("Input file \"%s\" has no extension.\n", inputPath);
+
+    if (outputFileExtension == NULL)
+        FATAL_ERROR("Output file \"%s\" has no extension.\n", outputPath);
+
+    for (int i = 0; handlers[i].function != NULL; i++)
+    {
+        if ((handlers[i].inputFileExtension == NULL || strcmp(handlers[i].inputFileExtension, inputFileExtension) == 0)
+            && (handlers[i].outputFileExtension == NULL || strcmp(handlers[i].outputFileExtension, outputFileExtension) == 0))
+        {
+            handlers[i].function(inputPath, outputPath, argc, argv);
+            return 0;
+        }
+    }
+
+    FATAL_ERROR("Don't know how to convert \"%s\" to \"%s\".\n", inputPath, outputPath);
 }