ninjdai/pokeemerald
1
0
Fork 0
mirror of https://github.com/Ninjdai1/pokeemerald.git synced 2024-11-16 19:47:35 +01:00
Code Issues Packages Projects Releases Wiki Activity

Add ability to specify metatile dimensions to gbagfx

Browse Source
This commit is contained in:
Marcus Huderle 2018-09-06 11:44:50 -05:00
parent f8f7a8e300
commit 78cdd97c8b
5 changed files with 210 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
tools/gbagfx/Makefile
View File

@ -1,12 +1,15 @@
CC = gcc CC = gcc
CFLAGS = -Wall -Wextra -Werror -std=c11 -O2 -DPNG_SKIP_SETJMP_CHECK CFLAGS = -Wall -Wextra -Werror -std=c11 -O2 -s -DPNG_SKIP_SETJMP_CHECK
LIBS = -lpng -lz LIBS = -lpng -lz
SRCS = main.c convert_png.c gfx.c jasc_pal.c lz.c rl.c util.c font.c SRCS = main.c convert_png.c gfx.c jasc_pal.c lz.c rl.c util.c font.c
.PHONY: clean .PHONY: all clean
all: gbagfx
@:
gbagfx: $(SRCS) convert_png.h gfx.h global.h jasc_pal.h lz.h rl.h util.h font.h gbagfx: $(SRCS) convert_png.h gfx.h global.h jasc_pal.h lz.h rl.h util.h font.h
$(CC) $(CFLAGS) $(SRCS) -o $@ $(LDFLAGS) $(LIBS) $(CC) $(CFLAGS) $(SRCS) -o $@ $(LDFLAGS) $(LIBS)

175
tools/gbagfx/gfx.c
View File

