brilliantsole 0.0.36 → 0.0.37

package/build/brilliantsole.cjs

@@ -5609,9 +5609,6 @@ 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) => {
@@ -6391,15 +6388,6 @@ 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);
@@ -6438,77 +6426,6 @@ 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);
@@ -6528,127 +6445,6 @@ 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) {
@@ -14668,9 +14464,6 @@ 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;
@@ -14679,18 +14472,12 @@ 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;