@divinevoxel/vlox 0.0.80 → 0.0.81

package/Templates/Archive/Functions/CreateArchivedTemplateFromFull.js

@@ -0,0 +1,174 @@
+import { Flat3DIndex, Vector3Like } from "@amodx/math";
+import { ArchivedVoxelTemplate } from "../ArchivedVoxelTemplate";
+import { NumberPalette } from "../../../Util/NumberPalette";
+import { BinaryBuffer, BinaryBufferFormat, } from "../../../Util/BinaryBuffer/index";
+import { VoxelArchivePalette } from "../../../Voxels/Archive/VoxelPaletteArechive";
+import { VoxelTagsRegister } from "../../../Voxels/Data/VoxelTagsRegister";
+import { VoxelLUT } from "../../../Voxels/Data/VoxelLUT";
+import { EngineSettings } from "../../../Settings/EngineSettings";
+/**
+ * Converts a FullVoxelTemplateData into an ArchivedVoxelTemplate.
+ */
+export default function CreateArchivedTemplateFromFull(fullData) {
+    const index = Flat3DIndex.GetXZYOrder();
+    index.setBounds(fullData.bounds.x, fullData.bounds.y, fullData.bounds.z);
+    const levelPalette = new NumberPalette();
+    const voxelPalette = new VoxelArchivePalette();
+    const secondaryPalette = new NumberPalette();
+    const ids = new Uint16Array(index.size);
+    const levels = new Uint8Array(index.size);
+    const secondary = new Uint16Array(index.size);
+    let idsAllTheSame = true;
+    let levelAllTheSame = true;
+    let secondaryAllTheSame = true;
+    let firstId = -1;
+    let firstLevel = -1;
+    let firstSecondary = -1;
+    let hasAnyVoxels = false;
+    for (let i = 0; i < index.size; i++) {
+        const rawId = fullData.ids[i];
+        const voxelId = voxelPalette.register(rawId);
+        const level = fullData.level[i];
+        const levelId = !levelPalette.isRegistered(level)
+            ? levelPalette.register(level)
+            : levelPalette.getId(level);
+        let voxelSecondary = 0;
+        const rawSecondary = fullData.secondary[i];
+        if (rawSecondary !== 0 &&
+            VoxelTagsRegister.VoxelTags[VoxelLUT.voxelIdToTrueId[rawId]]["dve_can_have_secondary"]) {
+            voxelSecondary = voxelPalette.register(rawSecondary);
+            if (!secondaryPalette.isRegistered(voxelSecondary))
+                secondaryPalette.register(voxelSecondary);
+        }
+        if (!hasAnyVoxels)
+            hasAnyVoxels = true;
+        if (firstId === -1)
+            firstId = voxelId;
+        if (firstLevel === -1)
+            firstLevel = levelId;
+        if (firstSecondary === -1)
+            firstSecondary = voxelSecondary;
+        ids[i] = voxelId;
+        levels[i] = levelId;
+        secondary[i] = voxelSecondary;
+        if (firstId !== voxelId)
+            idsAllTheSame = false;
+        if (firstLevel !== levelId)
+            levelAllTheSame = false;
+        if (firstSecondary !== voxelSecondary)
+            secondaryAllTheSame = false;
+    }
+    const buffers = {};
+    const idsPaletted = voxelPalette.size < 0xffff;
+    const levelPaletted = levelPalette.size < 0xff;
+    const secondaryPaletted = secondaryPalette.size < 0xffff;
+    // ids
+    if (idsAllTheSame) {
+        if (hasAnyVoxels) {
+            buffers.ids = BinaryBuffer.Create({
+                format: BinaryBufferFormat.Uint16,
+                byteLength: ids.length,
+                buffer: ids[0],
+            });
+        }
+    }
+    else if (idsPaletted) {
+        const type = BinaryBuffer.DetermineSubByteArray(voxelPalette.size);
+        buffers.ids = BinaryBuffer.Create({
+            buffer: BinaryBuffer.Convert(ids, BinaryBufferFormat.Uint16, type).buffer,
+            format: type,
+            byteLength: ids.length,
+        });
+    }
+    else {
+        buffers.ids = BinaryBuffer.Create({
+            buffer: ids.buffer,
+            format: BinaryBufferFormat.Uint16,
+            byteLength: ids.length,
+        });
+    }
+    // level
+    if (levelAllTheSame) {
+        if (hasAnyVoxels) {
+            buffers.level = BinaryBuffer.Create({
+                format: BinaryBufferFormat.Uint8,
+                byteLength: levels.length,
+                buffer: levels[0],
+            });
+        }
+    }
+    else if (levelPaletted) {
+        const type = BinaryBuffer.DetermineSubByteArray(levelPalette.size);
+        buffers.level = BinaryBuffer.Create({
+            buffer: BinaryBuffer.Convert(levels, BinaryBufferFormat.Uint8, type)
+                .buffer,
+            format: type,
+        });
+    }
+    else {
+        buffers.level = BinaryBuffer.Create({
+            buffer: levels.buffer,
+            format: BinaryBufferFormat.Uint8,
+        });
+    }
+    // secondary
+    if (secondaryAllTheSame) {
+        if (hasAnyVoxels) {
+            buffers.secondary = BinaryBuffer.Create({
+                format: BinaryBufferFormat.Uint16,
+                byteLength: secondary.length,
+                buffer: secondary[0],
+            });
+        }
+    }
+    else if (secondaryPaletted) {
+        const type = BinaryBuffer.DetermineSubByteArray(voxelPalette.size);
+        buffers.secondary = BinaryBuffer.Create({
+            buffer: BinaryBuffer.Convert(secondary, BinaryBufferFormat.Uint16, type)
+                .buffer,
+            format: type,
+        });
+    }
+    else {
+        buffers.secondary = BinaryBuffer.Create({
+            buffer: secondary.buffer,
+            format: BinaryBufferFormat.Uint16,
+        });
+    }
+    const palettes = {
+        ...voxelPalette.toJSON(),
+    };
+    if (levelPalette.size > 0 &&
+        !(levelPalette.size === 1 && levelPalette._palette[0] === 0)) {
+        palettes.level = BinaryBuffer.Create({
+            format: BinaryBufferFormat.Uint8,
+            byteLength: levelPalette._palette.length,
+            buffer: Uint8Array.from(levelPalette._palette).buffer,
+        });
+    }
+    if (secondaryPalette.size > 0 &&
+        !(secondaryPalette.size === 1 && secondaryPalette._palette[0] === 0)) {
+        palettes.secondary = BinaryBuffer.Create({
+            format: BinaryBufferFormat.Uint16,
+            byteLength: secondaryPalette._palette.length,
+            buffer: Uint16Array.from(secondaryPalette._palette).buffer,
+        });
+    }
+    const data = {
+        type: "archived",
+        engineVersion: EngineSettings.version,
+        formatVersion: "",
+        dataKey: {
+            voxelPalette: VoxelArchivePalette.GetVoxelPaletteDataKey(),
+            arrayOrders: {
+                id: "YXZ",
+                level: "YXZ",
+                secondary: "YXZ",
+            },
+        },
+        bounds: Vector3Like.Create(fullData.bounds.x, fullData.bounds.y, fullData.bounds.z),
+        palettes,
+        buffers,
+    };
+    return new ArchivedVoxelTemplate(data);
+}

