@divinevoxel/vlox 0.0.80 → 0.0.81

package/Textures/Functions/BuildTextureData.js

@@ -1,94 +1,7 @@
 import { CompiledTexture } from "../Classes/CompiledTexture";
 import { CompiledTextureAnimation } from "../../Textures/Classes/CompiledTextureAnimation";
-let baseURL = "assets/textures";
-let canvas;
-let context;
-let atlasCanvas;
-let atlasContext;
-const finalSize = [256, 256];
-async function 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;
-    });
-}
-function loadImage(src) {
-    return new Promise((resolve, reject) => {
-        const img = new Image();
-        img.src = src;
-        img.onload = () => resolve(img);
-        img.onerror = reject;
-    });
-}
-async function sliceImageIntoTiles(src, tilesX, tilesY) {
-    const image = await loadImage(src);
-    const tileWidth = image.width / tilesX;
-    const tileHeight = image.height / tilesY;
-    atlasCanvas.width = tileWidth;
-    atlasCanvas.height = tileHeight;
-    const tiles = [];
-    for (let x = 0; x < tilesX; x++) {
-        for (let y = 0; y < tilesY; y++) {
-            atlasContext.clearRect(0, 0, tileWidth, tileHeight);
-            atlasContext.drawImage(image, x * tileWidth, y * tileHeight, tileWidth, tileHeight, 0, 0, tileWidth, tileHeight);
-            tiles[CompiledTexture.GetAtlasIndex(x, y, tilesX)] =
-                atlasCanvas.toDataURL("image/png");
-        }
-    }
-    return tiles;
-}
-async function loadImageForShader(imgSrcData) {
-    if (!context)
-        throw new Error("Canvas context is not available");
-    canvas.width = finalSize[0];
-    canvas.height = finalSize[1];
-    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 = () => {
-            context.clearRect(0, 0, canvas.width, canvas.height);
-            context.imageSmoothingEnabled = false;
-            context.save();
-            context.translate(0, canvas.height);
-            context.scale(1, -1);
-            context.drawImage(image, 0, 0, canvas.width, canvas.height);
-            context.restore();
-            const dataUrl = canvas.toDataURL("image/png");
-            const returnImage = new Image(canvas.width, canvas.height);
-            returnImage.src = dataUrl;
-            returnImage.onload = () => resolve(returnImage);
-        };
-    });
-}
-async function loadImageForOriginal(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 = () => {
-            resolve(image);
-        };
-    });
-}
-function getImagePath(data, parentId = null) {
-    if (data.base64)
-        return data.base64;
-    if (data.path)
-        return data.path;
-    if (!parentId)
-        return `${baseURL}/${data.id}.png`;
-    return `${baseURL}/${parentId}/${data.id}.png`;
-}
-function getTextureId(data, parentId = null) {
-    return `${parentId ? parentId : data.id}${!parentId ? "" : ":" + data.id}`;
-}
+import { TextureLoader } from "../Classes/TextureLoader";
+let loader;
 function createAnimationData(atlas, data, startIndex) {
     const compiled = new CompiledTextureAnimation(startIndex);
     if (!data?.frames) {
@@ -123,21 +36,19 @@ function createAnimationData(atlas, data, startIndex) {
     return compiled;
 }
 async function process(compiled, data, textureIndex, parent, cache = false) {
-    const textureId = getTextureId(data, parent);
+    const textureId = loader.getTextureId(data, parent);
     compiled.textureMap[textureId] = textureIndex;
-    const imagePath = getImagePath(data, parent);
+    const imagePath = loader.getImagePath(data, parent);
     if (cache) {
-        data.base64 = await getImageBase64(imagePath);
+        data.base64 = await loader.getImageBase64(imagePath);
     }
     if (!data.atlas) {
-        compiled.images[textureIndex] = await loadImageForShader(imagePath);
-        compiled.originalImages[textureIndex] = await loadImageForOriginal(imagePath);
+        compiled.images[textureIndex] = await loader.loadImageForShader(imagePath);
         return textureIndex + 1;
     }
-    const tiles = await sliceImageIntoTiles(imagePath, ...data.atlas.tiles);
+    const tiles = await loader.sliceImageIntoTiles(imagePath, ...data.atlas.tiles);
     for (let i = 0; i < tiles.length; i++) {
-        compiled.images[textureIndex + i] = await loadImageForShader(tiles[i]);
-        compiled.originalImages[textureIndex + i] = await loadImageForOriginal(tiles[i]);
+        compiled.images[textureIndex + i] = await loader.loadImageForShader(tiles[i].src);
     }
     compiled.atlasSizeMap[textureId] = data.atlas.tiles;
     if (data.animated) {
@@ -153,36 +64,22 @@ async function process(compiled, data, textureIndex, parent, cache = false) {
     }
     return textureIndex + tiles.length;
 }
-export async function BuildTextureData({ type, baseURL: currentBaseURL, textures, finalSize: currentFinalSize, createCache, }, progress) {
-    const defaultBaseURL = currentBaseURL || "assets/textures";
-    finalSize[0] = currentFinalSize ? currentFinalSize[0] : 256;
-    finalSize[1] = currentFinalSize ? currentFinalSize[1] : 256;
-    if (!canvas) {
-        canvas = document.createElement("canvas");
-        canvas.width = finalSize[0];
-        canvas.height = finalSize[1];
-        context = canvas.getContext("2d", {
-            willReadFrequently: true,
-        });
-        context.imageSmoothingEnabled = false;
-        atlasCanvas = document.createElement("canvas");
-        atlasContext = atlasCanvas.getContext("2d", {
-            willReadFrequently: true,
-        });
-        // atlasContext.imageSmoothingEnabled = false;
-        if (!context)
-            throw new Error(`Error could not create CanvasRenderingContext2D`);
+export async function BuildTextureData({ type, baseURL, textures, finalSize, createCache }, progress) {
+    const defaultBaseURL = baseURL || "assets/textures";
+    if (!loader) {
+        loader = new TextureLoader();
     }
+    loader.setSize(finalSize || [16, 16]);
     const compiled = new CompiledTexture(type);
     let count = 0;
     for (const texture of textures) {
         progress.completeWorkItems(1);
         progress.setStatus(`Building Texture ${type} | ${texture.id}`);
         if (texture.basePath) {
-            baseURL = texture.basePath;
+            loader.baseURL = texture.basePath;
         }
         else {
-            baseURL = defaultBaseURL;
+            loader.baseURL = defaultBaseURL;
         }
         if (!texture.variations?.length) {
             try {
@@ -199,10 +96,10 @@ export async function BuildTextureData({ type, baseURL: currentBaseURL, textures
             for (let i = 0; i < texture.variations.length; i++) {
                 const vara = texture.variations[i];
                 if (texture.basePath) {
-                    baseURL = texture.basePath;
+                    loader.baseURL = texture.basePath;
                 }
                 else {
-                    baseURL = defaultBaseURL;
+                    loader.baseURL = defaultBaseURL;
                 }
                 if (typeof vara == "string") {
                     const newData = { type: texture.type, id: vara };
@@ -220,10 +117,10 @@ export async function BuildTextureData({ type, baseURL: currentBaseURL, textures
                 }
                 try {
                     if (vara.basePath) {
-                        baseURL = vara.basePath;
+                        loader.baseURL = vara.basePath;
                     }
                     else {
-                        baseURL = defaultBaseURL;
+                        loader.baseURL = defaultBaseURL;
                     }
                     count = await process(compiled, vara, count, texture.id, createCache);
                 }

package/Textures/Functions/CreateCompactedTexture.d.ts

@@ -0,0 +1,6 @@
+import { Vec2Array } from "@amodx/math";
+import { CompactedTextureData, TextureData } from "../Texture.types";
+export declare function CreateCompactedTexture(type: string, baseURL: string, size: Vec2Array, textures: TextureData[]): Promise<{
+    data: CompactedTextureData;
+    image: HTMLImageElement;
+}>;

package/Textures/Functions/CreateCompactedTexture.js

@@ -0,0 +1,105 @@
+import { TextureLoader } from "../Classes/TextureLoader";
+import { CompactedTextureReader } from "../Classes/CompactedTextureReader";
+async function process(loader, reader, node, data, textureIndex, parent) {
+    const imagePath = loader.getImagePath(data, parent);
+    if (!data.atlas) {
+        const loadedImage = await loader.loadImage(imagePath);
+        reader.writeImage(textureIndex, loadedImage);
+        node.index = textureIndex;
+        return textureIndex + 1;
+    }
+    node.atlas = data.atlas.tiles;
+    const tiles = await loader.sliceImageIntoTiles(imagePath, ...data.atlas.tiles);
+    node.index = [];
+    for (let i = 0; i < tiles.length; i++) {
+        node.index.push(textureIndex + i);
+        reader.writeImage(textureIndex + i, tiles[i]);
+    }
+    return textureIndex + tiles.length;
+}
+export async function CreateCompactedTexture(type, baseURL, size, textures) {
+    const defaultBaseURL = baseURL || "assets/textures";
+    const compatexTextureData = {
+        type,
+        size: [0, 0],
+        textureSize: size,
+        nodes: [],
+    };
+    let totalImageCount = 0;
+    for (const textureData of textures) {
+        if (!textureData.variations?.length) {
+            if (textureData.atlas) {
+                totalImageCount +=
+                    textureData.atlas.tiles[0] * textureData.atlas.tiles[1];
+            }
+            else {
+                totalImageCount++;
+            }
+            continue;
+        }
+        if (textureData.variations) {
+            for (const varation of textureData.variations) {
+                if (typeof varation == "string") {
+                    totalImageCount++;
+                    continue;
+                }
+                if (varation.atlas) {
+                    totalImageCount += varation.atlas.tiles[0] * varation.atlas.tiles[1];
+                }
+                else {
+                    totalImageCount++;
+                }
+            }
+        }
+    }
+    const width = Math.ceil(Math.sqrt(totalImageCount)) * size[0];
+    const height = Math.ceil(Math.sqrt(totalImageCount)) * size[1];
+    compatexTextureData.size = [width, height];
+    const loader = new TextureLoader();
+    loader.setSize(size);
+    const compactedTextureReader = new CompactedTextureReader();
+    compactedTextureReader.setSize([width, height], size);
+    let textureIndex = 0;
+    for (const textureData of textures) {
+        if (textureData.basePath) {
+            loader.baseURL = textureData.basePath;
+        }
+        else {
+            loader.baseURL = defaultBaseURL;
+        }
+        const baseNode = {
+            id: textureData.id,
+            index: 0,
+        };
+        compatexTextureData.nodes.push(baseNode);
+        if (!textureData?.variations?.length) {
+            textureIndex = await process(loader, compactedTextureReader, baseNode, textureData, textureIndex, null);
+        }
+        if (textureData.variations) {
+            baseNode.variations = [];
+            for (let varation of textureData.variations) {
+                if (typeof varation == "string") {
+                    varation = { id: varation };
+                    if (textureData.basePath)
+                        varation.basePath = textureData.basePath;
+                }
+                if (varation.basePath) {
+                    loader.baseURL = varation.basePath;
+                }
+                else {
+                    loader.baseURL = defaultBaseURL;
+                }
+                const varationNode = {
+                    id: varation.id,
+                    index: 0,
+                };
+                baseNode.variations.push(varationNode);
+                textureIndex = await process(loader, compactedTextureReader, varationNode, varation, textureIndex, textureData.id);
+            }
+        }
+    }
+    return {
+        data: compatexTextureData,
+        image: compactedTextureReader.getFinalImage(),
+    };
+}

package/Textures/Functions/ReadCompactedTexture.d.ts

@@ -0,0 +1,2 @@
+import { CompactedTextureData, TextureData } from "../Texture.types";
+export declare function ReadCompactedTexture(data: CompactedTextureData, textures: TextureData[], path: string): Promise<void>;

package/Textures/Functions/ReadCompactedTexture.js

@@ -0,0 +1,42 @@
+import { CompactedTextureReader } from "../Classes/CompactedTextureReader";
+function findVarationTextureData(id, textureData) {
+    if (!textureData.variations)
+        return null;
+    for (let i = 0; i < textureData.variations.length; i++) {
+        if (typeof textureData.variations[i] == "string" &&
+            textureData.variations[i] == id) {
+            const data = {
+                id,
+            };
+            textureData.variations[i] = data;
+            return data;
+        }
+        else if (textureData.variations[i].id == id) {
+            return textureData.variations[i];
+        }
+    }
+    return null;
+}
+export async function ReadCompactedTexture(data, textures, path) {
+    const textureMap = new Map();
+    const compactedTextureMap = new Map();
+    for (const textureData of textures) {
+        textureMap.set(textureData.id, textureData);
+    }
+    for (const textureData of data.nodes) {
+        compactedTextureMap.set(textureData.id, textureData);
+    }
+    const compactedTextureReader = new CompactedTextureReader();
+    compactedTextureReader.setSize(data.size, data.textureSize);
+    await compactedTextureReader.loadImage(path);
+    for (const node of data.nodes) {
+        const textureData = textureMap.get(node.id);
+        textureData.base64 = (await compactedTextureReader.readImage(node)).src;
+        if (node.variations) {
+            for (const varation of node.variations) {
+                const data = findVarationTextureData(varation.id, textureData);
+                data.base64 = (await compactedTextureReader.readImage(varation)).src;
+            }
+        }
+    }
+}

package/Textures/Texture.types.d.ts

@@ -64,3 +64,17 @@ export type TextureData = {
      */
     variations?: (string | TextureDataBase)[];
 } & TextureDataBase;
+export type CompactedTextureData = {
+    type: string;
+    size: [sizeX: number, sizeY: number];
+    textureSize: [sizeX: number, sizeY: number];
+    nodes: CompactedTextureNodeData[];
+};
+export type CompactedTextureNodeBaseData = {
+    id: string;
+    index: number | number[];
+    atlas?: [sizeX: number, sizeY: number];
+};
+export type CompactedTextureNodeData = {
+    variations?: CompactedTextureNodeBaseData[];
+} & CompactedTextureNodeBaseData;

package/Textures/TextureManager.d.ts

@@ -1,7 +1,8 @@
+import { Vec2Array } from "@amodx/math";
 import { WorkItemProgress } from "../Util/WorkItemProgress.js";
 import { CompiledTexture } from "./Classes/CompiledTexture.js";
 import { BuildTextureDataProps } from "./Functions/BuildTextureData.js";
-import type { TextureData } from "./Texture.types";
+import type { CompactedTextureData, TextureData } from "./Texture.types";
 export declare class TextureManager {
     static _textureTypes: Map<string, TextureData[]>;
     static _compiledTextures: Map<string, CompiledTexture>;
@@ -9,4 +10,9 @@ export declare class TextureManager {
     static registerTexture(textureData: TextureData[]): void;
     static getTexture(id: string): CompiledTexture;
     static compiledTextures(props?: Omit<BuildTextureDataProps, "textures" | "type">, progress?: WorkItemProgress): Promise<void>;
+    static createCompactedTextures(baseURL: string, textureSize: Vec2Array): Promise<{
+        data: CompactedTextureData;
+        image: HTMLImageElement;
+    }[]>;
+    static readCompactedTexture(data: CompactedTextureData, path: string): Promise<void>;
 }

package/Textures/TextureManager.js

@@ -1,5 +1,7 @@
 import { WorkItemProgress } from "../Util/WorkItemProgress.js";
 import { BuildTextureData, } from "./Functions/BuildTextureData.js";
+import { CreateCompactedTexture } from "./Functions/CreateCompactedTexture.js";
+import { ReadCompactedTexture } from "./Functions/ReadCompactedTexture.js";
 const missingTexture = {
     id: "dve_missing",
     base64: "data:image/png;base64,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",
@@ -40,6 +42,17 @@ export class TextureManager {
             this._compiledTextures.set(type, compiled);
         }
     }
+    static async createCompactedTextures(baseURL, textureSize) {
+        const returnData = [];
+        for (const [type, data] of this._textureTypes) {
+            returnData.push(await CreateCompactedTexture(type, baseURL, textureSize, data));
+        }
+        return returnData;
+    }
+    static async readCompactedTexture(data, path) {
+        const textures = this._textureTypes.get(data.type);
+        await ReadCompactedTexture(data, textures, path);
+    }
 }
 TextureManager.addTextureType("dve_item");
 TextureManager.addTextureType("dve_voxel");

package/Tools/Brush/Brush.d.ts

@@ -6,6 +6,7 @@ import { PaintVoxelData } from "../../Voxels/Types/PaintVoxelData.js";
 import { VoxelPathData } from "../../Templates/Path/VoxelPath.types.js";
 import { IVoxelSelection } from "../../Templates/Selection/VoxelSelection.js";
 export declare class BrushTool {
+    private temp;
     data: PaintVoxelData;
     dimension: number;
     x: number;
@@ -28,8 +29,9 @@ export declare class BrushTool {
     setLevelState(levelState: number): this;
     setMod(mod: number): this;
     clear(): void;
-    _paint(): false | undefined;
-    _erase(): void;
+    protected _paint(): false | undefined;
+    protected _paintRaw(raw: RawVoxelData): false | undefined;
+    protected _erase(): void;
     paint(): this;
     paintTemplate(voxelTemplate: IVoxelTemplate): void;
     paintPath(data: VoxelPathData): void;

package/Tools/Brush/Brush.js

@@ -4,9 +4,9 @@ import { WorldRegister } from "../../World/WorldRegister.js";
 import { VoxelLUT } from "../../Voxels/Data/VoxelLUT.js";
 import { PaintVoxelData } from "../../Voxels/Types/PaintVoxelData.js";
 const air = [0, 0, 0, 0];
-const temp = [0, 0, 0, 0];
 PaintVoxelData.Set;
 export class BrushTool {
+    temp = [0, 0, 0, 0];
     data = PaintVoxelData.Create();
     dimension = 0;
     x = 0;
@@ -87,8 +87,7 @@ export class BrushTool {
     }
     setSecondaryName(name) {
         if (name) {
-            this.data.secondaryVoxelId =
-                VoxelLUT.voxelNametoIdMap.get(name);
+            this.data.secondaryVoxelId = VoxelLUT.voxelNametoIdMap.get(name);
         }
         else {
             this.data.secondaryVoxelId = "";
@@ -115,11 +114,14 @@ export class BrushTool {
     clear() {
         this.data.id = "dve_air";
         this.data.name = "";
+        this.data.state = 0;
+        this.data.mod = 0;
         this.data.secondaryVoxelId = "";
+        this.data.secondaryName = "";
+        this.data.secondaryState = 0;
+        this.data.secondaryMod = 0;
         this.data.level = 0;
         this.data.levelState = 0;
-        this.data.state = 0;
-        this.data.mod = 0;
         this.x = 0;
         this.y = 0;
         this.z = 0;
@@ -136,7 +138,26 @@ export class BrushTool {
         voxel.setLevel(this.data.level);
         if (this.data.secondaryVoxelId && this.data.secondaryVoxelId != "dve_air") {
             voxel.setSecondary(true);
-            voxel.setStringId(this.data.secondaryVoxelId);
+            voxel.setStringId(this.data.secondaryVoxelId, this.data.secondaryState, this.data.secondaryMod);
+            voxel.setSecondary(false);
+        }
+        voxel.process();
+        if (voxel.isLightSource() && voxel.getLightSourceValue()) {
+            voxel.setLight(voxel.getLightSourceValue());
+        }
+        voxel.updateVoxel(0);
+    }
+    _paintRaw(raw) {
+        if (!this.dataCursor.inBounds(this.x, this.y, this.z))
+            return false;
+        const voxel = this.dataCursor.getVoxel(this.x, this.y, this.z);
+        if (!voxel)
+            return;
+        voxel.setId(raw[0]);
+        voxel.setLevel(raw[2]);
+        if (voxel.canHaveSecondaryVoxel() && raw[3] !== 0) {
+            voxel.setSecondary(true);
+            voxel.setId(raw[3]);
             voxel.setSecondary(false);
         }
         voxel.process();
@@ -158,6 +179,7 @@ export class BrushTool {
     paintTemplate(voxelTemplate) {
         const { x: ox, y: oy, z: oz } = this;
         const { x: sx, y: sy, z: sz } = voxelTemplate.bounds.size;
+        const temp = [0, 0, 0, 0];
         for (let x = 0; x < sx; x++) {
             for (let y = 0; y < sy; y++) {
                 for (let z = 0; z < sz; z++) {

package/Util/BinaryBuffer/Functions/BinaryBufferConvert.d.ts

@@ -2,4 +2,4 @@ import { BinaryBufferFormat } from "../BinaryBuffer.types";
 export declare function DetermineSubByteArrayForBinaryBuffer(paletteSize: number): BinaryBufferFormat | null;
 export declare function GetConvertedBinaryBufferSize(source: Uint8Array | Uint16Array, format: BinaryBufferFormat): number;
 export declare function GetBinaryBufferIndexLength(source: Uint8Array | Uint16Array, format: BinaryBufferFormat): number;
-export declare function ConvertBinaryBuffer(source: Uint8Array | Uint16Array, sourceType: BinaryBufferFormat, destinationType: BinaryBufferFormat): Uint8Array<ArrayBuffer> | Uint16Array<ArrayBuffer>;
+export declare function ConvertBinaryBuffer(source: Uint8Array | Uint16Array, sourceType: BinaryBufferFormat, destinationType: BinaryBufferFormat): Uint16Array<ArrayBuffer> | Uint8Array<ArrayBuffer>;

package/Util/TickInterval.d.ts

@@ -1,5 +1,6 @@
 /** # Tick Interval
  * Creates a predictable tick interval.
+ * Uses requestAnimationFrame when available, falling back to setTimeout.
  */
 export declare class TickInterval {
     stopOnError: boolean;
@@ -7,6 +8,8 @@ export declare class TickInterval {
     private interval;
     private currentTimeout;
     private __timeoutFunc;
+    private _useAnimationFrame;
+    private _lastTick;
     constructor(run?: () => void | Promise<void>, interval?: number, stopOnError?: boolean);
     setOnRun(run: () => void | Promise<void>): this;
     setInterval(interval: number): this;

package/Util/TickInterval.js

@@ -1,5 +1,6 @@
 /** # Tick Interval
  * Creates a predictable tick interval.
+ * Uses requestAnimationFrame when available, falling back to setTimeout.
  */
 export class TickInterval {
     stopOnError;
@@ -7,8 +8,11 @@ export class TickInterval {
     interval = 1;
     currentTimeout;
     __timeoutFunc;
+    _useAnimationFrame;
+    _lastTick = 0;
     constructor(run, interval, stopOnError = true) {
         this.stopOnError = stopOnError;
+        this._useAnimationFrame = typeof requestAnimationFrame !== "undefined";
         if (run)
             this.setOnRun(run);
         if (interval !== undefined)
@@ -30,19 +34,43 @@ export class TickInterval {
     runInterval() {
         if (!this._active)
             return;
-        this.currentTimeout = setTimeout(this.__timeoutFunc, this.interval);
+        if (this._useAnimationFrame) {
+            this.currentTimeout = requestAnimationFrame((timestamp) => {
+                if (!this._active)
+                    return;
+                // Only fire once enough time has elapsed, matching the requested interval.
+                if (timestamp - this._lastTick >= this.interval) {
+                    this._lastTick = timestamp;
+                    this.__timeoutFunc();
+                }
+                else {
+                    // Not time yet — re-queue without calling the callback.
+                    this.runInterval();
+                }
+            });
+        }
+        else {
+            this.currentTimeout = setTimeout(this.__timeoutFunc, this.interval);
+        }
     }
     start() {
         if (!this._active) {
             this._active = true;
+            this._lastTick = 0;
             this.runInterval();
         }
         return this;
     }
     stop() {
         this._active = false;
-        if (this.currentTimeout !== undefined)
-            clearTimeout(this.currentTimeout);
+        if (this.currentTimeout !== undefined) {
+            if (this._useAnimationFrame) {
+                cancelAnimationFrame(this.currentTimeout);
+            }
+            else {
+                clearTimeout(this.currentTimeout);
+            }
+        }
         this.currentTimeout = undefined;
         return this;
     }

package/Voxels/Archive/VoxelPaletteArchiveReader.d.ts

@@ -1,6 +1,7 @@
 import { BinarySchema } from "../State/Schema/BinarySchema";
 import { ArchivedVoxelDataForPalette, VoxelArchivePaletteData } from "./VoxelArchive.types";
 export declare class VoxelPaletteArchiveReader {
+    temp: [id: string, state: number, mod: number];
     voxelPalette: Uint16Array;
     _voxels: ArchivedVoxelDataForPalette[];
     _voxelStateSchema: Map<string, BinarySchema>;