@divinevoxel/vlox 0.0.7 → 0.0.72

package/Mesher/Models/Nodes/Ruleless/RulelessQuadVoxelGeometryNode.d.ts

@@ -1,9 +1,7 @@
-import { Vec3Array, Vec4Array, Vector3Like } from "@amodx/math";
+import { Vec3Array, Vec4Array } from "@amodx/math";
 import { VoxelFaces } from "../../../../Math";
-import { QuadScalarVertexData } from "../../../Geomtry/Primitives/QuadVertexData";
 import { VoxelQuadGeometryNode } from "../../../../Models/VoxelModel.types";
 import { Quad } from "../../../Geomtry/Primitives/Quad";
-import { VoxelMesherDataTool } from "../../../../Mesher/Tools/VoxelMesherDataTool";
 import { QuadVoxelGometryArgs } from "../../../../Models/Input/QuadVoxelGometryInputs";
 import { GeoemtryNode } from "../GeometryNode";
 import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
@@ -11,12 +9,10 @@ export declare class RulelessQuadVoxelGeometryNode extends GeoemtryNode<VoxelQua
     quad: Quad;
     quadBounds: [Vec3Array, Vec3Array];
     vertexWeights: [Vec4Array, Vec4Array, Vec4Array, Vec4Array];
-    worldLight: QuadScalarVertexData;
-    worldAO: QuadScalarVertexData;
     closestFace: VoxelFaces;
     lightData: VoxelLightData;
     init(): void;
     determineShading(): void;
     shouldFlip(): boolean;
-    add(tool: VoxelMesherDataTool, originHash: number, origin: Vector3Like, args: QuadVoxelGometryArgs): void;
+    add(args: QuadVoxelGometryArgs): boolean;
 }

package/Mesher/Models/Nodes/Ruleless/RulelessQuadVoxelGeometryNode.js

@@ -4,7 +4,6 @@ import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcC
 import { QuadVoxelGometryInputs, } from "../../../../Models/Input/QuadVoxelGometryInputs";
 import { GeoemtryNode } from "../GeometryNode";
 import { GetQuadGeometryData } from "../../Common/QuadGeometryNode";