package/Textures/Classes/CompactedTextureReader.d.ts

@@ -0,0 +1,22 @@
+import { Vec2Array } from "@amodx/math";
+import { TextureAtlasIndex } from "./TextureAtlasIndex";
+import { CompactedTextureNodeBaseData } from "Textures/Texture.types";
+export declare class CompactedTextureReader {
+    canvas: HTMLCanvasElement;
+    context: CanvasRenderingContext2D;
+    atlasCanvas: HTMLCanvasElement;
+    atlasContext: CanvasRenderingContext2D;
+    textureCanvas: HTMLCanvasElement;
+    textureContext: CanvasRenderingContext2D;
+    index: TextureAtlasIndex;
+    atlasIndex: TextureAtlasIndex;
+    size: Vec2Array;
+    textureSize: Vec2Array;
+    constructor();
+    setSize(size: Vec2Array, textureSize: Vec2Array): void;
+    loadImage(path: string): Promise<boolean>;
+    getFinalImage(): HTMLImageElement;
+    writeImage(index: number, image: HTMLImageElement): void;
+    readImage(data: CompactedTextureNodeBaseData): Promise<HTMLImageElement>;
+    readImageAtIndex(index: number): Promise<HTMLImageElement>;
+}

package/Textures/Classes/CompactedTextureReader.js

