@city41/gba-convertpng 0.0.26 → 0.0.28

package/dist/background.js

@@ -110,12 +110,19 @@ async function processBackground(bg) {
     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]));
+    if (bg.forcePalette) {
+        const forcedPaletteCanvas = await (0, canvas_1.createCanvasFromPath)(bg.forcePalette);
+        canvas = await (0, canvas_1.forceCanvasToPalette)(canvas, forcedPaletteCanvas);
+        palettes.push((0, palette_1.getForcedPalette)(forcedPaletteCanvas));
+    }
+    else {
+        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

package/dist/main.js

@@ -41,6 +41,7 @@ const background_1 = require("./background");
 const c_1 = require("./c");
 const asm_1 = require("./asm");
 const bitmap_1 = require("./bitmap");
+const palette_1 = require("./palette");
 /**
  * Loads the json spec from the file path and converts all file paths
  * inside to absolute paths so the rest of the tool doesn't have to think about it
@@ -81,6 +82,9 @@ function hydrateJsonSpec(jsonSpecPath) {
             return {
                 ...bg,
                 file: path.resolve(rootDir, bg.file),
+                forcePalette: bg.forcePalette
+                    ? path.resolve(rootDir, bg.forcePalette)
+                    : undefined,
             };
         }),
         bitmaps: (initialSpec.bitmaps ?? []).map((bmp) => {
@@ -89,6 +93,12 @@ function hydrateJsonSpec(jsonSpecPath) {
                 file: path.resolve(rootDir, bmp.file),
             };
         }),
+        palettes: (initialSpec.palettes ?? []).map(p => {
+            return {
+                ...p,
+                file: path.resolve(rootDir, p.file)
+            };
+        })
     };
 }
 function getBitmapDefines(result) {
@@ -130,6 +140,9 @@ function toSrcFiles(result, format) {
     else if ((0, bitmap_1.isProcessBitmapResult)(result)) {
         file = result.bitmap.file;
     }
+    else if ((0, palette_1.isProcessPaletteResult)(result)) {
+        file = result.palette.file;
+    }
     else {
         throw new Error(`toSrcFiles: unexpected object: ${JSON.stringify(result)}`);
     }
@@ -216,6 +229,48 @@ function toSrcFiles(result, format) {
                 throw new Error('gba-convertpng does not support "bin"');
         }
     }
+    else if ((0, palette_1.isProcessPaletteResult)(result)) {
+        switch (format) {
+            case "C":
+                return {
+                    tile: [],
+                    palette: [
+                        {
+                            src: (0, c_1.toCc)(result.data, "w", 8, fileRoot + "_palette", fileRoot + ".palette"),
+                            extension: "c",
+                        },
+                        {
+                            src: (0, c_1.toCh)(result.data, "w", fileRoot + "_palette"),
+                            extension: "h",
+                        },
+                    ],
+                    map: [],
+                    bitmap: [],
+                };
+            case "C.inc":
+                return {
+                    tile: [],
+                    palette: [
+                        { src: (0, c_1.toCinc)(result.data, "w", 8), extension: "c.inc" },
+                    ],
+                    map: [],
+                    bitmap: [],
+                };
+            case "asz80":
+            case "z80":
+            case "pyz80":
+                return {
+                    tile: [],
+                    palette: [
+                        { src: (0, asm_1.toAsm)(result.data, "w", 8, format), extension: "asm" },
+                    ],
+                    map: [],
+                    bitmap: [],
+                };
+            case "bin":
+                throw new Error('gba-convertpng does not support "bin"');
+        }
+    }
     else {
         switch (format) {
             case "C":
@@ -348,6 +403,11 @@ async function main(jsonSpec) {
         const srcFiles = toSrcFiles(processResult, jsonSpec.format);
         await writeFiles(srcFiles, bmp, jsonSpec.outputDir);
     }
+    for (const palette of jsonSpec.palettes) {
+        const processResult = await (0, palette_1.processPalette)(palette);
+        const srcFiles = toSrcFiles(processResult, jsonSpec.format);
+        await writeFiles(srcFiles, palette, jsonSpec.outputDir);
+    }
 }
 if (require.main === module) {
     const [_tsNode, _convertpng, jsonSpecPath] = process.argv;

package/dist/palette.d.ts

@@ -1,5 +1,7 @@
 import { Canvas } from "canvas";
+import { PaletteSpec, ProcessPaletteResult } from "./types";
 declare const MAGENTA_15: number;
+declare function isProcessPaletteResult(obj: unknown): obj is ProcessPaletteResult;
 declare function getForcedPalette(c: Canvas): number[];
 declare function extractPalette(c: Canvas, pad?: boolean): number[];
 declare function extractPalette15(data15: number[], pad?: boolean): number[];
@@ -7,4 +9,5 @@ declare function reduceCanvases(canvases: Canvas[]): {
     palette: number[];
     canvas: Canvas;
 };
-export { extractPalette, extractPalette15, getForcedPalette, reduceCanvases, MAGENTA_15 };
+declare function processPalette(palette: PaletteSpec): Promise<ProcessPaletteResult>;
+export { processPalette, isProcessPaletteResult, extractPalette, extractPalette15, getForcedPalette, reduceCanvases, MAGENTA_15 };

package/dist/palette.js

@@ -1,15 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MAGENTA_15 = void 0;
+exports.processPalette = processPalette;
+exports.isProcessPaletteResult = isProcessPaletteResult;
 exports.extractPalette = extractPalette;
 exports.extractPalette15 = extractPalette15;
 exports.getForcedPalette = getForcedPalette;
 exports.reduceCanvases = reduceCanvases;
 const canvas_1 = require("canvas");
 const colors_1 = require("./colors");
+const canvas_2 = require("./canvas");
 const MAGENTA_24 = [255, 0, 255, 255];
 const MAGENTA_15 = (0, colors_1.rgbToGBA15)(255, 0, 255);
 exports.MAGENTA_15 = MAGENTA_15;
+function isProcessPaletteResult(obj) {
+    return (obj !== null &&
+        typeof obj === "object" &&
+        "palette" in obj &&
+        typeof obj.palette === "object" &&
+        obj.palette !== null &&
+        "file" in obj.palette);
+}
 function is24BitMagenta(color) {
     return (color.length === MAGENTA_24.length &&
         color.every((channel, i) => channel === MAGENTA_24[i]));
@@ -103,4 +114,18 @@ function reduceCanvases(canvases) {
         canvas: paletteCanvas,
     };
 }
+async function processPalette(palette) {
+    const paletteCanvas = await (0, canvas_2.createCanvasFromPath)(palette.file);
+    let paletteData;
+    if (palette.forcePalette) {
+        paletteData = getForcedPalette(paletteCanvas);
+    }
+    else {
+        paletteData = extractPalette(paletteCanvas, !palette.trimPalette);
+    }
+    return {
+        palette,
+        data: paletteData
+    };
+}
 //# sourceMappingURL=palette.js.map

package/dist/types.d.ts

@@ -8,6 +8,11 @@ export type BasicSpriteSpec = {
     forcePalette?: string;
     transparentColor?: number;
 };
+export type PaletteSpec = {
+    file: string;
+    trimPalette?: boolean;
+    forcePalette?: boolean;
+};
 export type SharedPaletteSpriteSpec = {
     name: string;
     trimPalette?: boolean;
@@ -21,6 +26,7 @@ export type BackgroundSpec = {
     trimPalette?: boolean;
     transparentColor?: number;
     reduceColors?: boolean;
+    forcePalette?: string;
 };
 export type BitmapSpec = {
     file: string;
@@ -31,6 +37,7 @@ export type ImportedJsonSpec = {
     sprites?: SpriteSpec[];
     backgrounds?: BackgroundSpec[];
     bitmaps?: BitmapSpec[];
+    palettes?: PaletteSpec[];
 };
 export type JsonSpec = Required<ImportedJsonSpec>;
 export type ProcessBasicSpriteResult = {
@@ -58,3 +65,7 @@ export type ProcessBitmapResult = {
     height: number;
     pixels: number[];
 };
+export type ProcessPaletteResult = {
+    palette: PaletteSpec;
+    data: number[];
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@city41/gba-convertpng",
-  "version": "0.0.26",
+  "version": "0.0.28",
   "description": "Converts png images to GBA tile format",
   "main": "index.js",
   "repository": "github.com/city41/gba-convertpng",