summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--tools/narccomp/.gitignore1
-rw-r--r--tools/nitrogfx/gfx.c95
-rw-r--r--tools/nitrogfx/gfx.h2
-rw-r--r--tools/nitrogfx/main.c161
-rw-r--r--tools/nitrogfx/util.c30
-rw-r--r--tools/nitrogfx/util.h2
6 files changed, 291 insertions, 0 deletions
diff --git a/tools/narccomp/.gitignore b/tools/narccomp/.gitignore
new file mode 100644
index 00000000..e96a03a5
--- /dev/null
+++ b/tools/narccomp/.gitignore
@@ -0,0 +1 @@
+narccomp
diff --git a/tools/nitrogfx/gfx.c b/tools/nitrogfx/gfx.c
index f927deed..25c346db 100644
--- a/tools/nitrogfx/gfx.c
+++ b/tools/nitrogfx/gfx.c
@@ -322,6 +322,39 @@ void ReadGbaPalette(char *path, struct Palette *palette)
free(data);
}
+void ReadNtrPalette(char *path, struct Palette *palette)
+{
+ int fileSize;
+ unsigned char *data = ReadWholeFile(path, &fileSize);
+
+ uint32_t magicNumber = (data[3] << 24) | (data[2] << 16) | (data[1] << 8) | data[0];
+ if (magicNumber != 0x4E434C52) //NCLR
+ FATAL_ERROR("Not a valid NCLR palette file. Magic number (%x).\n", magicNumber);
+
+ unsigned char *paletteHeader = data + 0x10;
+
+ magicNumber = (paletteHeader[3] << 24) | (paletteHeader[2] << 16) | (paletteHeader[1] << 8) | paletteHeader[0];
+ if (magicNumber != 0x504C5454) //PLTT
+ FATAL_ERROR("No valid PLTT file after NCLR header. Magic number (%x).\n", magicNumber);
+
+ if ((fileSize - 0x28) % 2 != 0)
+ FATAL_ERROR("The file size (%d) is not a multiple of 2.\n", fileSize);
+
+ palette->numColors = (fileSize - 0x28) / 2; //remove header and divide by 2
+
+ unsigned char *paletteData = paletteHeader + 0x18;
+
+ for (int i = 0; i < palette->numColors; i++)
+ {
+ uint16_t paletteEntry = (paletteData[i * 2 + 1] << 8) | paletteData[i * 2];
+ palette->colors[i].red = UPCONVERT_BIT_DEPTH(GET_GBA_PAL_RED(paletteEntry));
+ palette->colors[i].green = UPCONVERT_BIT_DEPTH(GET_GBA_PAL_GREEN(paletteEntry));
+ palette->colors[i].blue = UPCONVERT_BIT_DEPTH(GET_GBA_PAL_BLUE(paletteEntry));
+ }
+
+ free(data);
+}
+
void WriteGbaPalette(char *path, struct Palette *palette)
{
FILE *fp = fopen(path, "wb");
@@ -342,3 +375,65 @@ void WriteGbaPalette(char *path, struct Palette *palette)
fclose(fp);
}
+
+void WriteNtrPalette(char *path, struct Palette *palette)
+{
+ FILE *fp = fopen(path, "wb");
+
+ if (fp == NULL)
+ FATAL_ERROR("Failed too open \"%s\" for writing.\n", path);
+
+ uint32_t size = palette->numColors * 2;
+ uint32_t extSize = size + 0x18;
+
+ //NCLR header
+ WriteGenericNtrHeader(fp, "RLCN", extSize);
+
+ //PLTT header
+ //magic number
+ fputs("TTLP", fp);
+
+ //section size
+ fputc(extSize & 0xFF, fp);
+ fputc((extSize >> 8) & 0xFF, fp);
+ fputc((extSize >> 16) & 0xFF, fp);
+ fputc((extSize >> 24) & 0xFF, fp);
+
+ //bit depth
+ fputc(0x03, fp); //todo figure out a way to determine bit depth
+ fputc(0x00, fp);
+ fputc(0x00, fp);
+ fputc(0x00, fp);
+
+ //padding
+ fputc(0x00, fp);
+ fputc(0x00, fp);
+ fputc(0x00, fp);
+ fputc(0x00, fp);
+
+ //size
+ fputc(size & 0xFF, fp);
+ fputc((size >> 8) & 0xFF, fp);
+ fputc((size >> 16) & 0xFF, fp);
+ fputc((size >> 24) & 0xFF, fp);
+
+ //colours per palette
+ fputc(0x10, fp);
+ fputc(0x00, fp);
+ fputc(0x00, fp);
+ fputc(0x00, fp);
+
+ //palette data
+ for (int i = 0; i < palette->numColors; i++) {
+ unsigned char red = DOWNCONVERT_BIT_DEPTH(palette->colors[i].red);
+ unsigned char green = DOWNCONVERT_BIT_DEPTH(palette->colors[i].green);
+ unsigned char blue = DOWNCONVERT_BIT_DEPTH(palette->colors[i].blue);
+
+ uint16_t paletteEntry = SET_GBA_PAL(red, green, blue);
+
+ fputc(paletteEntry & 0xFF, fp);
+ fputc(paletteEntry >> 8, fp);
+ }
+
+ fclose(fp);
+}
diff --git a/tools/nitrogfx/gfx.h b/tools/nitrogfx/gfx.h
index 5355ced8..d5241509 100644
--- a/tools/nitrogfx/gfx.h
+++ b/tools/nitrogfx/gfx.h
@@ -31,6 +31,8 @@ void ReadImage(char *path, int tilesWidth, int bitDepth, int metatileWidth, int
void WriteImage(char *path, int numTiles, int bitDepth, int metatileWidth, int metatileHeight, struct Image *image, bool invertColors);
void FreeImage(struct Image *image);
void ReadGbaPalette(char *path, struct Palette *palette);
+void ReadNtrPalette(char *path, struct Palette *palette);
void WriteGbaPalette(char *path, struct Palette *palette);
+void WriteNtrPalette(char *path, struct Palette *palette);
#endif // GFX_H
diff --git a/tools/nitrogfx/main.c b/tools/nitrogfx/main.c
index b9f4272c..07083234 100644
--- a/tools/nitrogfx/main.c
+++ b/tools/nitrogfx/main.c
@@ -44,6 +44,39 @@ void ConvertGbaToPng(char *inputPath, char *outputPath, struct GbaToPngOptions *
FreeImage(&image);
}
+void ConvertNtrToPng(char *inputPath UNUSED, char *outputPath UNUSED, struct GbaToPngOptions *options) //todo finish
+{
+ struct Image image;
+
+ if (options->paletteFilePath != NULL)
+ {
+ ReadNtrPalette(options->paletteFilePath, &image.palette);
+ image.hasPalette = true;
+ }
+ else
+ {
+ image.hasPalette = false;
+ }
+
+ if (image.hasPalette)
+ {
+ printf("Image has palette!\n");
+ printf("Colours: %d\n", image.palette.numColors);
+ for (int i = 0; i < image.palette.numColors; i++)
+ {
+ printf("Red: %d ", image.palette.colors[i].red);
+ printf("Green: %d ", image.palette.colors[i].green);
+ printf("Blue: %d\n", image.palette.colors[i].blue);
+ }
+ }
+ else
+ {
+ printf("No palette detected!\n");
+ }
+
+ FreeImage(&image);
+}
+
void ConvertPngToGba(char *inputPath, char *outputPath, struct PngToGbaOptions *options)
{
struct Image image;
@@ -198,6 +231,85 @@ void HandlePngToGbaCommand(char *inputPath, char *outputPath, int argc, char **a
ConvertPngToGba(inputPath, outputPath, &options);
}
+void HandleNtrToPngCommand(char *inputPath, char *outputPath, int argc, char **argv)
+{
+ //char *inputFileExtension = GetFileExtension(inputPath);
+ struct GbaToPngOptions options;
+ options.paletteFilePath = NULL;
+ options.bitDepth = 4; //todo read from header
+ options.hasTransparency = false;
+ options.width = 1;
+ options.metatileWidth = 1;
+ options.metatileHeight = 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++;
+
+ options.paletteFilePath = argv[i];
+ }
+ else if (strcmp(option, "-object") == 0)
+ {
+ options.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, &options.width))
+ FATAL_ERROR("Failed to parse width.\n");
+
+ if (options.width < 1)
+ 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
+ {
+ FATAL_ERROR("Unrecognized option \"%s\".\n", option);
+ }
+ }
+
+ if (options.metatileWidth > options.width)
+ options.width = options.metatileWidth;
+
+ ConvertNtrToPng(inputPath, outputPath, &options);
+}
+
void HandlePngToGbaPaletteCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED)
{
struct Palette palette;
@@ -214,6 +326,14 @@ void HandleGbaToJascPaletteCommand(char *inputPath, char *outputPath, int argc U
WriteJascPalette(outputPath, &palette);
}
+void HandleNtrToJascPaletteCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED)
+{
+ struct Palette palette;
+
+ ReadNtrPalette(inputPath, &palette);
+ WriteJascPalette(outputPath, &palette);
+}
+
void HandleJascToGbaPaletteCommand(char *inputPath, char *outputPath, int argc, char **argv)
{
int numColors = 0;
@@ -251,6 +371,43 @@ void HandleJascToGbaPaletteCommand(char *inputPath, char *outputPath, int argc,
WriteGbaPalette(outputPath, &palette);
}
+void HandleJascToNtrPaletteCommand(char *inputPath, char *outputPath, int argc, char **argv)
+{
+ int numColors = 0;
+
+ 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");
+
+ i++;
+
+ 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);
+ }
+ }
+
+ struct Palette palette;
+
+ ReadJascPalette(inputPath, &palette);
+
+ if (numColors != 0)
+ palette.numColors = numColors;
+
+ WriteNtrPalette(outputPath, &palette);
+}
+
void HandleLatinFontToPngCommand(char *inputPath, char *outputPath, int argc UNUSED, char **argv UNUSED)
{
struct Image image;
@@ -491,12 +648,16 @@ int main(int argc, char **argv)
{ "1bpp", "png", HandleGbaToPngCommand },
{ "4bpp", "png", HandleGbaToPngCommand },
{ "8bpp", "png", HandleGbaToPngCommand },
+ //{ "ncgr", "png", HandleNtrToPngCommand },
{ "png", "1bpp", HandlePngToGbaCommand },
{ "png", "4bpp", HandlePngToGbaCommand },
{ "png", "8bpp", HandlePngToGbaCommand },
+ //{ "png", "ncgr", HandlePngToNtrCommand },
{ "png", "gbapal", HandlePngToGbaPaletteCommand },
{ "gbapal", "pal", HandleGbaToJascPaletteCommand },
+ { "nclr", "pal", HandleNtrToJascPaletteCommand },
{ "pal", "gbapal", HandleJascToGbaPaletteCommand },
+ { "pal", "nclr", HandleJascToNtrPaletteCommand },
{ "latfont", "png", HandleLatinFontToPngCommand },
{ "png", "latfont", HandlePngToLatinFontCommand },
{ "hwjpnfont", "png", HandleHalfwidthJapaneseFontToPngCommand },
diff --git a/tools/nitrogfx/util.c b/tools/nitrogfx/util.c
index 87abeb31..8fec7d72 100644
--- a/tools/nitrogfx/util.c
+++ b/tools/nitrogfx/util.c
@@ -4,6 +4,7 @@
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
+#include <stdint.h>
#include <errno.h>
#include <limits.h>
#include "global.h"
@@ -122,3 +123,32 @@ void WriteWholeFile(char *path, void *buffer, int bufferSize)
fclose(fp);
}
+
+void WriteGenericNtrHeader(FILE* fp, const char* magicNumber, uint32_t size)
+{
+ //magic number
+ fputs(magicNumber, fp);
+
+ //byte order
+ fputc(0xFF, fp);
+ fputc(0xFE, fp);
+
+ //version
+ fputc(0x00, fp);
+ fputc(0x01, fp);
+
+ //size
+ size += 0x10; //add header size
+ fputc(size & 0xFF, fp);
+ fputc((size >> 8) & 0xFF, fp);
+ fputc((size >> 16) & 0xFF, fp);
+ fputc((size >> 24) & 0xFF, fp);
+
+ //header size
+ fputc(0x10, fp);
+ fputc(0x00, fp);
+
+ //sections
+ fputc(0x01, fp);
+ fputc(0x00, fp);
+} \ No newline at end of file
diff --git a/tools/nitrogfx/util.h b/tools/nitrogfx/util.h
index 6d7a9c21..a220ba81 100644
--- a/tools/nitrogfx/util.h
+++ b/tools/nitrogfx/util.h
@@ -4,11 +4,13 @@
#define UTIL_H
#include <stdbool.h>
+#include <stdint.h>
bool ParseNumber(char *s, char **end, int radix, int *intValue);
char *GetFileExtension(char *path);
unsigned char *ReadWholeFile(char *path, int *size);
unsigned char *ReadWholeFileZeroPadded(char *path, int *size, int padAmount);
void WriteWholeFile(char *path, void *buffer, int bufferSize);
+void WriteGenericNtrHeader(FILE* fp, const char* magicNumber, uint32_t size);
#endif // UTIL_H
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-30 04:56:23 +0000