ref: e753b62d1ace56de6f83e058f834c867dbf46476
parent: 6ed220b4c10c0c3ceb994f7bd2273e6bdfd6414f
author: ISSOtm <eldredhabert0@gmail.com>
date: Sat Mar 19 08:08:51 EDT 2022
Add program by @aaaaaa123456789 to generate RGBGFX-able images
--- a/Makefile
+++ b/Makefile
@@ -126,6 +126,9 @@
rgbgfx: ${rgbgfx_obj} $Q${CXX} ${REALLDFLAGS} ${PNGLDFLAGS} -o $@ ${rgbgfx_obj} ${REALCXXFLAGS} -x c++ src/version.c ${PNGLDLIBS}+test/randtilegen: test/randtilegen.c
+ $Q${CC} ${REALLDFLAGS} ${PNGLDFLAGS} -o $@ $^ ${REALCFLAGS} -Wno-vla ${PNGCFLAGS} ${PNGLDLIBS}+
# Rules to process files
# We want the Bison invocation to pass through our rules, not default ones
--- a/test/.gitignore
+++ b/test/.gitignore
@@ -1,3 +1,1 @@
-/pokecrystal/
-/pokered/
-/ucity/
+/randtilegen
--- /dev/null
+++ b/test/randtilegen.c
@@ -1,0 +1,240 @@
+/*
+ * This file is part of RGBDS.
+ *
+ * Copyright (c) 2022, Eldred Habert and RGBDS contributors.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Originally:
+ * // This program is hereby released to the public domain.
+ * // ~aaaaaa123456789, released 2022-03-15
+ * https://gist.github.com/aaaaaa123456789/3feccf085ab4f82d144d9a47fb1b4bdf
+ *
+ * This was modified to use libpng instead of libplum, as well as comments and style changes.
+ */
+
+#include <assert.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <png.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+uint32_t randBits = 0; // Storage for bits read from the input stream but not yet used
+uint8_t randCount = 0; // How many bits are currently stored in the above
+size_t nbRandBytes = 0;
+
+static uint32_t getRandomBits(uint8_t count) {+ // Trying to read one more byte with `randCount` at least this high will drop some bits
+ // If the count is no higher than that limit, then the loop will exit without reading more bytes
+ assert(count <= sizeof(randBits) * 8 + 1);
+
+ // Read bytes until we have enough bits to serve the request
+ while (count > randCount) {+ int data = getchar();
+ if (data == EOF) {+ fprintf(stderr, "Exit after reading %zu bytes\n", nbRandBytes);
+ exit(0);
+ }
+ randBits |= (uint32_t)data << randCount;
+ randCount += 8;
+ ++nbRandBytes;
+ }
+
+ uint32_t result = randBits & (((uint32_t)1 << count) - 1);
+ randBits >>= count;
+ randCount -= count;
+ return result;
+}
+
+/**
+ * Expand a 5-bit color component to 8 bits with minimal bias
+ */
+static uint8_t _5to8(uint8_t five) {+ return five << 3 | five >> 2;
+}
+
+static void generate_random_image(png_structp png, png_infop pngInfo) {+#define NB_TILES 100
+ struct {+ unsigned char palette;
+ unsigned char nbColors;
+ } attributes[NB_TILES];
+ uint8_t tileData[NB_TILES][8][8];
+ // These two are in tiles, not pixels
+ // Both width and height are 4-bit values, so nbTiles is 8-bit (OK!)
+ uint8_t const width = getRandomBits(3) + 3, height = getRandomBits(3) + 3,
+ nbTiles = width * height;
+
+ for (uint8_t p = 0; p < nbTiles; p++) {+ uint8_t pal;
+ do {+ pal = getRandomBits(5);
+ } while (pal == 0 || (pal > 29));
+ attributes[p].palette = 2 * pal + getRandomBits(1);
+ // Population count (nb of bits set), the simple way
+ static uint8_t const popcount[] = {1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,+ 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4};
+ attributes[p].nbColors = popcount[pal - 1];
+ if (attributes[p].nbColors < 2) {+ memset(tileData[p], 0, sizeof(tileData[p]));
+ continue;
+ }
+ uint8_t index, total;
+ for (index = 0, total = 0; index < p; index++) {+ if (attributes[index].nbColors == attributes[p].nbColors) {+ total++;
+ }
+ }
+ // index == p at exit
+ if (total) {+ index = getRandomBits(8);
+ if (index < total) {+ total = index + 1;
+ for (index = 0; total; index++) {+ if (attributes[index].nbColors == attributes[p].nbColors) {+ total--;
+ }
+ }
+ } else {+ index = p;
+ }
+ }
+ if (index != p) {+ unsigned rotation = getRandomBits(2);
+ for (uint8_t y = 0; y < 8; y++) {+ for (uint8_t x = 0; x < 8; x++) {+ tileData[p][y][x] =
+ tileData[index][y ^ ((rotation & 2) ? 7 : 0)][x ^ ((rotation & 1) ? 7 : 0)];
+ }
+ }
+ } else {+ switch (attributes[p].nbColors) {+ case 2:
+ for (uint8_t y = 0; y < 8; y++)
+ for (uint8_t x = 0; x < 8; x++)
+ tileData[p][y][x] = getRandomBits(1);
+ break;
+ case 4:
+ for (uint8_t y = 0; y < 8; y++)
+ for (uint8_t x = 0; x < 8; x++)
+ tileData[p][y][x] = getRandomBits(2);
+ break;
+ default:
+ for (uint8_t y = 0; y < 8; y++)
+ for (uint8_t x = 0; x < 8; x++) {+ do {+ index = getRandomBits(2);
+ } while (index == 3);
+ tileData[p][y][x] = index;
+ }
+ }
+ }
+ }
+
+ uint16_t colors[10];
+ for (uint8_t p = 0; p < 10; p++) {+ colors[p] = getRandomBits(15);
+ }
+ // Randomly make color #0 of all palettes transparent
+ if (!getRandomBits(2)) {+ colors[0] |= 0x8000;
+ colors[5] |= 0x8000;
+ }
+
+ uint16_t palettes[60][4];
+ for (uint8_t p = 0; p < 60; p++) {+ const uint16_t *subpal = colors;
+ if (p & 1) {+ subpal += 5;
+ }
+ uint8_t total = 0;
+ for (uint8_t index = 0; index < 5; index++) {+ if (p & (2 << index)) {+ palettes[p][total++] = subpal[index];
+ }
+ }
+ }
+
+ png_set_IHDR(png, pngInfo, width * 8, height * 8, 8, PNG_COLOR_TYPE_RGB_ALPHA,
+ getRandomBits(1) ? PNG_INTERLACE_NONE : PNG_INTERLACE_ADAM7,
+ PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+
+ // While it would be nice to write the image little by little, I really don't want to handle
+ // interlacing myself. (We're doing interlacing to test that RGBGFX correctly handles it.)
+ uint8_t const SIZEOF_PIXEL = 4; // Each pixel is 4 bytes (RGBA @ 8 bits/component)
+ uint8_t data[height * 8 * width * 8 * SIZEOF_PIXEL];
+ uint8_t *rowPtrs[height * 8];
+ for (uint8_t y = 0; y < height * 8; ++y) {+ rowPtrs[y] = &data[y * width * 8 * SIZEOF_PIXEL];
+ }
+
+ for (uint8_t p = 0; p < nbTiles; p++) {+ uint8_t tx = 8 * (p % width), ty = 8 * (p / width);
+ for (uint8_t y = 0; y < 8; y++) {+ uint8_t * const row = rowPtrs[ty + y];
+ for (uint8_t x = 0; x < 8; x++) {+ uint8_t * const pixel = &row[(tx + x) * SIZEOF_PIXEL];
+ uint16_t color = palettes[attributes[p].palette][tileData[p][y][x]];
+ pixel[0] = _5to8(color & 0x1F);
+ pixel[1] = _5to8(color >> 5 & 0x1F);
+ pixel[2] = _5to8(color >> 10 & 0x1F);
+ pixel[3] = color & 0x8000 ? 0x00 : 0xFF;
+ }
+ }
+ }
+ png_set_rows(png, pngInfo, rowPtrs);
+ png_write_png(png, pngInfo, PNG_TRANSFORM_IDENTITY, NULL);
+}
+
+int main(int argc, char **argv) {+ if (argc < 2) {+ fputs("usage: randtilegen <basename> [<basename> [...]]\n", stderr);+ return 2;
+ }
+
+ size_t maxBasenameLen = 0;
+ for (int index = 1; index < argc; index++) {+ size_t length = strlen(argv[index]);
+ if (length > maxBasenameLen) {+ maxBasenameLen = length;
+ }
+ }
+
+ char filename[maxBasenameLen + 25];
+ for (uint16_t i = 0;; i++) { // 65k images ought to be enough+ for (int index = 1; index < argc; index++) {+ sprintf(filename, "%s%" PRIu16 ".png", argv[index], i);
+ FILE *img = fopen(filename, "wb");
+ if (!img) {+ perror("PNG fopen");+ return 1;
+ }
+ png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+ if (!png) {+ perror("png_create_write_struct");+ return 1;
+ }
+ png_infop pngInfo = png_create_info_struct(png);
+ if (!pngInfo) {+ perror("png_create_info_struct");+ return 1;
+ }
+ if (setjmp(png_jmpbuf(png))) {+ fprintf(stderr, "FATAL: an error occurred while writing image \"%s\"\n", filename);
+ return 1;
+ }
+
+ png_init_io(png, img);
+ generate_random_image(png, pngInfo);
+ png_destroy_write_struct(&png, &pngInfo);
+ fclose(img);
+ }
+
+ if (i == UINT16_MAX) {+ break;
+ }
+ }
+}