@@ -0,0 +1,90 @@
+import { TextureAtlasIndex } from "./TextureAtlasIndex";
+export class CompactedTextureReader {
+    canvas;
+    context;
+    atlasCanvas;
+    atlasContext;
+    textureCanvas;
+    textureContext;
+    index = new TextureAtlasIndex();
+    atlasIndex = new TextureAtlasIndex();
+    size;
+    textureSize;
+    constructor() {
+        this.canvas = document.createElement("canvas");
+        this.context = this.canvas.getContext("2d", {
+            willReadFrequently: true,
+        });
+        this.context.imageSmoothingEnabled = false;
+        this.atlasCanvas = document.createElement("canvas");
+        this.atlasContext = this.atlasCanvas.getContext("2d", {
+            willReadFrequently: true,
+        });
+        this.atlasContext.imageSmoothingEnabled = false;
+        this.textureCanvas = document.createElement("canvas");
+        this.textureContext = this.textureCanvas.getContext("2d", {
+            willReadFrequently: true,
+        });
+        this.textureContext.imageSmoothingEnabled = false;
+        if (!this.context)
+            throw new Error(`Error could not create CanvasRenderingContext2D`);
+    }
+    setSize(size, textureSize) {
+        this.index.setBounds([size[0] / textureSize[0], size[1] / textureSize[1]]);
+        this.size = size;
+        this.canvas.width = size[0];
+        this.canvas.height = size[1];
+        this.textureCanvas.width = textureSize[0];
+        this.textureCanvas.height = textureSize[1];
+        this.textureSize = textureSize;
+    }
+    loadImage(path) {
+        return new Promise((resolve, reject) => {
+            const image = new Image();
+            image.onerror = reject;
+            image.src = path;
+            image.onload = () => {
+                this.context.drawImage(image, 0, 0, this.canvas.width, this.canvas.height);
+                resolve(true);
+            };
+        });
+    }
+    getFinalImage() {
+        const image = new Image();
+        image.src = this.canvas.toDataURL("image/png");
+        return image;
+    }
+    writeImage(index, image) {
+        const [x, y] = this.index.getPosition(index);
+        this.context.drawImage(image, x * this.textureSize[0], y * this.textureSize[1], this.textureSize[0], this.textureSize[1]);
+    }
+    async readImage(data) {
+        if (!Array.isArray(data.index)) {
+            return this.readImageAtIndex(data.index);
+        }
+        const atlas = data.atlas;
+        this.atlasCanvas.width = atlas[0] * this.textureSize[0];
+        this.atlasCanvas.height = atlas[1] * this.textureSize[1];
+        this.atlasContext.clearRect(0, 0, this.atlasCanvas.width, this.atlasCanvas.height);
+        this.atlasIndex.setBounds(atlas);
+        const startIndex = data.index[0];
+        for (const index of data.index) {
+            const [x, y] = this.atlasIndex.getPosition(index - startIndex);
+            const image = await this.readImageAtIndex(index);
+            this.atlasContext.drawImage(image, x * this.textureSize[0], y * this.textureSize[1], this.textureSize[0], this.textureSize[1]);
+        }
+        const image = new Image();
+        image.src = this.atlasCanvas.toDataURL("image/png");
+        return image;
+    }
+    async readImageAtIndex(index) {
+        const tileWidth = this.textureSize[0];
+        const tileHeight = this.textureSize[1];
+        const [x, y] = this.index.getPosition(index);
+        this.textureContext.clearRect(0, 0, tileWidth, tileHeight);
+        this.textureContext.drawImage(this.canvas, x * tileWidth, y * tileHeight, tileWidth, tileHeight, 0, 0, tileWidth, tileHeight);
+        const image = new Image();
+        image.src = this.textureCanvas.toDataURL("image/png");
+        return image;
+    }
+}

package/Textures/Classes/CompiledTexture.d.ts