-import { UpdateBounds } from "../../Common/BoundsFunctions";
 import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
 const ArgIndexes = QuadVoxelGometryInputs.ArgIndexes;
 export class RulelessQuadVoxelGeometryNode extends GeoemtryNode {
@@ -14,8 +13,6 @@ export class RulelessQuadVoxelGeometryNode extends GeoemtryNode {
         [0, 0, 0],
     ];
     vertexWeights;
-    worldLight;
-    worldAO;
     closestFace;
     lightData = new VoxelLightData();
     init() {
@@ -28,11 +25,11 @@ export class RulelessQuadVoxelGeometryNode extends GeoemtryNode {
         this.closestFace = closestFace;
     }
     determineShading() {
-        const tool = this.tool;
+        const tool = this.builder;
         const lightData = tool.lightData[VoxelFaces.Up];
-        const noAO = this.tool.voxel.isLightSource() || this.tool.voxel.noAO();
-        const worldLight = this.worldLight;
-        const worldAO = this.worldAO;
+        const noAO = this.builder.voxel.isLightSource() || this.builder.voxel.noAO();
+        const worldLight = this.builder.vars.light;
+        const worldAO = this.builder.vars.ao;
         for (let v = 0; v < 4; v++) {
             worldAO.vertices[v] = 0;
             worldLight.vertices[v] = getInterpolationValue(lightData, this.vertexWeights[v]);
@@ -41,40 +38,40 @@ export class RulelessQuadVoxelGeometryNode extends GeoemtryNode {
         }
     }
     shouldFlip() {
-        if (shouldCauseFlip(this.worldAO.vertices[0], this.worldAO.vertices[1], this.worldAO.vertices[2], this.worldAO.vertices[3]))
+        const worldLight = this.builder.vars.light;
+        const worldAO = this.builder.vars.ao;
+        if (shouldCauseFlip(worldAO.vertices[0], worldAO.vertices[1], worldAO.vertices[2], worldAO.vertices[3]))
             return true;
-        return (shouldCauseFlip(this.lightData.getS(this.worldLight.vertices[0]), this.lightData.getS(this.worldLight.vertices[1]), this.lightData.getS(this.worldLight.vertices[2]), this.lightData.getS(this.worldLight.vertices[3])) ||
-            shouldCauseFlip(this.lightData.sumRGB(this.worldLight.vertices[0]), this.lightData.sumRGB(this.worldLight.vertices[1]), this.lightData.sumRGB(this.worldLight.vertices[2]), this.lightData.sumRGB(this.worldLight.vertices[3])));
+        return (shouldCauseFlip(this.lightData.getS(worldLight.vertices[0]), this.lightData.getS(worldLight.vertices[1]), this.lightData.getS(worldLight.vertices[2]), this.lightData.getS(worldLight.vertices[3])) ||
+            shouldCauseFlip(this.lightData.sumRGB(worldLight.vertices[0]), this.lightData.sumRGB(worldLight.vertices[1]), this.lightData.sumRGB(worldLight.vertices[2]), this.lightData.sumRGB(worldLight.vertices[3])));
     }
-    add(tool, originHash, origin, args) {
-        this.tool = tool;
-        this.origin = tool.position;
-        this.worldAO = tool.vars.ao;
-        this.worldLight = tool.vars.light;
-        if (args[ArgIndexes.Enabled]) {
-            tool.calculateFaceData(this.closestFace);
-            this.determineShading();
-            const quad = this.quad;
-            quad.flip = this.shouldFlip() || args[ArgIndexes.Fliped];
-            tool.vars.textureIndex = args[ArgIndexes.Texture];
-            quad.doubleSided = args[ArgIndexes.DoubleSided];
-            const uvs = args[ArgIndexes.UVs];
-            //1
-            quad.uvs.vertices[0].x = uvs[0][0];
-            quad.uvs.vertices[0].y = uvs[0][1];
-            //2
-            quad.uvs.vertices[1].x = uvs[1][0];
-            quad.uvs.vertices[1].y = uvs[1][1];
-            //3
-            quad.uvs.vertices[2].x = uvs[2][0];
-            quad.uvs.vertices[2].y = uvs[2][1];
-            //4
-            quad.uvs.vertices[3].x = uvs[3][0];
-            quad.uvs.vertices[3].y = uvs[3][1];
-            VoxelGeometryBuilder.addQuad(tool, origin, quad);
-            UpdateBounds(tool, origin, this.quadBounds);
-        }
-        this.worldLight.setAll(0);
-        this.worldAO.setAll(0);
+    add(args) {
+        if (!args[ArgIndexes.Enabled])
+            return false;
+        const tool = this.builder;
+        tool.calculateFaceData(this.closestFace);
+        this.determineShading();
+        const quad = this.quad;
+        quad.flip = this.shouldFlip() || args[ArgIndexes.Fliped];
+        tool.vars.textureIndex = args[ArgIndexes.Texture];
+        quad.doubleSided = args[ArgIndexes.DoubleSided];
+        const uvs = args[ArgIndexes.UVs];
+        //1
+        quad.uvs.vertices[0].x = uvs[0][0];
+        quad.uvs.vertices[0].y = uvs[0][1];
+        //2
+        quad.uvs.vertices[1].x = uvs[1][0];
+        quad.uvs.vertices[1].y = uvs[1][1];
+        //3
+        quad.uvs.vertices[2].x = uvs[2][0];
+        quad.uvs.vertices[2].y = uvs[2][1];
+        //4
+        quad.uvs.vertices[3].x = uvs[3][0];
+        quad.uvs.vertices[3].y = uvs[3][1];
+        VoxelGeometryBuilder.addQuad(tool, tool.position, quad);
+        this.builder.updateBounds(this.quadBounds);
+        this.builder.vars.light.setAll(0);
+        this.builder.vars.ao.setAll(0);
+        return true;
     }
 }

package/Mesher/Models/VoxelConstructor.d.ts

@@ -1,4 +1,3 @@
-import { TextureRegister } from "../../Textures/TextureRegister";
 import { VoxelMesherDataTool } from "../../Mesher/Tools/VoxelMesherDataTool";
 import { CompiledVoxelModelInputData, CompiledVoxelModelData } from "../../Voxels/Types/VoxelModelCompiledData.types";
 import { StateSchema } from "../../Voxels/State/Schema/StateSchema";
@@ -8,6 +7,7 @@ import { VoxelModelEffect } from "./VoxelModelEffect";
 import { CondtionalTreeReader } from "../../Voxels/State/CondiotnalTreeReader";
 export declare class VoxelConstructor {
     id: string;
+    builder: VoxelMesherDataTool;
     data: CompiledVoxelModelData;
     isModel: true;
     geometries: number[][];
@@ -20,9 +20,8 @@ export declare class VoxelConstructor {
     effects: VoxelModelEffect;
     shapeStateTree: StateTreeReader;
     condtioanlShapeStateTree: CondtionalTreeReader;
-    constructor(id: string, data: CompiledVoxelModelData, voxleData: CompiledVoxelModelInputData);
+    constructor(id: string, builder: VoxelMesherDataTool, data: CompiledVoxelModelData, voxleData: CompiledVoxelModelInputData);
     isShapeStateFaceTransparent(modState: number, shapeState: number, geoId: number, faceIndex: number): boolean;
     isCondtionalStateFaceTransparent(modState: number, shapeState: number, geoId: number, faceIndex: number): boolean;
-    process(tool: VoxelMesherDataTool): void;
-    onTexturesRegistered(textureManager: typeof TextureRegister): void;
+    process(): boolean;
 }

package/Mesher/Models/VoxelConstructor.js

@@ -1,5 +1,4 @@
 import { VoxelModelConstructorRegister } from "./VoxelModelConstructorRegister";
-import { VoxelGeometryLookUp } from "./VoxelGeometryLookUp";
 import { StateSchema } from "../../Voxels/State/Schema/StateSchema";
 import { StateTreeReader } from "../../Voxels/State/StateTreeReader";
 import { VoxelFaceTransparentResultsIndex } from "../../Models/Indexing/VoxelFaceTransparentResultsIndex";
@@ -7,6 +6,7 @@ import { VoxelModelEffect } from "./VoxelModelEffect";
 import { CondtionalTreeReader } from "../../Voxels/State/CondiotnalTreeReader";
 export class VoxelConstructor {
     id;
+    builder;
     data;
     isModel = true;
     geometries = [];
@@ -19,8 +19,9 @@ export class VoxelConstructor {
     effects;
     shapeStateTree;
     condtioanlShapeStateTree;
-    constructor(id, data, voxleData) {
+    constructor(id, builder, data, voxleData) {
         this.id = id;
+        this.builder = builder;
         this.data = data;
         this.baseInputMap = voxleData.baseGeometryInputMap;
         this.conditonalInputMap = voxleData.condiotnalGeometryInputMap;
@@ -38,10 +39,12 @@ export class VoxelConstructor {
     isCondtionalStateFaceTransparent(modState, shapeState, geoId, faceIndex) {
         return (this.transparentIndex.getValue(modState, this.data.relativeGeometryByteIndexMap[this.data.condiotnalShapeStateRelativeGeometryMap[shapeState][geoId]], faceIndex) == 1);
     }
-    process(tool) {
-        const hashed = VoxelGeometryLookUp.getHash(tool.nVoxel, tool.position.x, tool.position.y, tool.position.z);
-        const treeState = VoxelGeometryLookUp.space.stateCache[hashed];
-        const modState = VoxelGeometryLookUp.space.modCache[hashed];
+    process() {
+        let added = false;
+        const builder = this.builder;
+        const hashed = builder.space.getHash(builder.nVoxel, builder.position.x, builder.position.y, builder.position.z);
+        const treeState = builder.space.stateCache[hashed];
+        const modState = builder.space.modCache[hashed];
         if (treeState > -1) {
             const geoLinks = this.data.shapeStateMap[treeState];
             const geometries = this.data.shapeStateGeometryMap[treeState];
@@ -53,11 +56,15 @@ export class VoxelConstructor {
                 const geomtry = VoxelModelConstructorRegister.geometry[geometries[i]];
                 const nodesLength = geomtry.nodes.length;
                 for (let k = 0; k < nodesLength; k++) {
-                    geomtry.nodes[k].add(tool, hashed, tool.origin, geoInputs[k]);
+                    const geo = geomtry.nodes[k];
+                    geo.builder = this.builder;
+                    const addedGeo = geo.add(geoInputs[k]);
+                    if (addedGeo)
+                        added = true;
                 }
             }
         }
-        const conditonalTreeState = VoxelGeometryLookUp.space.conditonalStateCache[hashed];
+        const conditonalTreeState = builder.space.conditonalStateCache[hashed];
         if (conditonalTreeState > -1) {
             const condiotnalNodes = this.data.condiotnalShapeStateMap[conditonalTreeState];
             const condiotnalNodesLength = condiotnalNodes.length;
@@ -71,13 +78,17 @@ export class VoxelConstructor {
                     const geomtry = VoxelModelConstructorRegister.geometry[this.data.geoLinkMap[nodeId]];
                     const nodesLength = geomtry.nodes.length;
                     for (let k = 0; k < nodesLength; k++) {
-                        geomtry.nodes[k].add(tool, hashed, tool.origin, geoInputs[k]);
+                        const geo = geomtry.nodes[k];
+                        geo.builder = this.builder;
+                        const addedGeo = geo.add(geoInputs[k]);
+                        if (addedGeo)
+                            added = true;
                     }
                 }
             }
         }
-        this.effects.addEffects(tool.voxel.getState(), tool.origin, tool.effects);
-        tool.clearCalculatedData();
+        this.effects.addEffects(builder.voxel.getState(), builder.origin, builder.effects);
+        builder.clearCalculatedData();
+        return added;
     }
-    onTexturesRegistered(textureManager) { }
 }

package/Mesher/Models/{VoxelGeometryLookUp.d.ts → VoxelGeometryBuilderCacheSpace.d.ts}

@@ -1,30 +1,24 @@
-import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
+import { DataCursorInterface } from "../../Tools/DataCursor.interface";
 import { Vec3Array, Vector3Like } from "@amodx/math";
 import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
-export declare class VoxelGeometryLookUpSpace {
+export declare class VoxelGeometryBuilderCacheSpace {
     bounds: Vector3Like;
     foundHash: Uint8Array;
-    voxelHash: Uint16Array;
+    voxelCache: Uint16Array;
+    lightCache: Int32Array;
     modCache: Int32Array;
     stateCache: Int32Array;
     conditonalStateCache: Int32Array;
     noCastAO: Uint8Array;
     offset: Vec3Array;
+    voxelCursor: VoxelCursor;
     constructor(bounds: Vector3Like);
     start(x: number, y: number, z: number): void;
     getIndex(x: number, y: number, z: number): number;
     getConstructor(index: number): import("./VoxelConstructor").VoxelConstructor | null;
     getGeomtry(index: number): false | number[];
     getConditionalGeomtry(index: number): false | number[][];
-}
-export declare class VoxelGeometryLookUp {
-    static space: VoxelGeometryLookUpSpace | null;
-    static voxelCursor: VoxelCursor;
-    static createSpace(x: number, y: number, z: number): VoxelGeometryLookUpSpace;
-    static init(): void;
-    static start(space: VoxelGeometryLookUpSpace): void;
-    static isRulesless(geoId: number): boolean;
-    static stop(): void;
-    static getHash(dataCursor: DataCursorInterface, x: number, y: number, z: number): number;
-    private static hashState;
+    getHash(dataCursor: DataCursorInterface, x: number, y: number, z: number): number;
+    getLight(dataCursor: DataCursorInterface, x: number, y: number, z: number): number;
+    private hashState;
 }

package/Mesher/Models/{VoxelGeometryLookUp.js → VoxelGeometryBuilderCacheSpace.js}

@@ -1,20 +1,23 @@
 import { VoxelModelConstructorRegister } from "./VoxelModelConstructorRegister";
 import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
 import { GetYXZOrderArrayIndex } from "../../Math/Indexing";
-export class VoxelGeometryLookUpSpace {
+export class VoxelGeometryBuilderCacheSpace {
     bounds;
     foundHash;
-    voxelHash;
+    voxelCache;
+    lightCache;
     modCache;
     stateCache;
     conditonalStateCache;
     noCastAO;
     offset = [0, 0, 0];
+    voxelCursor = new VoxelCursor();
     constructor(bounds) {
         this.bounds = bounds;
         const volume = bounds.x * bounds.y * bounds.z;
         this.foundHash = new Uint8Array(volume);
-        this.voxelHash = new Uint16Array(volume);
+        this.lightCache = new Int32Array(volume);
+        this.voxelCache = new Uint16Array(volume);
         this.modCache = new Int32Array(volume);
         this.stateCache = new Int32Array(volume);
         this.conditonalStateCache = new Int32Array(volume);
@@ -24,8 +27,9 @@ export class VoxelGeometryLookUpSpace {
         this.offset[0] = x;
         this.offset[1] = y;
         this.offset[2] = z;
+        this.lightCache.fill(-1);
         this.foundHash.fill(0);
-        this.voxelHash.fill(0);
+        this.voxelCache.fill(0);
         this.modCache.fill(-1);
         this.stateCache.fill(-1);
         this.conditonalStateCache.fill(-1);
@@ -35,72 +39,73 @@ export class VoxelGeometryLookUpSpace {
         return GetYXZOrderArrayIndex(x - this.offset[0], y - this.offset[1], z - this.offset[2], this.bounds.x, this.bounds.y, this.bounds.z);
     }
     getConstructor(index) {
-        if (this.foundHash[index] !== 2)
+        if (this.foundHash[index] < 2)
             return null;
-        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelHash[index]];
+        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelCache[index]];
     }
     getGeomtry(index) {
-        if (this.foundHash[index] !== 2)
+        if (this.foundHash[index] < 2)
             return false;
-        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelHash[index]].data.shapeStateGeometryMap[this.stateCache[index]];
+        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelCache[index]].data.shapeStateGeometryMap[this.stateCache[index]];
     }
     getConditionalGeomtry(index) {
-        if (this.foundHash[index] !== 2)
+        if (this.foundHash[index] < 2)
             return false;
-        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelHash[index]].data.condiotnalShapeStateGeometryMap[this.conditonalStateCache[index]];
+        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelCache[index]].data.condiotnalShapeStateGeometryMap[this.conditonalStateCache[index]];
     }
-}
-export class VoxelGeometryLookUp {
-    static space = null;
-    static voxelCursor = new VoxelCursor();
-    static createSpace(x, y, z) {
-        return new VoxelGeometryLookUpSpace({ x, y, z });
-    }
-    static init() { }
-    static start(space) {
-        this.space = space;
-    }
-    static isRulesless(geoId) {
-        return VoxelModelConstructorRegister.rulesless[geoId] == true;
-    }
-    static stop() { }
-    static getHash(dataCursor, x, y, z) {
-        if (!this.space)
-            throw new Error(`Voxel geomtry look up must have space set`);
-        const hashed = this.space.getIndex(x, y, z);
-        if (this.space.foundHash[hashed] == 0) {
+    getHash(dataCursor, x, y, z) {
+        const hashed = this.getIndex(x, y, z);
+        if (this.foundHash[hashed] == 0) {
             this.hashState(dataCursor, hashed, x, y, z);
         }
         return hashed;
     }
-    static hashState(dataCursor, index, x, y, z) {
-        if (!this.space)
-            throw new Error(`Voxel geomtry look up must have space set`);
-        if (this.space.foundHash[index] == 1)
+    getLight(dataCursor, x, y, z) {
+        const index = this.getIndex(x, y, z);
+        if (this.lightCache[index] == -1) {
+            this.lightCache[index] = 0;
+            const voxel = dataCursor.getVoxel(x, y, z);
+            if (voxel) {
+                const light = voxel.getLight();
+                if (light > 0) {
+                    this.lightCache[index] = light;
+                }
+            }
+        }
+        return this.lightCache[index];
+    }
+    hashState(dataCursor, index, x, y, z) {
+        if (this.foundHash[index] == 1)
             return -1;
-        if (this.space.foundHash[index] == 2)
-            return this.space.stateCache[index];
+        if (this.foundHash[index] == 2)
+            return this.stateCache[index];
         const voxel = dataCursor.getVoxel(x, y, z);
+        if (voxel) {
+            const light = voxel.getLight();
+            if (light > 0) {
+                this.lightCache[index] = light;
+            }
+        }
         if (!voxel || !voxel.isRenderable()) {
-            this.space.foundHash[index] = 1;
+            this.foundHash[index] = 1;
             return -1;
         }
         const voxelId = voxel.getId();
         const voxelConstructor = VoxelModelConstructorRegister.constructorsPaltte[voxelId];
         if (!voxelConstructor) {
-            this.space.foundHash[index] = 1;
+            this.foundHash[index] = 1;
             return -1;
         }
-        this.space.voxelHash[index] = voxelId;
-        this.space.foundHash[index] = 2;
+        this.voxelCache[index] = voxelId;
+        this.foundHash[index] = 2;
         //no ao
-        this.space.noCastAO[index] = voxel.isLightSource() || voxel.noAO() ? 1 : 0;
+        this.noCastAO[index] = voxel.isLightSource() || voxel.noAO() ? 1 : 0;
         //state
         const state = voxelConstructor.shapeStateTree.getState(voxel.getState());
-        this.space.stateCache[index] = state;
+        this.stateCache[index] = state;
         //mod
         const mod = voxelConstructor.modTree.getState(voxel.getMod());
-        this.space.modCache[index] = mod;
+        this.modCache[index] = mod;
         this.voxelCursor.copy(voxel).process();
         voxelConstructor.schema.position.x = x;
         voxelConstructor.schema.position.y = y;
@@ -108,7 +113,7 @@ export class VoxelGeometryLookUp {
         voxelConstructor.schema.voxel = this.voxelCursor;
         voxelConstructor.schema.dataCursor = dataCursor;
         const conditonalState = voxelConstructor.condtioanlShapeStateTree.getState();
-        this.space.conditonalStateCache[index] = conditonalState;
+        this.conditonalStateCache[index] = conditonalState;
         return 1;
     }
 }

package/Mesher/Models/VoxelModelConstructorRegister.js

@@ -1,6 +1,6 @@
-import { VoxelPalette } from "../../Voxels/Palettes/VoxelPalette";
 import { StringPalette } from "../../Util/StringPalette";
 import { VoxelGeometryConstructor } from "./Nodes/VoxelGeometryConstructor";
+import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
 export class VoxelModelConstructorRegister {
     static geometryPalette;
     static geometry = [];
@@ -31,11 +31,11 @@ export class VoxelModelConstructorRegister {
         if (Array.isArray(voxel)) {
             for (const vox of voxel) {
                 this.constructors.set(vox.id, vox);
-                this.constructorsPaltte[VoxelPalette.ids.getNumberId(vox.id)] = vox;
+                this.constructorsPaltte[VoxelPalettesRegister.voxels.getNumberId(vox.id)] = vox;
             }
             return;
         }
-        this.constructorsPaltte[VoxelPalette.ids.getNumberId(voxel.id)] = voxel;
+        this.constructorsPaltte[VoxelPalettesRegister.voxels.getNumberId(voxel.id)] = voxel;
         this.constructors.set(voxel.id, voxel);
     }
     static registerGeometry(geometries) {

package/Mesher/Tools/VoxelMeshBVHBuilder.d.ts

@@ -56,9 +56,8 @@ export declare class StructCursor {
     get active(): number;
     get nodeType(): number;
     trueIndex: number;
-    _index: number;
-    get index(): number;
-    set index(index: number);
+    private index;
+    setIndex(index: number): void;
     constructor(data: Float32Array);
     setActive(): void;
     setVoxelIndex(value: number): void;
@@ -66,12 +65,6 @@ export declare class StructCursor {
     setGeomtryNode(): void;
     updateMin(x: number, y: number, z: number): void;
     updateMax(x: number, y: number, z: number): void;
-    toJSON(): {
-        min: number[];
-        max: number[];
-        active: number;
-        nodeType: number;
-    };
 }
 export declare class VoxelMeshBVHBuilder {
     static AABBStructByteSize: number;

package/Mesher/Tools/VoxelMeshBVHBuilder.js

@@ -134,12 +134,8 @@ export class StructCursor {
         return this.data[this.trueIndex + 7];
     }
     trueIndex = 0;
-    _index = 0;
-    get index() {
-        return this._index;
-    }
-    set index(index) {
-        this._index = index;
+    index = 0;
+    setIndex(index) {
         this.trueIndex = index * 8;
     }
     constructor(data) {
@@ -185,14 +181,6 @@ export class StructCursor {
             this.data[iz] = z;
         }
     }
-    toJSON() {
-        return {
-            min: [this.minX, this.minY, this.minZ],
-            max: [this.maxX, this.maxY, this.maxZ],
-            active: this.active,
-            nodeType: this.nodeType,
-        };
-    }
 }
 export class VoxelMeshBVHBuilder {
     static AABBStructByteSize = (4 + 4) * 4;
@@ -209,7 +197,7 @@ export class VoxelMeshBVHBuilder {
         const leafIndex = this.treeIndex.getIndexAtLevel(12, voxelIndex);
         this.indices[voxelIndex * 2] = indicesStart;
         this.indices[voxelIndex * 2 + 1] = indicesEnd;
-        this.structCursor.index = leafIndex;
+        this.structCursor.setIndex(leafIndex);
         this.structCursor.updateMin(minX, minY, minZ);
         this.structCursor.updateMax(maxX, maxY, maxZ);
         this.structCursor.setVoxelIndex(voxelIndex);
@@ -217,7 +205,7 @@ export class VoxelMeshBVHBuilder {
         let current = leafIndex;
         for (let level = 1; level < 13; level++) {
             let parentNode = this.treeIndex.getParent(current);
-            this.structCursor.index = parentNode;
+            this.structCursor.setIndex(parentNode);
             this.structCursor.updateMin(minX, minY, minZ);
             this.structCursor.updateMax(maxX, maxY, maxZ);
             this.structCursor.setActive();

package/Mesher/Tools/VoxelMeshVertexStructCursor.d.ts

@@ -1,3 +1,13 @@
+export declare const VoxelMeshVertexConstants: {
+    VertexFloatSize: number;
+    VertexByteSize: number;
+    PositionOffset: number;
+    NormalOffset: number;
+    TextureIndexOffset: number;
+    UVOffset: number;
+    ColorOffset: number;
+    VoxelDataOFfset: number;
+};
 export declare class VoxelMeshVertexStructCursor {
     static VertexFloatSize: number;
     static VertexByteSize: number;

package/Mesher/Tools/VoxelMeshVertexStructCursor.js

@@ -1,3 +1,13 @@
+export const VoxelMeshVertexConstants = {
+    VertexFloatSize: 24,
+    VertexByteSize: 24 * 4,
+    PositionOffset: 0,
+    NormalOffset: 4,
+    TextureIndexOffset: 8,
+    UVOffset: 12,
+    ColorOffset: 14,
+    VoxelDataOFfset: 18,
+};
 export class VoxelMeshVertexStructCursor {
     static VertexFloatSize = 24;
     static VertexByteSize = this.VertexFloatSize * 4;

package/Mesher/Tools/VoxelMesherDataTool.d.ts

@@ -4,22 +4,24 @@ import { VoxelFaces } from "../../Math";
 import { QuadVerticies } from "../Geomtry/Geometry.types";
 import { VoxelMesh } from "../Geomtry/VoxelMesh";
 import { VoxelMeshBVHBuilder } from "./VoxelMeshBVHBuilder";
-import { Vec3Array, Vector3Like } from "@amodx/math";
+import { Vec3Array, Vector3Like, Vector4Like } from "@amodx/math";
 import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface.js";
-import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface.js";
+import { DataCursorInterface } from "../../Tools/DataCursor.interface.js";
+import { VoxelGeometryBuilderCacheSpace } from "../Models/VoxelGeometryBuilderCacheSpace";
 declare class VoxelVars {
     faceFlipped: boolean;
     textureIndex: number;
+    overlayTextures: Vector4Like;
     light: QuadScalarVertexData;
     ao: QuadScalarVertexData;
     animation: QuadScalarVertexData;
     level: QuadScalarVertexData;
-    overlayTextures: QuadScalarVertexData;
     reset(): void;
 }
 export declare class VoxelMesherDataTool extends MesherDataTool {
     id: string;
     materialIndex: number;
+    space: VoxelGeometryBuilderCacheSpace;
     voxel: VoxelCursorInterface;
     nVoxel: DataCursorInterface;
     /**The current world position */
@@ -41,9 +43,10 @@ export declare class VoxelMesherDataTool extends MesherDataTool {
     _indexStart: number;
     startConstruction(): void;
     endConstruction(): boolean;
+    _boundsUpdate: boolean;
+    updateBounds(bounds: [Vec3Array, Vec3Array]): void;
     calculateFaceData(direction: VoxelFaces): true | undefined;
     clearCalculatedData(): void;
-    reset(): void;
-    resetAll(): this;
+    clear(): this;
 }
 export {};