@city41/gba-convertpng 0.0.25 → 0.0.26

package/dist/background.d.ts

@@ -2,4 +2,3 @@ import { BackgroundSpec, ProcessBackgroundResult } from "./types";
 declare function isProcessBackgroundResult(obj: unknown): obj is ProcessBackgroundResult;
 declare function processBackground(bg: BackgroundSpec): Promise<ProcessBackgroundResult>;
 export { processBackground, isProcessBackgroundResult };
-export type { ProcessBackgroundResult };

package/dist/background.js

@@ -1,14 +1,11 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processBackground = processBackground;
 exports.isProcessBackgroundResult = isProcessBackgroundResult;
 const canvas_1 = require("./canvas");
+const colors_1 = require("./colors");
+const lodash_1 = require("lodash");
 const palette_1 = require("./palette");
-const tile_1 = require("./tile");
-const isEqual_1 = __importDefault(require("lodash/isEqual"));
 function isProcessBackgroundResult(obj) {
     return (obj !== null &&
         typeof obj === "object" &&
@@ -17,40 +14,136 @@ function isProcessBackgroundResult(obj) {
         obj.background !== null &&
         "file" in obj.background);
 }
-function extractMap(allTilesThatFormImage, dedupedTiles) {
-    const map = [];
-    allTilesThatFormImage.forEach((tile, i) => {
-        const index = dedupedTiles.findIndex((dt) => {
-            return (0, isEqual_1.default)(dt, tile);
-        });
-        if (index < 0) {
-            throw new Error("extractMap: failed to find a matching tile in the deduped tile set");
+function convertTileTo15Bit(rawTile) {
+    const data15 = [];
+    for (let p = 0; p < rawTile.length; p += 4) {
+        if (rawTile[p + 3] !== 255) {
+            data15.push(palette_1.MAGENTA_15);
+        }
+        else {
+            data15.push((0, colors_1.rgbToGBA15)(rawTile[p], rawTile[p + 1], rawTile[p + 2]));
         }
-        map.push(index);
+    }
+    return data15;
+}
+function getTileIndex(tilePalette, tile) {
+    const index = tilePalette.findIndex(t => {
+        return t.join('-') === tile.join('-');
     });
+    if (index > -1) {
+        return index;
+    }
+    tilePalette.push([...tile]);
+    return tilePalette.length - 1;
+}
+// looks through all the palettes and combines multiple palettes into one 
+// based on how much room they have.
+// example, palette-a has 4 colors, palette-b has 6, result is a palette with 10 colors
+// possibly the two palettes share colors, only one copy of each color will be preserved
+//
+// by the way this algoritm works, it also uniqs the palettes
+function combinePalettes(palettes) {
+    if (palettes.length <= 1) {
+        return palettes;
+    }
+    const sortedPalettes = (0, lodash_1.sortBy)(palettes, p => p.length);
+    let firstPalette = sortedPalettes[0];
+    const remainingPalettes = [];
+    for (let p = 1; p < sortedPalettes.length; ++p) {
+        const otherPalette = sortedPalettes[p];
+        const otherPaletteUniqueColors = otherPalette.filter(c => !firstPalette.includes(c));
+        if (firstPalette.length + otherPaletteUniqueColors.length < 16) {
+            firstPalette = firstPalette.concat(otherPaletteUniqueColors);
+        }
+        else {
+            remainingPalettes.push(otherPalette);
+        }
+    }
+    const combinedOtherPalettes = combinePalettes(remainingPalettes);
+    return [firstPalette].concat(combinedOtherPalettes);
+}
+function buildMap(tiles, bgWidthPx, bgHeightPx) {
+    const map = [];
+    const bgWidthT = bgWidthPx / 8;
+    const bgHeightT = bgHeightPx / 8;
+    for (let y = 0; y < bgHeightT; ++y) {
+        for (let x = 0; x < bgWidthT; ++x) {
+            const tile = tiles[y * bgWidthT + x];
+            map.push(tile.paletteIndex << 12 | tile.tileIndex);
+        }
+    }
     return map;
 }
+function getGBATile(data15, palette) {
+    const gbaTile = [];
+    for (let p = 0; p < data15.length; p += 2) {
+        const highNibble = palette.indexOf(data15[p + 1]);
+        const lowNibble = palette.indexOf(data15[p]);
+        const byte = (highNibble & 0xf) << 4 | (lowNibble & 0xf);
+        gbaTile.push(byte);
+    }
+    return gbaTile;
+}
+function findMatchingPalette(data15, palettes) {
+    const foundPalette = palettes.find(palette => {
+        return data15.every(c => palette.includes(c));
+    });
+    if (!foundPalette) {
+        throw new Error('findMatchingPalette: failed to find a palette');
+    }
+    return foundPalette;
+}
+function padPalette(palette) {
+    while (palette.length < 16) {
+        palette.push(0);
+    }
+    return palette;
+}
 async function processBackground(bg) {
-    // const canvas = await reduceColors(await createCanvasFromPath(bg.file), 16);
     let canvas = await (0, canvas_1.createCanvasFromPath)(bg.file);
     if (typeof bg.reduceColors === "undefined" || bg.reduceColors === true) {
         canvas = await (0, canvas_1.reduceColors)(canvas, 16);
     }
     canvas = (0, canvas_1.roundUpToTileSize)(canvas);
-    const palette = (0, palette_1.extractPalette)(canvas, !bg.trimPalette);
-    console.log("palette size", palette.length);
-    const allTilesThatFormImage = (0, tile_1.extractTiles)(canvas, palette, 1);
-    const dedupedTiles = (0, tile_1.dedupeTiles)(allTilesThatFormImage);
-    const map = extractMap(allTilesThatFormImage, dedupedTiles);
-    if (typeof bg.transparentColor === "number") {
-        palette[0] = bg.transparentColor;
+    const ctx = canvas.getContext('2d');
+    const tiles = [];
+    const tilePalette = [];
+    let palettes = [];
+    // first, determine the palettes
+    for (let y = 0; y < canvas.height; y += 8) {
+        for (let x = 0; x < canvas.width; x += 8) {
+            const rawTile = Array.from(ctx.getImageData(x, y, 8, 8).data);
+            const data15 = convertTileTo15Bit(rawTile);
+            const palette = (0, palette_1.extractPalette15)(data15, false);
+            palettes = combinePalettes(palettes.concat([palette]));
+        }
+    }
+    // now with palettes in hand, do the rest
+    for (let y = 0; y < canvas.height; y += 8) {
+        for (let x = 0; x < canvas.width; x += 8) {
+            const rawTile = Array.from(ctx.getImageData(x, y, 8, 8).data);
+            const data15 = convertTileTo15Bit(rawTile);
+            const palette = findMatchingPalette(data15, palettes);
+            const gbaTileData = getGBATile(data15, palette);
+            const tileIndex = getTileIndex(tilePalette, gbaTileData);
+            const paletteIndex = palettes.indexOf(palette);
+            tiles.push({
+                tileIndex,
+                paletteIndex,
+            });
+        }
     }
+    const tileData = tilePalette.flat(1);
+    const paletteData = palettes.map(padPalette).flat(1);
+    const paletteCount = palettes.length;
+    const map = buildMap(tiles, canvas.width, canvas.height);
     return {
-        canvas,
         background: bg,
-        tiles: dedupedTiles.flat(1),
-        palette,
+        canvas,
         map,
+        palette: paletteData,
+        paletteCount,
+        tiles: tileData
     };
 }
 //# sourceMappingURL=background.js.map

package/dist/main.js

@@ -96,6 +96,13 @@ function getBitmapDefines(result) {
     return `#define ${name.toUpperCase()}_WIDTH ${result.width}
 #define ${name.toUpperCase()}_HEIGHT ${result.height}`;
 }
+function getPaletteDefines(result, file) {
+    if ((0, sprite_1.isProcessBasicSpriteResult)(result)) {
+        return '';
+    }
+    const name = path.basename(file, ".png");
+    return `#define ${name.toUpperCase()}_NUM_PALETTES ${result.paletteCount}`;
+}
 function getTileDefines(result, file) {
     const name = path.basename(file, ".png");
     let tileWidth = result.canvas.width / 8;
@@ -230,7 +237,7 @@ function toSrcFiles(result, format) {
                                 extension: "c",
                             },
                             {
-                                src: (0, c_1.toCh)(result.palette, "w", fileRoot + "_palette"),
+                                src: (0, c_1.toCh)(result.palette, "w", fileRoot + "_palette", getPaletteDefines(result, file)),
                                 extension: "h",
                             },
                         ]

package/dist/palette.d.ts

@@ -1,8 +1,10 @@
 import { Canvas } from "canvas";
+declare const MAGENTA_15: number;
 declare function getForcedPalette(c: Canvas): number[];
 declare function extractPalette(c: Canvas, pad?: boolean): number[];
+declare function extractPalette15(data15: number[], pad?: boolean): number[];
 declare function reduceCanvases(canvases: Canvas[]): {
     palette: number[];
     canvas: Canvas;
 };
-export { extractPalette, getForcedPalette, reduceCanvases };
+export { extractPalette, extractPalette15, getForcedPalette, reduceCanvases, MAGENTA_15 };

package/dist/palette.js

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAGENTA_15 = void 0;
 exports.extractPalette = extractPalette;
+exports.extractPalette15 = extractPalette15;
 exports.getForcedPalette = getForcedPalette;
 exports.reduceCanvases = reduceCanvases;
 const canvas_1 = require("canvas");
 const colors_1 = require("./colors");
 const MAGENTA_24 = [255, 0, 255, 255];
-const MAGENTA = (0, colors_1.rgbToGBA15)(255, 0, 255);
+const MAGENTA_15 = (0, colors_1.rgbToGBA15)(255, 0, 255);
+exports.MAGENTA_15 = MAGENTA_15;
 function is24BitMagenta(color) {
     return (color.length === MAGENTA_24.length &&
         color.every((channel, i) => channel === MAGENTA_24[i]));
@@ -21,9 +24,9 @@ function getForcedPalette(c) {
         const gbaColor = (0, colors_1.rgbToGBA15)(r, g, b);
         rawPalette.push(gbaColor);
     }
-    const paletteWithoutMangenta = rawPalette.filter((c) => c !== MAGENTA);
+    const paletteWithoutMangenta = rawPalette.filter((c) => c !== MAGENTA_15);
     // then append magenta as the first color, to become transparent
-    const palette = [MAGENTA].concat(paletteWithoutMangenta);
+    const palette = [MAGENTA_15].concat(paletteWithoutMangenta);
     return palette;
 }
 function extractPalette(c, pad = true) {
@@ -42,9 +45,21 @@ function extractPalette(c, pad = true) {
     }
     const rawPalette = Array.from(gbaColors);
     // make sure there is no magenta in the palette
-    const paletteWithoutMangenta = rawPalette.filter((c) => c !== MAGENTA);
+    const paletteWithoutMangenta = rawPalette.filter((c) => c !== MAGENTA_15);
     // then append magenta as the first color, to become transparent
-    const palette = [MAGENTA].concat(paletteWithoutMangenta);
+    const palette = [MAGENTA_15].concat(paletteWithoutMangenta);
+    while (pad && palette.length < 16) {
+        palette.push(0);
+    }
+    return palette;
+}
+function extractPalette15(data15, pad = true) {
+    const gbaColors = new Set(data15);
+    const rawPalette = Array.from(gbaColors);
+    // make sure there is no magenta in the palette
+    const paletteWithoutMangenta = rawPalette.filter((c) => c !== MAGENTA_15);
+    // then append magenta as the first color, to become transparent
+    const palette = [MAGENTA_15].concat(paletteWithoutMangenta);
     while (pad && palette.length < 16) {
         palette.push(0);
     }

package/dist/tile.js

@@ -6,7 +6,7 @@ const colors_1 = require("./colors");
 function extractTile(imageData, palette) {
     const tileData = [];
     for (let p = 0; p < imageData.data.length; p += 8) {
-        // first pixel in tile, high nibble
+        // second pixel in tile, high nibble
         // if this pixel has any transparency, then use palette index 0
         // which will make it fully transparent on the gba
         let hindex = 0;
@@ -18,7 +18,7 @@ function extractTile(imageData, palette) {
             const hgbaColor = (0, colors_1.rgbToGBA15)(hr, hg, hb);
             hindex = palette.indexOf(hgbaColor);
         }
-        // second pixel in tile, low nibble
+        // first pixel in tile, low nibble
         // if this pixel has any transparency, then use palette index 0
         // which will make it fully transparent on the gba
         let lindex = 0;

package/dist/types.d.ts

@@ -49,6 +49,7 @@ export type ProcessBackgroundResult = {
     background: BackgroundSpec;
     tiles: number[];
     palette: number[];
+    paletteCount: number;
     map: number[];
 };
 export type ProcessBitmapResult = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@city41/gba-convertpng",
-  "version": "0.0.25",
+  "version": "0.0.26",
   "description": "Converts png images to GBA tile format",
   "main": "index.js",
   "repository": "github.com/city41/gba-convertpng",
@@ -25,7 +25,7 @@
     "@types/nearest-color": "^0.4.1",
     "canvas": "^3.2.0",
     "imagemagick": "^0.1.3",
-    "lodash": "^4.17.21",
+    "lodash": "^4.17.23",
     "mkdirp": "^3.0.1",
     "nearest-color": "^0.4.4"
   },