@@ -6,7 +6,6 @@ export declare class CompiledTexture {
     id: string;
     static GetAtlasIndex: (x: number, y: number, boundsX: number) => number;
     static GetAtlasPosition: (index: number, boundsX: number, position?: Vec2Array) => Vec2Array;
-    originalImages: HTMLImageElement[];
     images: HTMLImageElement[];
     /**Maps texture ids to their atlas sizes  */
     atlasSizeMap: Record<string, [width: number, height: number]>;
@@ -19,5 +18,9 @@ export declare class CompiledTexture {
     constructor(id: string);
     getTextureIndex(id: TextureId): number;
     getTexturePath(id: TextureId): string;
+    canvas: HTMLCanvasElement;
+    context: CanvasRenderingContext2D;
+    private setUpCanvas;
     getTextureData(id: TextureId): Promise<Uint8ClampedArray>;
+    getTextureDataSync(id: TextureId): Uint8ClampedArray;
 }

package/Textures/Classes/CompiledTexture.js

@@ -7,7 +7,6 @@ export class CompiledTexture {
         position[0] = Math.floor(index % boundsX);
         return position;
     };
-    originalImages = [];
     images = [];
     /**Maps texture ids to their atlas sizes  */
     atlasSizeMap = {};
@@ -54,18 +53,47 @@ export class CompiledTexture {
     getTexturePath(id) {
         return this.images[this.getTextureIndex(id)].src;
     }
+    canvas;
+    context;
+    setUpCanvas() {
+        if (this.canvas)
+            return;
+        this.canvas = document.createElement("canvas");
+        this.context = this.canvas.getContext("2d", {
+            willReadFrequently: true,
+        });
+    }
     async getTextureData(id) {
-        const path = this.originalImages[this.getTextureIndex(id)].src;
+        this.setUpCanvas();
+        const path = this.images[this.getTextureIndex(id)].src;
         const res = await fetch(path);
         if (!res.ok)
             throw new Error(`Failed to fetch texture: ${path}`);
         const blob = await res.blob();
         const bitmap = await createImageBitmap(blob);
-        const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
-        const ctx = canvas.getContext("2d");
-        if (!ctx)
-            throw new Error("OffscreenCanvas context unavailable");
-        ctx.drawImage(bitmap, 0, 0);
-        return ctx.getImageData(0, 0, bitmap.width, bitmap.height).data;
+        this.canvas.width = bitmap.width;
+        this.canvas.height = bitmap.height;
+        this.context.translate(0, bitmap.height);
+        this.context.scale(1, -1);
+        this.context.drawImage(bitmap, 0, 0);
+        return this.context.getImageData(0, 0, bitmap.width, bitmap.height).data;
+    }
+    getTextureDataSync(id) {
+        this.setUpCanvas();
+        const img = this.images[this.getTextureIndex(id)];
+        if (!img) {
+            throw new Error(`Texture image not found for ID: ${id}`);
+        }
+        if (!img.complete || img.naturalWidth === 0) {
+            throw new Error(`Texture image is not fully loaded yet: ${img.src}`);
+        }
+        const width = img.naturalWidth;
+        const height = img.naturalHeight;
+        this.canvas.width = width;
+        this.canvas.height = height;
+        this.context.translate(0, height);
+        this.context.scale(1, -1);
+        this.context.drawImage(img, 0, 0);
+        return this.context.getImageData(0, 0, width, height).data;
     }
 }

package/Textures/Classes/TextureAtlasIndex.d.ts

@@ -0,0 +1,7 @@
+import { Vec2Array } from "@amodx/math";
+export declare class TextureAtlasIndex {
+    bounds: Vec2Array;
+    setBounds(bounds: Vec2Array): void;
+    getIndex(x: number, y: number): number;
+    getPosition(index: number, position?: Vec2Array): Vec2Array;
+}

package/Textures/Classes/TextureAtlasIndex.js

@@ -0,0 +1,14 @@
+export class TextureAtlasIndex {
+    bounds = [0, 0];
+    setBounds(bounds) {
+        this.bounds = bounds;
+    }
+    getIndex(x, y) {
+        return x + y * this.bounds[0];
+    }
+    getPosition(index, position = [0, 0]) {
+        position[0] = Math.floor(index % this.bounds[0]);
+        position[1] = Math.floor(index / this.bounds[0]);
+        return position;
+    }
+}

package/Textures/Classes/TextureLoader.d.ts

@@ -0,0 +1,20 @@
+import { Vec2Array } from "@amodx/math";
+import { TextureData } from "../Texture.types";
+import { TextureAtlasIndex } from "./TextureAtlasIndex";
+export declare class TextureLoader {
+    baseURL: string;
+    canvas: HTMLCanvasElement;
+    context: CanvasRenderingContext2D;
+    atlasCanvas: HTMLCanvasElement;
+    atlasContext: CanvasRenderingContext2D;
+    size: Vec2Array;
+    atlasIndex: TextureAtlasIndex;
+    constructor();
+    setSize(size: Vec2Array): void;
+    getImageBase64(url: string): Promise<string>;
+    loadImage(src: string): Promise<HTMLImageElement>;
+    sliceImageIntoTiles(src: string, tilesX: number, tilesY: number): Promise<HTMLImageElement[]>;
+    getImagePath(data: TextureData, parentId?: string | null): string;
+    getTextureId(data: TextureData, parentId?: string | null): string;
+    loadImageForShader(imgSrcData: string | HTMLImageElement): Promise<HTMLImageElement>;
+}

package/Textures/Classes/TextureLoader.js

@@ -0,0 +1,95 @@
+import { TextureAtlasIndex } from "./TextureAtlasIndex";
+export class TextureLoader {
+    baseURL = "assets/textures";
+    canvas;
+    context;
+    atlasCanvas;
+    atlasContext;
+    size;
+    atlasIndex = new TextureAtlasIndex();
+    constructor() {
+        this.canvas = document.createElement("canvas");
+        this.context = this.canvas.getContext("2d", {
+            willReadFrequently: true,
+        });
+        this.context.imageSmoothingEnabled = false;
+        this.atlasCanvas = document.createElement("canvas");
+        this.atlasContext = this.atlasCanvas.getContext("2d", {
+            willReadFrequently: true,
+        });
+        if (!this.context)
+            throw new Error(`Error could not create CanvasRenderingContext2D`);
+    }
+    setSize(size) {
+        this.size = size;
+        this.canvas.width = size[0];
+        this.canvas.height = size[1];
+    }
+    async getImageBase64(url) {
+        const response = await fetch(url);
+        const blob = await response.blob();
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.readAsDataURL(blob);
+            reader.onloadend = () => resolve(reader.result);
+            reader.onerror = reject;
+        });
+    }
+    loadImage(src) {
+        return new Promise((resolve, reject) => {
+            const img = new Image();
+            img.src = src;
+            img.onload = () => resolve(img);
+            img.onerror = reject;
+        });
+    }
+    async sliceImageIntoTiles(src, tilesX, tilesY) {
+        const image = await this.loadImage(src);
+        this.atlasIndex.setBounds([tilesX, tilesY]);
+        const tileWidth = image.width / tilesX;
+        const tileHeight = image.height / tilesY;
+        this.atlasCanvas.width = tileWidth;
+        this.atlasCanvas.height = tileHeight;
+        const tiles = [];
+        for (let x = 0; x < tilesX; x++) {
+            for (let y = 0; y < tilesY; y++) {
+                this.atlasContext.clearRect(0, 0, tileWidth, tileHeight);
+                this.atlasContext.drawImage(image, x * tileWidth, y * tileHeight, tileWidth, tileHeight, 0, 0, tileWidth, tileHeight);
+                tiles[this.atlasIndex.getIndex(x, y)] = await this.loadImage(this.atlasCanvas.toDataURL("image/png"));
+            }
+        }
+        return tiles;
+    }
+    getImagePath(data, parentId = null) {
+        if (data.base64)
+            return data.base64;
+        if (data.path)
+            return data.path;
+        if (!parentId)
+            return `${this.baseURL}/${data.id}.png`;
+        return `${this.baseURL}/${parentId}/${data.id}.png`;
+    }
+    getTextureId(data, parentId = null) {
+        return `${parentId ? parentId : data.id}${!parentId ? "" : ":" + data.id}`;
+    }
+    async loadImageForShader(imgSrcData) {
+        return new Promise((resolve, reject) => {
+            const image = typeof imgSrcData === "string" ? new Image() : imgSrcData;
+            image.onerror = reject;
+            if (typeof imgSrcData === "string")
+                image.src = imgSrcData;
+            image.onload = () => {
+                this.context.clearRect(0, 0, this.canvas.width, this.canvas.height);
+                this.context.save();
+                this.context.translate(0, this.canvas.height);
+                this.context.scale(1, -1);
+                this.context.drawImage(image, 0, 0, this.canvas.width, this.canvas.height);
+                this.context.restore();
+                const dataUrl = this.canvas.toDataURL("image/png");
+                const returnImage = new Image(this.canvas.width, this.canvas.height);
+                returnImage.src = dataUrl;
+                returnImage.onload = () => resolve(returnImage);
+            };
+        });
+    }
+}

package/Textures/Functions/BuildTextureData.d.ts

@@ -8,4 +8,4 @@ export type BuildTextureDataProps = {
     textures: TextureData[];
     finalSize?: [width: number, height: number];
 };
-export declare function BuildTextureData({ type, baseURL: currentBaseURL, textures, finalSize: currentFinalSize, createCache, }: BuildTextureDataProps, progress: WorkItemProgress): Promise<CompiledTexture>;
+export declare function BuildTextureData({ type, baseURL, textures, finalSize, createCache }: BuildTextureDataProps, progress: WorkItemProgress): Promise<CompiledTexture>;