@ -18,16 +18,35 @@
#define DOWNCONVERT_BIT_DEPTH(x) ((x) / 8) #define DOWNCONVERT_BIT_DEPTH(x) ((x) / 8)
static void ConvertFromTiles1Bpp(unsigned char *src, unsigned char *dest, int numTiles, int tilesWidth, bool invertColors) static void AdvanceMetatilePosition(int *subTileX, int *subTileY, int *metatileX, int *metatileY, int metatilesWide, int metatileWidth, int metatileHeight)
{ {
int tilesX = 0; (*subTileX)++;
int tilesY = 0; if (*subTileX == metatileWidth) {
int pitch = tilesWidth; *subTileX = 0;
(*subTileY)++;
if (*subTileY == metatileHeight) {
*subTileY = 0;
(*metatileX)++;
if (*metatileX == metatilesWide) {
*metatileX = 0;
(*metatileY)++;
}
}
}
}
static void ConvertFromTiles1Bpp(unsigned char *src, unsigned char *dest, int numTiles, int metatilesWide, int metatileWidth, int metatileHeight, bool invertColors)
{
int subTileX = 0;
int subTileY = 0;
int metatileX = 0;
int metatileY = 0;
int pitch = metatilesWide * metatileWidth;
for (int i = 0; i < numTiles; i++) { for (int i = 0; i < numTiles; i++) {
for (int j = 0; j < 8; j++) { for (int j = 0; j < 8; j++) {
int destY = tilesY * 8 + j; int destY = (metatileY * metatileHeight + subTileY) * 8 + j;
int destX = tilesX; int destX = metatileX * metatileWidth + subTileX;
unsigned char srcPixelOctet = *src++; unsigned char srcPixelOctet = *src++;
unsigned char *destPixelOctet = &dest[destY * pitch + destX]; unsigned char *destPixelOctet = &dest[destY * pitch + destX];
@ -38,27 +57,24 @@ static void ConvertFromTiles1Bpp(unsigned char *src, unsigned char *dest, int nu
} }
} }
tilesX++; AdvanceMetatilePosition(&subTileX, &subTileY, &metatileX, &metatileY, metatilesWide, metatileWidth, metatileHeight);
if (tilesX == tilesWidth) {
tilesX = 0;
tilesY++;
}
} }
} }
static void ConvertFromTiles4Bpp(unsigned char *src, unsigned char *dest, int numTiles, int tilesWidth, bool invertColors) static void ConvertFromTiles4Bpp(unsigned char *src, unsigned char *dest, int numTiles, int metatilesWide, int metatileWidth, int metatileHeight, bool invertColors)
{ {
int tilesX = 0; int subTileX = 0;
int tilesY = 0; int subTileY = 0;
int pitch = tilesWidth * 4; int metatileX = 0;
int metatileY = 0;
int pitch = (metatilesWide * metatileWidth) * 4;
for (int i = 0; i < numTiles; i++) { for (int i = 0; i < numTiles; i++) {
for (int j = 0; j < 8; j++) { for (int j = 0; j < 8; j++) {
int destY = tilesY * 8 + j; int destY = (metatileY * metatileHeight + subTileY) * 8 + j;
for (int k = 0; k < 4; k++) { for (int k = 0; k < 4; k++) {
int destX = tilesX * 4 + k; int destX = (metatileX * metatileWidth + subTileX) * 4 + k;
unsigned char srcPixelPair = *src++; unsigned char srcPixelPair = *src++;
unsigned char leftPixel = srcPixelPair & 0xF; unsigned char leftPixel = srcPixelPair & 0xF;
unsigned char rightPixel = srcPixelPair >> 4; unsigned char rightPixel = srcPixelPair >> 4;
@ -72,27 +88,24 @@ static void ConvertFromTiles4Bpp(unsigned char *src, unsigned char *dest, int nu
} }
} }
tilesX++; AdvanceMetatilePosition(&subTileX, &subTileY, &metatileX, &metatileY, metatilesWide, metatileWidth, metatileHeight);
if (tilesX == tilesWidth) {
tilesX = 0;
tilesY++;
}
} }
} }
static void ConvertFromTiles8Bpp(unsigned char *src, unsigned char *dest, int numTiles, int tilesWidth, bool invertColors) static void ConvertFromTiles8Bpp(unsigned char *src, unsigned char *dest, int numTiles, int metatilesWide, int metatileWidth, int metatileHeight, bool invertColors)
{ {
int tilesX = 0; int subTileX = 0;
int tilesY = 0; int subTileY = 0;
int pitch = tilesWidth * 8; int metatileX = 0;
int metatileY = 0;
int pitch = (metatilesWide * metatileWidth) * 8;
for (int i = 0; i < numTiles; i++) { for (int i = 0; i < numTiles; i++) {
for (int j = 0; j < 8; j++) { for (int j = 0; j < 8; j++) {
int destY = tilesY * 8 + j; int destY = (metatileY * metatileHeight + subTileY) * 8 + j;
for (int k = 0; k < 8; k++) { for (int k = 0; k < 8; k++) {
int destX = tilesX * 8 + k; int destX = (metatileX * metatileWidth + subTileX) * 8 + k;
unsigned char srcPixel = *src++; unsigned char srcPixel = *src++;
if (invertColors) if (invertColors)
@ -102,25 +115,22 @@ static void ConvertFromTiles8Bpp(unsigned char *src, unsigned char *dest, int nu
} }
} }
tilesX++; AdvanceMetatilePosition(&subTileX, &subTileY, &metatileX, &metatileY, metatilesWide, metatileWidth, metatileHeight);
if (tilesX == tilesWidth) {
tilesX = 0;
tilesY++;
}
} }
} }
static void ConvertToTiles1Bpp(unsigned char *src, unsigned char *dest, int numTiles, int tilesWidth, bool invertColors) static void ConvertToTiles1Bpp(unsigned char *src, unsigned char *dest, int numTiles, int metatilesWide, int metatileWidth, int metatileHeight, bool invertColors)
{ {
int tilesX = 0; int subTileX = 0;
int tilesY = 0; int subTileY = 0;
int pitch = tilesWidth; int metatileX = 0;
int metatileY = 0;
int pitch = metatilesWide * metatileWidth;
for (int i = 0; i < numTiles; i++) { for (int i = 0; i < numTiles; i++) {
for (int j = 0; j < 8; j++) { for (int j = 0; j < 8; j++) {
int srcY = tilesY * 8 + j; int srcY = (metatileY * metatileHeight + subTileY) * 8 + j;
int srcX = tilesX; int srcX = metatileX * metatileWidth + subTileX;
unsigned char srcPixelOctet = src[srcY * pitch + srcX]; unsigned char srcPixelOctet = src[srcY * pitch + srcX];
unsigned char *destPixelOctet = dest++; unsigned char *destPixelOctet = dest++;
@ -131,27 +141,24 @@ static void ConvertToTiles1Bpp(unsigned char *src, unsigned char *dest, int numT
} }
} }
tilesX++; AdvanceMetatilePosition(&subTileX, &subTileY, &metatileX, &metatileY, metatilesWide, metatileWidth, metatileHeight);
if (tilesX == tilesWidth) {
tilesX = 0;
tilesY++;
}
} }
} }
static void ConvertToTiles4Bpp(unsigned char *src, unsigned char *dest, int numTiles, int tilesWidth, bool invertColors) static void ConvertToTiles4Bpp(unsigned char *src, unsigned char *dest, int numTiles, int metatilesWide, int metatileWidth, int metatileHeight, bool invertColors)
{ {
int tilesX = 0; int subTileX = 0;
int tilesY = 0; int subTileY = 0;
int pitch = tilesWidth * 4; int metatileX = 0;
int metatileY = 0;
int pitch = (metatilesWide * metatileWidth) * 4;
for (int i = 0; i < numTiles; i++) { for (int i = 0; i < numTiles; i++) {
for (int j = 0; j < 8; j++) { for (int j = 0; j < 8; j++) {
int srcY = tilesY * 8 + j; int srcY = (metatileY * metatileHeight + subTileY) * 8 + j;
for (int k = 0; k < 4; k++) { for (int k = 0; k < 4; k++) {
int srcX = tilesX * 4 + k; int srcX = (metatileX * metatileWidth + subTileX) * 4 + k;
unsigned char srcPixelPair = src[srcY * pitch + srcX]; unsigned char srcPixelPair = src[srcY * pitch + srcX];
unsigned char leftPixel = srcPixelPair >> 4; unsigned char leftPixel = srcPixelPair >> 4;
unsigned char rightPixel = srcPixelPair & 0xF; unsigned char rightPixel = srcPixelPair & 0xF;
@ -165,27 +172,24 @@ static void ConvertToTiles4Bpp(unsigned char *src, unsigned char *dest, int numT
} }
} }
tilesX++; AdvanceMetatilePosition(&subTileX, &subTileY, &metatileX, &metatileY, metatilesWide, metatileWidth, metatileHeight);
if (tilesX == tilesWidth) {
tilesX = 0;
tilesY++;
}
} }
} }
static void ConvertToTiles8Bpp(unsigned char *src, unsigned char *dest, int numTiles, int tilesWidth, bool invertColors) static void ConvertToTiles8Bpp(unsigned char *src, unsigned char *dest, int numTiles, int metatilesWide, int metatileWidth, int metatileHeight, bool invertColors)
{ {
int tilesX = 0; int subTileX = 0;
int tilesY = 0; int subTileY = 0;
int pitch = tilesWidth * 8; int metatileX = 0;
int metatileY = 0;
int pitch = (metatilesWide * metatileWidth) * 8;
for (int i = 0; i < numTiles; i++) { for (int i = 0; i < numTiles; i++) {
for (int j = 0; j < 8; j++) { for (int j = 0; j < 8; j++) {
int srcY = tilesY * 8 + j; int srcY = (metatileY * metatileHeight + subTileY) * 8 + j;
for (int k = 0; k < 8; k++) { for (int k = 0; k < 8; k++) {
int srcX = tilesX * 8 + k; int srcX = (metatileX * metatileWidth + subTileX) * 8 + k;
unsigned char srcPixel = src[srcY * pitch + srcX]; unsigned char srcPixel = src[srcY * pitch + srcX];
if (invertColors) if (invertColors)
@ -195,16 +199,11 @@ static void ConvertToTiles8Bpp(unsigned char *src, unsigned char *dest, int numT
} }
} }
tilesX++; AdvanceMetatilePosition(&subTileX, &subTileY, &metatileX, &metatileY, metatilesWide, metatileWidth, metatileHeight);
if (tilesX == tilesWidth) {
tilesX = 0;
tilesY++;
}
} }
} }
void ReadImage(char *path, int tilesWidth, int bitDepth, struct Image *image, bool invertColors) void ReadImage(char *path, int tilesWidth, int bitDepth, int metatileWidth, int metatileHeight, struct Image *image, bool invertColors)
{ {
int tileSize = bitDepth * 8; int tileSize = bitDepth * 8;
@ -215,6 +214,12 @@ void ReadImage(char *path, int tilesWidth, int bitDepth, struct Image *image, bo
int tilesHeight = (numTiles + tilesWidth - 1) / tilesWidth; int tilesHeight = (numTiles + tilesWidth - 1) / tilesWidth;
if (tilesWidth % metatileWidth != 0)
FATAL_ERROR("The width in tiles (%d) isn't a multiple of the specified metatile width (%d)", tilesWidth, metatileWidth);
if (tilesHeight % metatileHeight != 0)
FATAL_ERROR("The height in tiles (%d) isn't a multiple of the specified metatile height (%d)", tilesHeight, metatileHeight);
image->width = tilesWidth * 8; image->width = tilesWidth * 8;
image->height = tilesHeight * 8; image->height = tilesHeight * 8;
image->bitDepth = bitDepth; image->bitDepth = bitDepth;
@ -223,22 +228,24 @@ void ReadImage(char *path, int tilesWidth, int bitDepth, struct Image *image, bo
if (image->pixels == NULL) if (image->pixels == NULL)
FATAL_ERROR("Failed to allocate memory for pixels.\n"); FATAL_ERROR("Failed to allocate memory for pixels.\n");
int metatilesWide = tilesWidth / metatileWidth;
switch (bitDepth) { switch (bitDepth) {
case 1: case 1:
ConvertFromTiles1Bpp(buffer, image->pixels, numTiles, tilesWidth, invertColors); ConvertFromTiles1Bpp(buffer, image->pixels, numTiles, metatilesWide, metatileWidth, metatileHeight, invertColors);
break; break;
case 4: case 4:
ConvertFromTiles4Bpp(buffer, image->pixels, numTiles, tilesWidth, invertColors); ConvertFromTiles4Bpp(buffer, image->pixels, numTiles, metatilesWide, metatileWidth, metatileHeight, invertColors);
break; break;
case 8: case 8:
ConvertFromTiles8Bpp(buffer, image->pixels, numTiles, tilesWidth, invertColors); ConvertFromTiles8Bpp(buffer, image->pixels, numTiles, metatilesWide, metatileWidth, metatileHeight, invertColors);
break; break;
} }
free(buffer); free(buffer);
} }
void WriteImage(char *path, int numTiles, int bitDepth, struct Image *image, bool invertColors) void WriteImage(char *path, int numTiles, int bitDepth, int metatileWidth, int metatileHeight, struct Image *image, bool invertColors)
{ {
int tileSize = bitDepth * 8; int tileSize = bitDepth * 8;
@ -251,6 +258,12 @@ void WriteImage(char *path, int numTiles, int bitDepth, struct Image *image, boo
int tilesWidth = image->width / 8; int tilesWidth = image->width / 8;
int tilesHeight = image->height / 8; int tilesHeight = image->height / 8;
if (tilesWidth % metatileWidth != 0)
FATAL_ERROR("The width in tiles (%d) isn't a multiple of the specified metatile width (%d)", tilesWidth, metatileWidth);
if (tilesHeight % metatileHeight != 0)
FATAL_ERROR("The height in tiles (%d) isn't a multiple of the specified metatile height (%d)", tilesHeight, metatileHeight);
int maxNumTiles = tilesWidth * tilesHeight; int maxNumTiles = tilesWidth * tilesHeight;
if (numTiles == 0) if (numTiles == 0)
@ -264,15 +277,17 @@ void WriteImage(char *path, int numTiles, int bitDepth, struct Image *image, boo
if (buffer == NULL) if (buffer == NULL)
FATAL_ERROR("Failed to allocate memory for pixels.\n"); FATAL_ERROR("Failed to allocate memory for pixels.\n");
int metatilesWide = tilesWidth / metatileWidth;
switch (bitDepth) { switch (bitDepth) {
case 1: case 1:
ConvertToTiles1Bpp(image->pixels, buffer, numTiles, tilesWidth, invertColors); ConvertToTiles1Bpp(image->pixels, buffer, numTiles, metatilesWide, metatileWidth, metatileHeight, invertColors);
break; break;
case 4: case 4:
ConvertToTiles4Bpp(image->pixels, buffer, numTiles, tilesWidth, invertColors); ConvertToTiles4Bpp(image->pixels, buffer, numTiles, metatilesWide, metatileWidth, metatileHeight, invertColors);
break; break;
case 8: case 8:
ConvertToTiles8Bpp(image->pixels, buffer, numTiles, tilesWidth, invertColors); ConvertToTiles8Bpp(image->pixels, buffer, numTiles, metatilesWide, metatileWidth, metatileHeight, invertColors);
break; break;
} }

4
tools/gbagfx/gfx.h
View File

@ -27,8 +27,8 @@ struct Image {
bool hasTransparency; bool hasTransparency;
}; };
void ReadImage(char *path, int tilesWidth, int bitDepth, struct Image *image, bool invertColors); void ReadImage(char *path, int tilesWidth, int bitDepth, int metatileWidth, int metatileHeight, struct Image *image, bool invertColors);
void WriteImage(char *path, int numTiles, int bitDepth, struct Image *image, bool invertColors); void WriteImage(char *path, int numTiles, int bitDepth, int metatileWidth, int metatileHeight, struct Image *image, bool invertColors);
void FreeImage(struct Image *image); void FreeImage(struct Image *image);
void ReadGbaPalette(char *path, struct Palette *palette); void ReadGbaPalette(char *path, struct Palette *palette);
void WriteGbaPalette(char *path, struct Palette *palette); void WriteGbaPalette(char *path, struct Palette *palette);

105
tools/gbagfx/main.c
View File

@ -5,6 +5,7 @@
#include <stdbool.h> #include <stdbool.h>
#include "global.h" #include "global.h"
#include "util.h" #include "util.h"
#include "options.h"
#include "gfx.h" #include "gfx.h"
#include "convert_png.h" #include "convert_png.h"
#include "jasc_pal.h" #include "jasc_pal.h"
@ -19,13 +20,13 @@ struct CommandHandler
void(*function)(char *inputPath, char *outputPath, int argc, char **argv); void(*function)(char *inputPath, char *outputPath, int argc, char **argv);
}; };
void ConvertGbaToPng(char *inputPath, char *outputPath, int width, int bitDepth, char *paletteFilePath, bool hasTransparency) void ConvertGbaToPng(char *inputPath, char *outputPath, struct GbaToPngOptions *options)
{ {
struct Image image; struct Image image;
if (paletteFilePath != NULL) if (options->paletteFilePath != NULL)
{ {
ReadGbaPalette(paletteFilePath, &image.palette); ReadGbaPalette(options->paletteFilePath, &image.palette);
image.hasPalette = true; image.hasPalette = true;
} }
else else
@ -33,24 +34,24 @@ void ConvertGbaToPng(char *inputPath, char *outputPath, int width, int bitDepth,
image.hasPalette = false; image.hasPalette = false;
} }
ReadImage(inputPath, width, bitDepth, &image, !image.hasPalette); ReadImage(inputPath, options->width, options->bitDepth, options->metatileWidth, options->metatileHeight, &image, !image.hasPalette);
image.hasTransparency = hasTransparency; image.hasTransparency = options->hasTransparency;
WritePng(outputPath, &image); WritePng(outputPath, &image);
FreeImage(&image); FreeImage(&image);
} }
void ConvertPngToGba(char *inputPath, char *outputPath, int numTiles, int bitDepth) void ConvertPngToGba(char *inputPath, char *outputPath, struct PngToGbaOptions *options)
{ {
struct Image image; struct Image image;
image.bitDepth = bitDepth; image.bitDepth = options->bitDepth;
ReadPng(inputPath, &image); ReadPng(inputPath, &image);
WriteImage(outputPath, numTiles, bitDepth, &image, !image.hasPalette); WriteImage(outputPath, options->numTiles, options->bitDepth, options->metatileWidth, options->metatileHeight, &image, !image.hasPalette);
FreeImage(&image); FreeImage(&image);
} }
@ -58,10 +59,13 @@ void ConvertPngToGba(char *inputPath, char *outputPath, int numTiles, int bitDep
void HandleGbaToPngCommand(char *inputPath, char *outputPath, int argc, char **argv) void HandleGbaToPngCommand(char *inputPath, char *outputPath, int argc, char **argv)
{ {
char *inputFileExtension = GetFileExtension(inputPath); char *inputFileExtension = GetFileExtension(inputPath);
int bitDepth = inputFileExtension[0] - '0'; struct GbaToPngOptions options;
char *paletteFilePath = NULL; options.paletteFilePath = NULL;
bool hasTransparency = false; options.bitDepth = inputFileExtension[0] - '0';
int width = 1; options.hasTransparency = false;
options.width = 1;
options.metatileWidth = 1;
options.metatileHeight = 1;
for (int i = 3; i < argc; i++) for (int i = 3; i < argc; i++)
{ {
@ -74,11 +78,11 @@ void HandleGbaToPngCommand(char *inputPath, char *outputPath, int argc, char **a
i++; i++;
paletteFilePath = argv[i]; options.paletteFilePath = argv[i];
} }
else if (strcmp(option, "-object") == 0) else if (strcmp(option, "-object") == 0)
{ {
hasTransparency = true; options.hasTransparency = true;
} }
else if (strcmp(option, "-width") == 0) else if (strcmp(option, "-width") == 0)
{ {
@ -87,26 +91,59 @@ void HandleGbaToPngCommand(char *inputPath, char *outputPath, int argc, char **a
i++; i++;
if (!ParseNumber(argv[i], NULL, 10, &width)) if (!ParseNumber(argv[i], NULL, 10, &options.width))
FATAL_ERROR("Failed to parse width.\n"); FATAL_ERROR("Failed to parse width.\n");
if (width < 1) if (options.width < 1)
FATAL_ERROR("Width must be positive.\n"); FATAL_ERROR("Width must be positive.\n");
} }
else if (strcmp(option, "-mwidth") == 0)
{
if (i + 1 >= argc)
FATAL_ERROR("No metatile width value following \"-mwidth\".\n");
i++;
if (!ParseNumber(argv[i], NULL, 10, &options.metatileWidth))
FATAL_ERROR("Failed to parse metatile width.\n");
if (options.metatileWidth < 1)
FATAL_ERROR("metatile width must be positive.\n");
}
else if (strcmp(option, "-mheight") == 0)
{
if (i + 1 >= argc)
FATAL_ERROR("No metatile height value following \"-mheight\".\n");
i++;
if (!ParseNumber(argv[i], NULL, 10, &options.metatileHeight))
FATAL_ERROR("Failed to parse metatile height.\n");
if (options.metatileHeight < 1)
FATAL_ERROR("metatile height must be positive.\n");
}
else else
{ {
FATAL_ERROR("Unrecognized option \"%s\".\n", option); FATAL_ERROR("Unrecognized option \"%s\".\n", option);
} }
} }
ConvertGbaToPng(inputPath, outputPath, width, bitDepth, paletteFilePath, hasTransparency); if (options.metatileWidth > options.width)
options.width = options.metatileWidth;
ConvertGbaToPng(inputPath, outputPath, &options);
} }
void HandlePngToGbaCommand(char *inputPath, char *outputPath, int argc, char **argv) void HandlePngToGbaCommand(char *inputPath, char *outputPath, int argc, char **argv)
{ {
char *outputFileExtension = GetFileExtension(outputPath); char *outputFileExtension = GetFileExtension(outputPath);
int bitDepth = outputFileExtension[0] - '0'; int bitDepth = outputFileExtension[0] - '0';
int numTiles = 0; struct PngToGbaOptions options;
options.numTiles = 0;
options.bitDepth = bitDepth;
options.metatileWidth = 1;
options.metatileHeight = 1;
for (int i = 3; i < argc; i++) for (int i = 3; i < argc; i++)
{ {
@ -119,19 +156,45 @@ void HandlePngToGbaCommand(char *inputPath, char *outputPath, int argc, char **a
i++; i++;
if (!ParseNumber(argv[i], NULL, 10, &numTiles)) if (!ParseNumber(argv[i], NULL, 10, &options.numTiles))
FATAL_ERROR("Failed to parse number of tiles.\n"); FATAL_ERROR("Failed to parse number of tiles.\n");
if (numTiles < 1) if (options.numTiles < 1)
FATAL_ERROR("Number of tiles must be positive.\n"); FATAL_ERROR("Number of tiles must be positive.\n");
} }
else if (strcmp(option, "-mwidth") == 0)
{
if (i + 1 >= argc)
FATAL_ERROR("No metatile width value following \"-mwidth\".\n");
i++;
if (!ParseNumber(argv[i], NULL, 10, &options.metatileWidth))
FATAL_ERROR("Failed to parse metatile width.\n");
if (options.metatileWidth < 1)
FATAL_ERROR("metatile width must be positive.\n");
}
else if (strcmp(option, "-mheight") == 0)
{
if (i + 1 >= argc)
FATAL_ERROR("No metatile height value following \"-mheight\".\n");
i++;
if (!ParseNumber(argv[i], NULL, 10, &options.metatileHeight))
FATAL_ERROR("Failed to parse metatile height.\n");
if (options.metatileHeight < 1)
FATAL_ERROR("metatile height must be positive.\n");
}
else else
{ {
FATAL_ERROR("Unrecognized option \"%s\".\n", option); FATAL_ERROR("Unrecognized option \"%s\".\n", option);
} }
} }
ConvertPngToGba(inputPath, outputPath, numTiles, bitDepth); ConvertPngToGba(inputPath, outputPath, &options);
} }
void HandlePngToGbaPaletteCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED) void HandlePngToGbaPaletteCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED)

24
tools/gbagfx/options.h Executable file
View File

@ -0,0 +1,24 @@
// Copyright (c) 2018 huderlem
#ifndef OPTIONS_H
#define OPTIONS_H
#include <stdbool.h>
struct GbaToPngOptions {
char *paletteFilePath;
int bitDepth;
bool hasTransparency;
int width;
int metatileWidth;
int metatileHeight;
};
struct PngToGbaOptions {
int numTiles;
int bitDepth;
int metatileWidth;
int metatileHeight;
};
#endif // OPTIONS_H