brilliantsole 0.0.34 → 0.0.36

package/build/brilliantsole.cjs

@@ -5609,6 +5609,9 @@ function removeSubstrings(string, substrings) {
 
 const _console$r = createConsole("DisplaySpriteSheetUtils", { log: false });
 const spriteHeaderLength = 3 * 2;
+function calculateSpriteSheetHeaderLength(numberOfSprites) {
+    return 2 + numberOfSprites * 2 + numberOfSprites * spriteHeaderLength;
+}
 function getCurvesPoints(curves) {
     const curvePoints = [];
     curves.forEach((curve, index) => {
@@ -6388,6 +6391,15 @@ function resizeImage(image, width, height, canvas) {
     ctx.drawImage(image, 0, 0, width, height);
     return canvas;
 }
+function cropCanvas(canvas, x, y, width, height, targetCanvas) {
+    targetCanvas = targetCanvas || document.createElement("canvas");
+    const ctx = targetCanvas.getContext("2d", { willReadFrequently: true });
+    targetCanvas.width = width;
+    targetCanvas.height = height;
+    ctx.imageSmoothingEnabled = false;
+    ctx.drawImage(canvas, x, y, width, height, 0, 0, width, height);
+    return targetCanvas;
+}
 function removeAlphaFromCanvas(canvas) {
     const ctx = canvas.getContext("2d", { willReadFrequently: true });
     const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
@@ -6426,6 +6438,77 @@ async function imageToBitmap(image, width, height, colors, bitmapColorIndices, n
     };
     return { blob, bitmap };
 }
+const drawSpriteBitmapCommandHeaderLength = 1 + 2 + 2 + 2 + 2 + 1 + 2;
+async function canvasToBitmaps(canvas, numberOfColors, mtu) {
+    const { blob, colors, colorIndices } = await quantizeCanvas(canvas, numberOfColors);
+    const bitmapRows = [];
+    const { width, height } = canvas;
+    const numberOfPixels = width * height;
+    const pixelDepth = DisplayPixelDepths.find((pixelDepth) => pixelDepthToNumberOfColors(pixelDepth) >= numberOfColors);
+    _console$q.assertWithError(pixelDepth, `no pixelDepth found that covers ${numberOfColors} colors`);
+    const pixelsPerByte = pixelDepthToPixelsPerByte(pixelDepth);
+    const numberOfBytes = Math.ceil(numberOfPixels / pixelsPerByte);
+    _console$q.log({
+        width,
+        height,
+        numberOfPixels,
+        pixelDepth,
+        pixelsPerByte,
+        numberOfBytes,
+        mtu,
+    });
+    const maxPixelDataLength = mtu - (drawSpriteBitmapCommandHeaderLength + 5);
+    const maxPixels = Math.floor(maxPixelDataLength / pixelsPerByte);
+    const maxBitmapWidth = Math.min(maxPixels, width);
+    let maxBitmapHeight = 1;
+    if (maxBitmapWidth == width) {
+        const bitmapRowPixelDataLength = Math.ceil(width / pixelsPerByte);
+        maxBitmapHeight = Math.floor(maxPixelDataLength / bitmapRowPixelDataLength);
+    }
+    _console$q.log({
+        maxPixelDataLength,
+        maxPixels,
+        maxBitmapHeight,
+        maxBitmapWidth,
+    });
+    if (maxBitmapHeight >= height) {
+        _console$q.log("image is small enough for a single bitmap");
+        const bitmap = {
+            numberOfColors,
+            pixels: colorIndices,
+            width,
+            height,
+        };
+        bitmapRows.push([bitmap]);
+    }
+    else {
+        let offsetX = 0;
+        let offsetY = 0;
+        const bitmapCanvas = document.createElement("canvas");
+        const bitmapColorIndices = new Array(numberOfColors)
+            .fill(0)
+            .map((_, i) => i);
+        while (offsetY < height) {
+            const bitmapHeight = Math.min(maxBitmapHeight, height - offsetY);
+            offsetX = 0;
+            const bitmapRow = [];
+            bitmapRows.push(bitmapRow);
+            while (offsetX < width) {
+                const bitmapWidth = Math.min(maxBitmapWidth, width - offsetX);
+                cropCanvas(canvas, offsetX, offsetY, bitmapWidth, bitmapHeight, bitmapCanvas);
+                const { bitmap } = await imageToBitmap(bitmapCanvas, bitmapWidth, bitmapHeight, colors, bitmapColorIndices, numberOfColors);
+                bitmapRow.push(bitmap);
+                offsetX += bitmapWidth;
+            }
+            offsetY += bitmapHeight;
+        }
+    }
+    return { bitmapRows, colors };
+}
+async function imageToBitmaps(image, width, height, numberOfColors, mtu) {
+    const canvas = resizeImage(image, width, height);
+    return canvasToBitmaps(canvas, numberOfColors, mtu);
+}
 function getBitmapNumberOfBytes(bitmap) {
     const pixelDepth = numberOfColorsToPixelDepth(bitmap.numberOfColors);
     const pixelsPerByte = pixelDepthToPixelsPerByte(pixelDepth);
@@ -6445,6 +6528,127 @@ function assertValidBitmapPixels(bitmap) {
         _console$q.assertRangeWithError(`bitmap.pixels[${index}]`, pixel, 0, bitmap.numberOfColors - 1);
     });
 }
+async function canvasToSprite(canvas, spriteName, numberOfColors, paletteName, overridePalette, spriteSheet, paletteOffset = 0) {
+    const { width, height } = canvas;
+    let palette = spriteSheet.palettes?.find((palette) => palette.name == paletteName);
+    if (!palette) {
+        palette = {
+            name: paletteName,
+            numberOfColors,
+            colors: new Array(numberOfColors).fill("#000000"),
+        };
+        spriteSheet.palettes = spriteSheet.palettes || [];
+        spriteSheet.palettes?.push(palette);
+    }
+    _console$q.log("pallete", palette);
+    const sprite = {
+        name: spriteName,
+        width,
+        height,
+        paletteSwaps: [],
+        commands: [],
+    };
+    const results = await quantizeCanvas(canvas, numberOfColors, !overridePalette ? palette.colors : undefined);
+    const blob = results.blob;
+    const colorIndices = results.colorIndices;
+    if (overridePalette) {
+        results.colors.forEach((color, index) => {
+            palette.colors[index + paletteOffset] = color;
+        });
+    }
+    sprite.commands.push({
+        type: "selectBitmapColors",
+        bitmapColorPairs: new Array(numberOfColors).fill(0).map((_, index) => ({
+            bitmapColorIndex: index,
+            colorIndex: index + paletteOffset,
+        })),
+    });
+    const bitmap = {
+        numberOfColors,
+        pixels: colorIndices,
+        width,
+        height,
+    };
+    sprite.commands.push({ type: "drawBitmap", offsetX: 0, offsetY: 0, bitmap });
+    const spriteIndex = spriteSheet.sprites.findIndex((sprite) => sprite.name == spriteName);
+    if (spriteIndex == -1) {
+        spriteSheet.sprites.push(sprite);
+    }
+    else {
+        _console$q.log(`overwriting spriteIndex ${spriteIndex}`);
+        spriteSheet.sprites[spriteIndex] = sprite;
+    }
+    return { sprite, blob };
+}
+async function imageToSprite(image, spriteName, width, height, numberOfColors, paletteName, overridePalette, spriteSheet, paletteOffset = 0) {
+    const canvas = resizeImage(image, width, height);
+    return canvasToSprite(canvas, spriteName, numberOfColors, paletteName, overridePalette, spriteSheet, paletteOffset);
+}
+const spriteSheetWithSingleBitmapCommandLength = calculateSpriteSheetHeaderLength(1) + drawSpriteBitmapCommandHeaderLength;
+function spriteSheetWithBitmapCommandAndSelectBitmapColorsLength(numberOfColors) {
+    return (spriteSheetWithSingleBitmapCommandLength + (1 + 1 + numberOfColors * 2));
+}
+async function canvasToSpriteSheet(canvas, spriteSheetName, numberOfColors, paletteName, maxFileLength) {
+    const spriteSheet = {
+        name: spriteSheetName,
+        palettes: [],
+        paletteSwaps: [],
+        sprites: [],
+    };
+    if (maxFileLength == undefined) {
+        await canvasToSprite(canvas, "image", numberOfColors, paletteName, true, spriteSheet);
+    }
+    else {
+        const { width, height } = canvas;
+        const numberOfPixels = width * height;
+        const pixelDepth = DisplayPixelDepths.find((pixelDepth) => pixelDepthToNumberOfColors(pixelDepth) >= numberOfColors);
+        _console$q.assertWithError(pixelDepth, `no pixelDepth found that covers ${numberOfColors} colors`);
+        const pixelsPerByte = pixelDepthToPixelsPerByte(pixelDepth);
+        const numberOfBytes = Math.ceil(numberOfPixels / pixelsPerByte);
+        _console$q.log({
+            width,
+            height,
+            numberOfPixels,
+            pixelDepth,
+            pixelsPerByte,
+            numberOfBytes,
+            maxFileLength,
+        });
+        const maxPixelDataLength = maxFileLength -
+            (spriteSheetWithBitmapCommandAndSelectBitmapColorsLength(numberOfColors) +
+                5);
+        const imageRowPixelDataLength = Math.ceil(width / pixelsPerByte);
+        const maxSpriteHeight = Math.floor(maxPixelDataLength / imageRowPixelDataLength);
+        if (maxSpriteHeight >= height) {
+            _console$q.log("image is small enough for a single sprite");
+            await canvasToSprite(canvas, "image", numberOfColors, paletteName, true, spriteSheet);
+        }
+        else {
+            const { colors } = await quantizeCanvas(canvas, numberOfColors);
+            spriteSheet.palettes?.push({ name: paletteName, numberOfColors, colors });
+            let offsetY = 0;
+            let imageIndex = 0;
+            const spriteCanvas = document.createElement("canvas");
+            while (offsetY < height) {
+                const spriteHeight = Math.min(maxSpriteHeight, height - offsetY);
+                cropCanvas(canvas, 0, offsetY, width, spriteHeight, spriteCanvas);
+                offsetY += spriteHeight;
+                _console$q.log(`cropping sprite ${imageIndex}`, {
+                    offsetY,
+                    width,
+                    spriteHeight,
+                });
+                await canvasToSprite(spriteCanvas, `image${imageIndex}`, numberOfColors, paletteName, false, spriteSheet);
+                imageIndex++;
+            }
+        }
+    }
+    return spriteSheet;
+}
+async function imageToSpriteSheet(image, spriteSheetName, width, height, numberOfColors, paletteName, maxFileLength) {
+    const canvas = resizeImage(image, width, height);
+    return canvasToSpriteSheet(canvas, spriteSheetName, numberOfColors, paletteName, maxFileLength);
+}
 
 const _console$p = createConsole("DisplayManagerInterface", { log: false });
 async function runDisplayContextCommand(displayManager, command, sendImmediately) {
@@ -14464,6 +14668,9 @@ exports.VibrationLocations = VibrationLocations;
 exports.VibrationTypes = VibrationTypes;
 exports.VibrationWaveformEffects = VibrationWaveformEffects;
 exports.WebSocketServer = WebSocketServer;
+exports.canvasToBitmaps = canvasToBitmaps;
+exports.canvasToSprite = canvasToSprite;
+exports.canvasToSpriteSheet = canvasToSpriteSheet;
 exports.displayCurveTypeToNumberOfControlPoints = displayCurveTypeToNumberOfControlPoints;
 exports.englishRegex = englishRegex;
 exports.fontToSpriteSheet = fontToSpriteSheet;
@@ -14472,12 +14679,18 @@ exports.getFontMetrics = getFontMetrics;
 exports.getFontUnicodeRange = getFontUnicodeRange;
 exports.getMaxSpriteSheetSize = getMaxSpriteSheetSize;
 exports.hexToRGB = hexToRGB;
+exports.imageToBitmaps = imageToBitmaps;
+exports.imageToSprite = imageToSprite;
+exports.imageToSpriteSheet = imageToSpriteSheet;
 exports.intersectWireframes = intersectWireframes;
 exports.isWireframePolygon = isWireframePolygon;
 exports.maxDisplayScale = maxDisplayScale;
 exports.mergeWireframes = mergeWireframes;
 exports.parseFont = parseFont;
 exports.pixelDepthToNumberOfColors = pixelDepthToNumberOfColors;
+exports.quantizeImage = quantizeImage;
+exports.resizeAndQuantizeImage = resizeAndQuantizeImage;
+exports.resizeImage = resizeImage;
 exports.rgbToHex = rgbToHex;
 exports.setAllConsoleLevelFlags = setAllConsoleLevelFlags;
 exports.setConsoleLevelFlagsForType = setConsoleLevelFlagsForType;