@divinevoxel/vlox 0.0.72 → 0.0.74

package/Textures/TextureManager.js

@@ -1,174 +1,36 @@
-import { EngineSettings } from "../Settings/EngineSettings.js";
-import { TextureBuilder } from "./TextureBuilder.js";
-import { TextureArray } from "./TextureArray.js";
-import { TextureRegister } from "./TextureRegister.js";
+import { BuildTextureData, } from "./Functions/BuildTextureData.js";
+const missingTexture = {
+    id: "dve_missing",
+    base64: "data:image/png;base64,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",
+};
 export class TextureManager {
-    static defaultTexturePath = "assets/textures";
-    static textureTypes = new Map();
-    static getTextureIndex(data) {
-        const [textureType, textureId, varation] = data;
-        const type = this.getTextureType(textureType);
-        if (!type)
-            return NaN;
-        return type.getTextureIndex(textureId, varation);
-    }
-    static _ready = false;
-    static isReady() {
-        return this._ready;
-    }
-    static async init() {
-        TextureBuilder.defineTextureDimensions(EngineSettings.settings.textures.textureSize);
-        for (const [key, type] of this.textureTypes) {
-            await type.build();
-        }
-        TextureRegister.setTextureIndex(this.generateTextureUVMap());
-        this._ready = true;
-    }
-    static generateTextureUVMap() {
-        const uvMap = {};
-        for (const [key, type] of this.textureTypes) {
-            uvMap[key] = type.getTextureIndexMap();
-        }
-        return uvMap;
-    }
-    static defineDefaultTexturePath(path) {
-        this.defaultTexturePath = path;
-    }
-    static getTextureData([type, id, segment]) {
-        const t = this.getTextureType(type);
-        if (!t)
-            return undefined;
-        return t.textureMap.get(id);
-    }
-    static getTextureType(id) {
-        const texture = this.textureTypes.get(id);
-        if (!texture)
-            return false;
-        return texture;
-    }
-    static getOrAddTextureType(id) {
-        const texture = this.textureTypes.get(id);
-        if (!texture)
-            return this.addTextureType(id);
-        return texture;
-    }
-    static addTextureType(id) {
-        const newType = new TextureArray(id);
-        this.textureTypes.set(id, newType);
-        return newType;
-    }
-    static clearTextureData() {
-        //
-        //  this.textureTypes.forEach((_) => _.clearSegmentData());
-    }
+    static _textureTypes = new Map();
+    static _compiledTextures = new Map();
     static registerTexture(textureData) {
-        if (Array.isArray(textureData)) {
-            for (const texture of textureData) {
-                const type = this.getOrAddTextureType(texture.type);
-                if (!type)
-                    continue;
-                type.addTexture(texture);
-                continue;
-            }
-            return;
-        }
-        const type = this.getOrAddTextureType(textureData.type);
-        if (!type)
-            return;
-        type.addTexture(textureData);
-    }
-    static getTexturePath(textureType, id, varation, segment = "main", frames) {
-        const data = this.getTextureData([textureType, id, segment]);
-        if (!data)
-            throw new Error(`Could not find data for ${textureType} ${id} ${varation}`);
-        let path = data.base64 &&
-            (Array.isArray(data.base64) ? data.base64[0] : data.base64);
-        if (path)
-            return path;
-        const type = this.textureTypes.get(textureType);
-        return type._getPath(data, varation, type.extension);
-    }
-    static async createCached() {
-        const cachedTextureData = [];
-        for (const [typeKey, type] of this.textureTypes) {
-            for (const baseData of type.textures) {
-                const data = structuredClone(baseData);
-                const id = baseData.id;
-                if (data.frames) {
-                    const images = [];
-                    for (let i = 1; i <= data.frames; i++) {
-                        images.push(await TextureBuilder.getBase64(type._getPath(data, `${id}-${i}`, type.extension)));
-                    }
-                    data.base64 = images;
-                }
-                else {
-                    data.base64 = await TextureBuilder.getBase64(type._getPath(data, "default", type.extension));
-                }
-                if (data.variations) {
-                    for (const varId in data.variations) {
-                        const varation = data.variations[varId];
-                        if (varation.frames) {
-                            const images = [];
-                            for (let i = 1; i <= varation.frames; i++) {
-                                images.push(await TextureBuilder.getBase64(type._getPath(data, `${varId}-${i}`, type.extension)));
-                            }
-                            varation.base64 = images;
-                        }
-                        else {
-                            varation.base64 = await TextureBuilder.getBase64(type._getPath(data, varId, type.extension));
-                        }
-                    }
-                }
-                cachedTextureData.push(data);
+        for (const texture of textureData) {
+            const typeId = texture.type || "dve_voxel";
+            let type = this._textureTypes.get(typeId);
+            if (!type) {
+                type = [missingTexture];
+                this._textureTypes.set(typeId, type);
             }
+            type.push(texture);
         }
-        return cachedTextureData;
     }
-    static async createRawDataMap() {
-        const map = new Map();
-        for (const [typeKey, type] of this.textureTypes) {
-            for (const data of type.textures) {
-                if (!data.includeInRawDataMap)
-                    continue;
-                if (!data.path && !data.rawData)
-                    continue;
-                const key = `${type.id}|${data.id}|default`;
-                if (data.frames) {
-                    for (let i = 1; i <= data.frames; i++) {
-                        const rawData = await TextureBuilder.getRawData(type._getPath(data, `${key}-${i}`, type.extension));
-                        data.rawData = rawData;
-                        map.set(`${key}-${i}`, rawData);
-                    }
-                }
-                else {
-                    const rawData = await TextureBuilder.getRawData(type._getPath(data, "default", type.extension));
-                    data.rawData = rawData;
-                    map.set(key, rawData);
-                }
-                if (data.variations) {
-                    for (const varId in data.variations) {
-                        const varation = data.variations[varId];
-                        if (!varation.includeInRawDataMap)
-                            continue;
-                        const key = `${type.id}|${data.id}|${varId}`;
-                        if (data.frames) {
-                            for (let i = 1; i <= data.frames; i++) {
-                                const rawData = await TextureBuilder.getRawData(type._getPath(data, `${key}-${i}`, type.extension));
-                                data.rawData = rawData;
-                                map.set(`${key}-${i}`, rawData);
-                            }
-                        }
-                        else {
-                            const rawData = await TextureBuilder.getRawData(type._getPath(data, varId, type.extension));
-                            data.rawData = rawData;
-                            map.set(key, rawData);
-                        }
-                    }
-                }
-            }
+    static getTexture(id) {
+        const type = this._compiledTextures.get(id);
+        if (!type)
+            throw new Error(`Compiled texture with id ${id} does not exist`);
+        return type;
+    }
+    static async compiledTextures(props = {}) {
+        for (const [type, data] of this._textureTypes) {
+            const compiled = await BuildTextureData({
+                type,
+                textures: data,
+                ...props,
+            });
+            this._compiledTextures.set(type, compiled);
         }
-        return map;
     }
 }
-TextureManager.getOrAddTextureType("dve_voxel");
-TextureManager.getOrAddTextureType("dve_node");

package/Tools/Brush/AdvancedBrushTool.js

@@ -1,7 +1,7 @@
 import { BrushTool } from "./Brush.js";
 export class AdvancedBrush extends BrushTool {
     tasks;
-    _location = ["main", 0, 0, 0];
+    _location = [0, 0, 0, 0];
     constructor(tasks) {
         super();
         this.tasks = tasks;

package/Tools/Brush/Brush.d.ts

@@ -3,11 +3,10 @@ import { WorldCursor } from "../../World/Cursor/WorldCursor.js";
 import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor.js";
 export declare class BrushTool {
     data: PaintVoxelData;
-    dimension: string;
+    dimension: number;
     x: number;
     y: number;
     z: number;
-    name: string;
     voxelCursor: VoxelCursor;
     dataCursor: WorldCursor;
     setXYZ(x: number, y: number, z: number): this;
@@ -19,6 +18,7 @@ export declare class BrushTool {
     setId(id: string): this;
     setName(name: string): this;
     setSecondaryId(id: string): this;
+    setSecondaryName(name: string): this;
     setShapeState(state: number): this;
     setLevel(level: number): this;
     setLevelState(levelState: number): this;
@@ -29,6 +29,6 @@ export declare class BrushTool {
     _erase(): void;
     paint(): this;
     erase(): this;
-    start(dimension: string, x: number, y: number, z: number): this;
+    start(dimension: number, x: number, y: number, z: number): this;
     stop(): this;
 }

package/Tools/Brush/Brush.js

@@ -7,17 +7,18 @@ const air = [0, 0, 0, 0, 0, 0];
 export class BrushTool {
     data = {
         id: airId,
+        name: "",
         state: 0,
         secondaryVoxelId: "",
+        secondaryVoxeName: "",
         level: 0,
         levelState: 0,
         mod: 0,
     };
-    dimension = "main";
+    dimension = 0;
     x = 0;
     y = 0;
     z = 0;
-    name = airId;
     voxelCursor = new VoxelCursor();
     dataCursor = new WorldCursor();
     setXYZ(x, y, z) {
@@ -30,11 +31,22 @@ export class BrushTool {
         WorldRegister.sectors.new(this.dimension, this.x, this.y, this.z);
     }
     setData(data) {
-        this.data.id = data.id ? data.id : airId;
+        this.clear();
+        if (data.name) {
+            this.setName(data.name);
+        }
+        else {
+            if (data.id)
+                this.setId(data.id);
+        }
+        if (data.secondaryVoxeName) {
+            this.setSecondaryName(data.secondaryVoxeName);
+        }
+        else {
+            if (data.secondaryVoxelId)
+                this.setSecondaryId(data.secondaryVoxelId);
+        }
         this.data.state = data.state ? data.state : 0;
-        this.data.secondaryVoxelId = data.secondaryVoxelId
-            ? data.secondaryVoxelId
-            : airId;
         this.data.level = data.level ? data.level : 0;
         this.data.levelState = data.levelState ? data.levelState : 0;
         this.data.mod = data.mod ? data.mod : 0;
@@ -62,15 +74,34 @@ export class BrushTool {
     }
     setId(id) {
         this.data.id = id;
+        this.data.name = VoxelPalettesRegister.voxelIdToNameMap.get(id);
         return this;
     }
     setName(name) {
-        this.data.id = VoxelPalettesRegister.voxelName.getId(name);
-        this.name = name;
+        this.data.id = VoxelPalettesRegister.voxelNametoIdMap.get(name);
+        this.data.name = name;
         return this;
     }
     setSecondaryId(id) {
         this.data.secondaryVoxelId = id;
+        if (id) {
+            this.data.secondaryVoxeName =
+                VoxelPalettesRegister.voxelIdToNameMap.get(id);
+        }
+        else {
+            this.data.secondaryVoxeName = "";
+        }
+        return this;
+    }
+    setSecondaryName(name) {
+        if (name) {
+            this.data.secondaryVoxelId =
+                VoxelPalettesRegister.voxelNametoIdMap.get(name);
+        }
+        else {
+            this.data.secondaryVoxelId = "";
+        }
+        this.data.secondaryVoxeName = name;
         return this;
     }
     setShapeState(state) {
@@ -91,6 +122,7 @@ export class BrushTool {
     }
     clear() {
         this.data.id = "dve_air";
+        this.data.name = "";
         this.data.secondaryVoxelId = "";
         this.data.level = 0;
         this.data.levelState = 0;

package/Tools/Tasks/TasksTool.d.ts

@@ -24,6 +24,7 @@ declare class VoxelTasks {
     update: TaskToolTask<VoxelUpdateTasks>;
     paint: TaskToolTask<VoxelUpdateTasks>;
     erease: TaskToolTask<LocationData>;
+    logic: TaskToolTask<LocationData>;
     constructor(tool: TaskTool);
 }
 declare class BuildTask {

package/Tools/Tasks/TasksTool.js

@@ -62,11 +62,13 @@ class VoxelTasks {
     update;
     paint;
     erease;
+    logic;
     constructor(tool) {
         this.tool = tool;
         this.update = new TaskToolTask(TasksIds.VoxelUpdate, tool.threads);
         this.paint = new TaskToolTask(TasksIds.VoxelPaint, tool.threads);
         this.erease = new TaskToolTask(TasksIds.VoxelErease, tool.threads);
+        this.logic = new TaskToolTask(TasksIds.LogicUpdate, tool.threads);
     }
 }
 class BuildTask {

package/Util/Binary/BinaryArrays.d.ts

@@ -0,0 +1,6 @@
+export declare function getBitArrayIndex(data: Uint8Array, arrayIndex: number): number;
+export declare function setBitArrayIndex(data: Uint8Array, arrayIndex: number, value: number): void;
+export declare function getNibbleArrayIndex(data: Uint8Array, arrayIndex: number): number;
+export declare function setNibbleArrayIndex(data: Uint8Array, arrayIndex: number, value: number): void;
+export declare function getHalfNibbleArrayIndex(data: Uint8Array, arrayIndex: number): number;
+export declare function setHalfNibbleArrayIndex(data: Uint8Array, arrayIndex: number, value: number): void;

package/Util/Binary/BinaryArrays.js

@@ -0,0 +1,25 @@
+import { getBitValue, setBitValue } from "./BinaryFunctions";
+export function getBitArrayIndex(data, arrayIndex) {
+    const arrayByteIndex = Math.floor(arrayIndex / 8);
+    const bitPosition = arrayIndex % 8;
+    return getBitValue(data[arrayByteIndex], bitPosition, 1);
+}
+export function setBitArrayIndex(data, arrayIndex, value) {
+    const arrayByteIndex = Math.floor(arrayIndex / 8);
+    const bitPosition = arrayIndex % 8;
+    data[arrayByteIndex] = setBitValue(data[arrayByteIndex], bitPosition, value & 1, 1);
+}
+export function getNibbleArrayIndex(data, arrayIndex) {
+    return getBitValue(data[(arrayIndex / 2) >> 0], arrayIndex % 2 === 0 ? 4 : 0, 4);
+}
+export function setNibbleArrayIndex(data, arrayIndex, value) {
+    const arrayByteIndex = (arrayIndex / 2) >> 0;
+    data[arrayByteIndex] = setBitValue(data[arrayByteIndex], arrayIndex % 2 === 0 ? 4 : 0, value, 4);
+}
+export function getHalfNibbleArrayIndex(data, arrayIndex) {
+    return getBitValue(data[(arrayIndex / 4) >> 0], (arrayIndex % 4) * 2, 2);
+}
+export function setHalfNibbleArrayIndex(data, arrayIndex, value) {
+    const arrayByteIndex = (arrayIndex / 4) >> 0;
+    data[arrayByteIndex] = setBitValue(data[arrayByteIndex], (arrayIndex % 4) * 2, value, 2);
+}

package/Util/Binary/BinaryBuffer.d.ts

@@ -0,0 +1,35 @@
+export declare enum BinaryBufferTypes {
+    Value = 0,
+    BitArray = 1,
+    HalfNibbleArray = 2,
+    NibbleArray = 4,
+    ByteArray = 8,
+    ShortArray = 16
+}
+export interface BinaryBufferData {
+    type: BinaryBufferTypes;
+    buffer: number | ArrayBufferLike;
+}
+export interface BinaryBuffer extends BinaryBufferData {
+}
+export declare class BinaryBuffer {
+    static ByteArrayMax: number;
+    static NibbleArrayMax: number;
+    static HalfNibbleArrayMax: number;
+    static BitArrayMax: number;
+    static DetermineSubByteArray: (paletteSize: number) => BinaryBufferTypes | null;
+    static CreateBufferForType(type: BinaryBufferTypes, length: number): Uint16Array | Uint8Array;
+    static GetConvertedBufferSize(source: Uint8Array | Uint16Array, type: BinaryBufferTypes): number;
+    static GetIndexLength(source: Uint8Array | Uint16Array, type: BinaryBufferTypes): number;
+    static ReadBufferAtIndex(source: Uint8Array | Uint16Array, type: BinaryBufferTypes, index: number): number;
+    static SetBufferAtIndex(source: Uint8Array | Uint16Array, type: BinaryBufferTypes, index: number, value: number): number | void;
+    static Convert(source: Uint8Array | Uint16Array, sourceType: BinaryBufferTypes, destinationType: BinaryBufferTypes): Uint16Array | Uint8Array;
+    static Create(data: Partial<BinaryBufferData>): BinaryBufferData;
+    bufferView: Uint8Array | Uint16Array;
+    constructor(data: BinaryBufferData);
+    getValue(index: number): number;
+    toJSON(): {
+        buffer: number | ArrayBufferLike;
+        type: BinaryBufferTypes;
+    };
+}

package/Util/Binary/BinaryBuffer.js

@@ -0,0 +1,136 @@
+import { getBitArrayIndex, getHalfNibbleArrayIndex, getNibbleArrayIndex, setBitArrayIndex, setHalfNibbleArrayIndex, setNibbleArrayIndex, } from "./BinaryArrays";
+export var BinaryBufferTypes;
+(function (BinaryBufferTypes) {
+    BinaryBufferTypes[BinaryBufferTypes["Value"] = 0] = "Value";
+    BinaryBufferTypes[BinaryBufferTypes["BitArray"] = 1] = "BitArray";
+    BinaryBufferTypes[BinaryBufferTypes["HalfNibbleArray"] = 2] = "HalfNibbleArray";
+    BinaryBufferTypes[BinaryBufferTypes["NibbleArray"] = 4] = "NibbleArray";
+    BinaryBufferTypes[BinaryBufferTypes["ByteArray"] = 8] = "ByteArray";
+    BinaryBufferTypes[BinaryBufferTypes["ShortArray"] = 16] = "ShortArray";
+})(BinaryBufferTypes || (BinaryBufferTypes = {}));
+export class BinaryBuffer {
+    static ByteArrayMax = 256;
+    static NibbleArrayMax = 16;
+    static HalfNibbleArrayMax = 4;
+    static BitArrayMax = 2;
+    static DetermineSubByteArray = (paletteSize) => {
+        if (paletteSize == BinaryBuffer.BitArrayMax)
+            return BinaryBufferTypes.BitArray;
+        if (paletteSize > BinaryBuffer.BitArrayMax &&
+            paletteSize <= BinaryBuffer.HalfNibbleArrayMax)
+            return BinaryBufferTypes.HalfNibbleArray;
+        if (paletteSize > BinaryBuffer.HalfNibbleArrayMax &&
+            paletteSize <= BinaryBuffer.NibbleArrayMax)
+            return BinaryBufferTypes.NibbleArray;
+        if (paletteSize > BinaryBuffer.NibbleArrayMax &&
+            paletteSize <= BinaryBuffer.ByteArrayMax)
+            return BinaryBufferTypes.ByteArray;
+        return null;
+    };
+    static CreateBufferForType(type, length) {
+        if (type == BinaryBufferTypes.ShortArray)
+            return new Uint16Array(length);
+        return new Uint8Array(length);
+    }
+    static GetConvertedBufferSize(source, type) {
+        if (type == BinaryBufferTypes.ShortArray ||
+            type == BinaryBufferTypes.ByteArray)
+            return source.length;
+        if (type == BinaryBufferTypes.BitArray)
+            return source.length / 8;
+        if (type == BinaryBufferTypes.HalfNibbleArray)
+            return source.length / 4;
+        if (type == BinaryBufferTypes.NibbleArray)
+            return source.length / 2;
+        if (type == BinaryBufferTypes.Value)
+            return 1;
+        return source.length;
+    }
+    static GetIndexLength(source, type) {
+        if (type == BinaryBufferTypes.ShortArray ||
+            type == BinaryBufferTypes.ByteArray)
+            return source.length;
+        if (type == BinaryBufferTypes.BitArray)
+            return source.length * 8;
+        if (type == BinaryBufferTypes.HalfNibbleArray)
+            return source.length * 4;
+        if (type == BinaryBufferTypes.NibbleArray)
+            return source.length * 2;
+        if (type == BinaryBufferTypes.Value)
+            return 1;
+        return source.length;
+    }
+    static ReadBufferAtIndex(source, type, index) {
+        if (type == BinaryBufferTypes.ShortArray ||
+            type == BinaryBufferTypes.ByteArray)
+            return source[index];
+        if (type == BinaryBufferTypes.BitArray)
+            return getBitArrayIndex(source, index);
+        if (type == BinaryBufferTypes.NibbleArray)
+            return getNibbleArrayIndex(source, index);
+        if (type == BinaryBufferTypes.HalfNibbleArray)
+            return getHalfNibbleArrayIndex(source, index);
+        return source[index];
+    }
+    static SetBufferAtIndex(source, type, index, value) {
+        if (type == BinaryBufferTypes.ShortArray ||
+            type == BinaryBufferTypes.ByteArray) {
+            return (source[index] = value);
+        }
+        if (type == BinaryBufferTypes.BitArray)
+            return setBitArrayIndex(source, index, value);
+        if (type == BinaryBufferTypes.NibbleArray)
+            return setNibbleArrayIndex(source, index, value);
+        if (type == BinaryBufferTypes.HalfNibbleArray)
+            return setHalfNibbleArrayIndex(source, index, value);
+        return source[index];
+    }
+    static Convert(source, sourceType, destinationType) {
+        if (sourceType == destinationType ||
+            (sourceType == BinaryBufferTypes.ShortArray &&
+                destinationType == BinaryBufferTypes.ByteArray) ||
+            (sourceType == BinaryBufferTypes.ByteArray &&
+                destinationType == BinaryBufferTypes.ShortArray)) {
+            const destination = this.CreateBufferForType(destinationType, this.GetConvertedBufferSize(source, destinationType));
+            destination.set(source);
+            return destination;
+        }
+        const length = this.GetIndexLength(source, sourceType);
+        const destination = this.CreateBufferForType(destinationType, this.GetConvertedBufferSize(source, destinationType));
+        for (let i = 0; i < length; i++) {
+            this.SetBufferAtIndex(destination, destinationType, i, this.ReadBufferAtIndex(source, sourceType, i));
+        }
+        return destination;
+    }
+    static Create(data) {
+        return {
+            buffer: 0,
+            type: BinaryBufferTypes.Value,
+            ...data,
+        };
+    }
+    bufferView;
+    constructor(data) {
+        this.buffer = data.buffer;
+        this.type = data.type;
+        if (typeof this.buffer !== "number") {
+            if (this.type == BinaryBufferTypes.ShortArray) {
+                this.bufferView = new Uint16Array(this.buffer);
+            }
+            else {
+                this.bufferView = new Uint8Array(this.buffer);
+            }
+        }
+    }
+    getValue(index) {
+        if (typeof this.buffer == "number")
+            return this.buffer;
+        return BinaryBuffer.ReadBufferAtIndex(this.bufferView, this.type, index);
+    }
+    toJSON() {
+        return {
+            buffer: this.buffer,
+            type: this.type,
+        };
+    }
+}

package/Util/Binary/{BitArray.d.ts → BinaryFunctions.d.ts}

@@ -1,4 +1,3 @@
 export declare function getBitValue(data: number, bitIndex: number, bitSize: number): number;
 export declare function setBitValue(data: number, bitIndex: number, value: number, bitSize: number): number;
-export declare function getBitArrayIndex(data: Uint8Array, arrayIndex: number): number;
-export declare function setBitArrayIndex(data: Uint8Array, arrayIndex: number, value: number): void;
+export declare function forceMultipleOf2(n: number): number;

package/Util/Binary/BinaryFunctions.js

@@ -0,0 +1,11 @@
+export function getBitValue(data, bitIndex, bitSize) {
+    const mask = (1 << bitSize) - 1;
+    return (data >>> bitIndex) & mask;
+}
+export function setBitValue(data, bitIndex, value, bitSize) {
+    const mask = (1 << bitSize) - 1;
+    return (data & ~(mask << bitIndex)) | ((value & mask) << bitIndex);
+}
+export function forceMultipleOf2(n) {
+    return n % 2 === 0 ? n : n + 1;
+}

package/{Mesher/Tools/VoxelMeshBVHBuilder.d.ts → Util/Binary/BinaryTree.d.ts}

@@ -1,7 +1,7 @@
 /**
  * A class to help with indexing a full flat binary tree defined by the number of levels it has.
  */
-declare class FlatBinaryTreeIndex {
+export declare class FlatBinaryTreeIndex {
     levels: number;
     constructor(levels: number);
     /** Gets the number of nodes at a level of the tree */
@@ -44,35 +44,3 @@ declare class FlatBinaryTreeIndex {
     /** Gets the total number of nodes in the tree */
     getTotalSize(): number;
 }
-export declare class StructCursor {
-    data: Float32Array;
-    get minX(): number;
-    get minY(): number;
-    get minZ(): number;
-    get maxX(): number;
-    get maxY(): number;
-    get maxZ(): number;
-    get voxelIndex(): number;
-    get active(): number;
-    get nodeType(): number;
-    trueIndex: number;
-    private index;
-    setIndex(index: number): void;
-    constructor(data: Float32Array);
-    setActive(): void;
-    setVoxelIndex(value: number): void;
-    setInnerNode(): void;
-    setGeomtryNode(): void;
-    updateMin(x: number, y: number, z: number): void;
-    updateMax(x: number, y: number, z: number): void;
-}
-export declare class VoxelMeshBVHBuilder {
-    static AABBStructByteSize: number;
-    treeIndex: FlatBinaryTreeIndex;
-    tree: Float32Array;
-    structCursor: StructCursor;
-    indices: Uint32Array;
-    reset(): void;
-    updateVoxel(voxelX: number, voxelY: number, voxelZ: number, meshIndex: number, indicesStart: number, indicesEnd: number, minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number): void;
-}
-export {};