@divinevoxel/vlox 0.0.73 → 0.0.74

package/Mesher/Geomtry/VoxelMeshBVHStructCursor.js

@@ -0,0 +1,78 @@
+export class VoxelMeshBVHStructCursor {
+    data;
+    get minX() {
+        return this.data[this.trueIndex];
+    }
+    get minY() {
+        return this.data[this.trueIndex + 1];
+    }
+    get minZ() {
+        return this.data[this.trueIndex + 2];
+    }
+    get maxX() {
+        return this.data[this.trueIndex + 4];
+    }
+    get maxY() {
+        return this.data[this.trueIndex + 5];
+    }
+    get maxZ() {
+        return this.data[this.trueIndex + 6];
+    }
+    get voxelIndex() {
+        return this.data[this.trueIndex + 3];
+    }
+    get active() {
+        return this.data[this.trueIndex + 3];
+    }
+    get nodeType() {
+        return this.data[this.trueIndex + 7];
+    }
+    trueIndex = 0;
+    index = 0;
+    setIndex(index) {
+        this.trueIndex = index * 8;
+    }
+    constructor(data) {
+        this.data = data;
+    }
+    setActive() {
+        this.data[this.trueIndex + 3] = 1;
+    }
+    setVoxelIndex(value) {
+        this.data[this.trueIndex + 3] = value;
+    }
+    setInnerNode() {
+        this.data[this.trueIndex + 7] = 1;
+    }
+    setGeomtryNode() {
+        this.data[this.trueIndex + 7] = 2;
+    }
+    updateMin(x, y, z) {
+        const ix = this.trueIndex;
+        const iy = this.trueIndex + 1;
+        const iz = this.trueIndex + 2;
+        if (x < this.data[ix] || this.data[ix] == -Infinity) {
+            this.data[ix] = x;
+        }
+        if (y < this.data[iy] || this.data[iy] == -Infinity) {
+            this.data[iy] = y;
+        }
+        if (z < this.data[iz] || this.data[iz] == -Infinity) {
+            this.data[iz] = z;
+        }
+    }
+    updateMax(x, y, z) {
+        const ix = this.trueIndex + 4;
+        const iy = this.trueIndex + 5;
+        const iz = this.trueIndex + 6;
+        if (x > this.data[ix] || this.data[ix] == -Infinity) {
+            this.data[ix] = x;
+        }
+        if (y > this.data[iy] || this.data[iy] == -Infinity) {
+            this.data[iy] = y;
+        }
+        if (z > this.data[iz] || this.data[iz] == -Infinity) {
+            this.data[iz] = z;
+        }
+    }
+}

package/Mesher/Geomtry/VoxelMeshBuffers.js

@@ -3,7 +3,7 @@ export class VoxelVertexBuffer {
     sectorVertexSize;
     _buffers = [];
     sectorSize = 0;
-    constructor(vertexFloatSize, sectorVertexSize, startingSectorSize = 4) {
+    constructor(vertexFloatSize, sectorVertexSize, startingSectorSize = 8) {
         this.vertexFloatSize = vertexFloatSize;
         this.sectorVertexSize = sectorVertexSize;
         this.sectorSize = vertexFloatSize * sectorVertexSize;
@@ -28,7 +28,7 @@ export class VoxelVertexBuffer {
 export class VoxelIndiceBuffer {
     sectorSize;
     _buffers = [];
-    constructor(sectorSize, startingSectorSize = 4) {
+    constructor(sectorSize, startingSectorSize = 8) {
         this.sectorSize = sectorSize;
         for (let i = 0; i < startingSectorSize; i++) {
             this._buffers.push(new Uint32Array(sectorSize));

package/Mesher/InitTask.js

@@ -10,7 +10,7 @@ export default function (rendererThread) {
             return;
         rendererThread.runTask("set-section", section, transfers);
     });
-    Threads.registerTask(TasksIds.BuildSector, (location) => {
+    Threads.registerTask(TasksIds.BuildSector, (location, origin) => {
         const sector = WorldRegister.sectors.getAt(location);
         if (!sector) {
             console.warn("Tried building a sector that does not exists.", location);
@@ -21,11 +21,15 @@ export default function (rendererThread) {
             let [minY, maxY] = section.getMinMax();
             if (Math.abs(minY) == Infinity && Math.abs(maxY) == Infinity)
                 continue;
+            const t = performance.now();
             const transfers = [];
             const sectionMesh = MeshSection([location[0], ...section.getPosition()], transfers);
             if (!sectionMesh)
                 continue;
             rendererThread.runTask("set-section", sectionMesh, transfers);
+            const buildTime = performance.now() - t;
+            origin.runTask("add-build-time", buildTime);
+            console.log("BUILD TIME", buildTime);
         }
     });
 }

package/Mesher/Models/Common/BoxGeometryNode.js

@@ -1,7 +1,7 @@
 import { Vector3Like } from "@amodx/math";
 import { VoxelFaces } from "../../../Math";
 import { Quad } from "../../Geomtry/Primitives/Quad";
-import { addQuadWeights } from "./Calc/CalcConstants";
+import { getQuadWeights } from "./Calc/CalcConstants";
 import { TransformBox } from "../../../Models/Shared/Transform";
 import { GetBounds } from "./BoundsFunctions";
 export function GetBoxGeometryNodeData(points, transform) {
@@ -66,12 +66,12 @@ export function GetBoxGeometryNodeData(points, transform) {
         }
         quadBounds[i] = GetBounds(positions);
     }
-    vertexWeights[VoxelFaces.Up] = addQuadWeights(quads[VoxelFaces.Up], VoxelFaces.Up);
-    vertexWeights[VoxelFaces.Down] = addQuadWeights(quads[VoxelFaces.Down], VoxelFaces.Down);
-    vertexWeights[VoxelFaces.North] = addQuadWeights(quads[VoxelFaces.North], VoxelFaces.North);
-    vertexWeights[VoxelFaces.South] = addQuadWeights(quads[VoxelFaces.South], VoxelFaces.South);
-    vertexWeights[VoxelFaces.East] = addQuadWeights(quads[VoxelFaces.East], VoxelFaces.East);
-    vertexWeights[VoxelFaces.West] = addQuadWeights(quads[VoxelFaces.West], VoxelFaces.West);
+    vertexWeights[VoxelFaces.Up] = getQuadWeights(quads[VoxelFaces.Up], VoxelFaces.Up);
+    vertexWeights[VoxelFaces.Down] = getQuadWeights(quads[VoxelFaces.Down], VoxelFaces.Down);
+    vertexWeights[VoxelFaces.North] = getQuadWeights(quads[VoxelFaces.North], VoxelFaces.North);
+    vertexWeights[VoxelFaces.South] = getQuadWeights(quads[VoxelFaces.South], VoxelFaces.South);
+    vertexWeights[VoxelFaces.East] = getQuadWeights(quads[VoxelFaces.East], VoxelFaces.East);
+    vertexWeights[VoxelFaces.West] = getQuadWeights(quads[VoxelFaces.West], VoxelFaces.West);
     return {
         quads,
         vertexWeights,

package/Mesher/Models/Common/Calc/CalcConstants.d.ts

@@ -11,5 +11,5 @@ export declare function shouldCauseFlip(topRight: number, topLeft: number, botto
 export declare function getVertexWeights(face: VoxelFaces, x: number, y: number, z: number): Vec4Array;
 export declare function getInterpolationValue(value: Vec4Array, weights: Vec4Array): number;
 export type QuadVertexWeights = [Vec4Array, Vec4Array, Vec4Array, Vec4Array];
-export declare const addQuadWeights: (quad: Quad, direction: VoxelFaces) => QuadVertexWeights;
+export declare const getQuadWeights: (quad: Quad, direction: VoxelFaces) => QuadVertexWeights;
 export declare function closestUnitNormal(v: Vec3Array): Vec3Array;

package/Mesher/Models/Common/Calc/CalcConstants.js

@@ -326,7 +326,7 @@ export function getInterpolationValue(value, weights) {
         lightData.getB(value[2]) * weights[2] +
         lightData.getB(value[3]) * weights[3]);
 }
-export const addQuadWeights = (quad, direction) => {
+export const getQuadWeights = (quad, direction) => {
     const returnArray = [];
     for (const vertex of QuadVerticiesArray) {
         const { x, y, z } = quad.positions.vertices[vertex];

package/Mesher/Models/Common/QuadGeometryNode.js

@@ -1,7 +1,7 @@
 import { Vector3Like } from "@amodx/math";
 import { VoxelFaces } from "../../../Math";
 import { Quad } from "../../Geomtry/Primitives/Quad";
-import { addQuadWeights, closestUnitNormal, } from "./Calc/CalcConstants";
+import { getQuadWeights, closestUnitNormal, } from "./Calc/CalcConstants";
 import { TransformQuad } from "../../../Models/Shared/Transform";
 import { GetBounds } from "./BoundsFunctions";
 export function GetQuadGeometryData(data, transform) {
@@ -40,7 +40,7 @@ export function GetQuadGeometryData(data, transform) {
         closestFace = VoxelFaces.North;
     if (unitNormal[2] == -1)
         closestFace = VoxelFaces.South;
-    const vertexWeights = addQuadWeights(quad, closestFace);
+    const vertexWeights = getQuadWeights(quad, closestFace);
     closestFace = closestFace;
     return {
         quad,

package/Mesher/Models/Nodes/Custom/Liquid/LiquidGeomtryNode.js

@@ -8,7 +8,7 @@ import { shouldCauseFlip } from "../../../Common/Calc/CalcConstants";
 import { getFlowAngle, getFlowGradient, FlowVerticies } from "./FlowGradient";
 import { GetBoxGeometryNodeData } from "../../../Common/BoxGeometryNode";
 import { VoxelLightData } from "../../../../../Voxels/Cursor/VoxelLightData";
-import { VoxelGeometryBuilder } from "../../../../Geomtry/VoxelGeometryBuilder";
+import { addVoxelQuad } from "../../../../Geomtry/VoxelGeometryBuilder";
 const vertexValue = new QuadScalarVertexData();
 const vertexLevel = new QuadScalarVertexData();
 const lightData = new VoxelLightData();
@@ -92,7 +92,7 @@ export class LiquidGeometryNode extends GeoemtryNode {
             quad.positions.vertices[1].y = vertexValue.vertices[1] * waterHeight;
             quad.positions.vertices[2].y = vertexValue.vertices[2] * waterHeight;
             quad.positions.vertices[3].y = vertexValue.vertices[3] * waterHeight;
-            VoxelGeometryBuilder.addQuad(tool, tool.origin, quad);
+            addVoxelQuad(tool, tool.origin, quad);
             tool.updateBounds(quadBounds[VoxelFaces.Up]);
         }
         if (this.isExposed(VoxelFaces.Down)) {
@@ -101,7 +101,7 @@ export class LiquidGeometryNode extends GeoemtryNode {
             const quad = Quads[VoxelFaces.Down];
             this.determineShading(VoxelFaces.Down);
             quad.flip = this.shouldFlip();
-            VoxelGeometryBuilder.addQuad(tool, tool.origin, quad);
+            addVoxelQuad(tool, tool.origin, quad);
             tool.updateBounds(quadBounds[VoxelFaces.Down]);
         }
         if (this.isExposed(VoxelFaces.North)) {
@@ -126,7 +126,7 @@ export class LiquidGeometryNode extends GeoemtryNode {
                 quad.positions.vertices[QuadVerticies.TopLeft].y = 1;
                 quad.setUVs(uvs);
             }
-            VoxelGeometryBuilder.addQuad(tool, tool.origin, quad);
+            addVoxelQuad(tool, tool.origin, quad);
             tool.updateBounds(quadBounds[VoxelFaces.North]);
         }
         if (this.isExposed(VoxelFaces.South)) {
@@ -151,7 +151,7 @@ export class LiquidGeometryNode extends GeoemtryNode {
                 quad.positions.vertices[QuadVerticies.TopRight].y = 1;
                 quad.setUVs(uvs);
             }
-            VoxelGeometryBuilder.addQuad(tool, tool.origin, quad);
+            addVoxelQuad(tool, tool.origin, quad);
             tool.updateBounds(quadBounds[VoxelFaces.South]);
         }
         if (this.isExposed(VoxelFaces.East)) {
@@ -176,7 +176,7 @@ export class LiquidGeometryNode extends GeoemtryNode {
                 quad.positions.vertices[QuadVerticies.TopRight].y = 1;
                 quad.setUVs(uvs);
             }
-            VoxelGeometryBuilder.addQuad(tool, tool.origin, quad);
+            addVoxelQuad(tool, tool.origin, quad);
             tool.updateBounds(quadBounds[VoxelFaces.East]);
         }
         if (this.isExposed(VoxelFaces.West)) {
@@ -201,7 +201,7 @@ export class LiquidGeometryNode extends GeoemtryNode {
                 quad.positions.vertices[QuadVerticies.TopRight].y = 1;
                 quad.setUVs(uvs);
             }
-            VoxelGeometryBuilder.addQuad(tool, tool.origin, quad);
+            addVoxelQuad(tool, tool.origin, quad);
             tool.updateBounds(quadBounds[VoxelFaces.West]);
         }
         this.builder.vars.light.setAll(0);

package/Mesher/Models/Nodes/Ruled/BoxVoxelGeometryNode.js

@@ -4,7 +4,7 @@ import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcC
 import { VoxelRelativeCubeIndexPositionMap } from "../../../../Models/Indexing/VoxelRelativeCubeIndex";
 import { GetBoxGeometryNodeData } from "../../Common/BoxGeometryNode";
 import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
-import { VoxelGeometryBuilder } from "../../../Geomtry/VoxelGeometryBuilder";
+import { addVoxelQuad, } from "../../../Geomtry/VoxelGeometryBuilder";
 import { VoxelModelConstructorRegister } from "../../../Models/VoxelModelConstructorRegister";
 const ArgIndexes = BoxVoxelGometryInputs.ArgIndexes;
 export class BoxVoxelGometryNode extends GeoemtryNode {
@@ -26,15 +26,15 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
         const faceIndexes = this.geomtry.faceCullMap[trueFaceIndex];
         if (!faceIndexes)
             return true;
-        const tool = this.builder;
+        const builder = this.builder;
         for (let positionIndex = 0; positionIndex < faceIndexes.length; positionIndex++) {
             const currentIndex = faceIndexes[positionIndex];
             const p = VoxelRelativeCubeIndexPositionMap[currentIndex];
-            const hashed = this.builder.space.getHash(tool.nVoxel, tool.position.x + p[0], tool.position.y + p[1], tool.position.z + p[2]);
+            const hashed = this.builder.space.getHash(builder.nVoxel, builder.position.x + p[0], builder.position.y + p[1], builder.position.z + p[2]);
             if (this.builder.space.foundHash[hashed] < 2)
                 continue;
+            const constructor = this.builder.space.getConstructor(hashed);
             const offsetBaseGometry = this.builder.space.getGeomtry(hashed);
-            const offsetConditonalGeometry = this.builder.space.getConditionalGeomtry(hashed);
             if (offsetBaseGometry) {
                 for (let i = 0; i < offsetBaseGometry.length; i++) {
                     const geoId = offsetBaseGometry[i];
@@ -42,27 +42,24 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
                         continue;
                     const faceIndex = this.geomtry.cullIndex.getValue(geoId, currentIndex, trueFaceIndex);
                     if (faceIndex > -1 &&
-                        !this.builder.space
-                            .getConstructor(hashed)
-                            ?.isShapeStateFaceTransparent(this.builder.space.modCache[hashed], this.builder.space.stateCache[hashed], geoId, faceIndex)) {
+                        !constructor.isShapeStateFaceTransparent(this.builder.space.modCache[hashed], this.builder.space.stateCache[hashed], geoId, faceIndex)) {
                         return false;
                     }
                 }
             }
-            if (!offsetConditonalGeometry)
-                continue;
-            for (let i = 0; i < offsetConditonalGeometry.length; i++) {
-                const cond = offsetConditonalGeometry[i];
-                for (let k = 0; k < cond.length; k++) {
-                    const geoId = cond[k];
-                    if (VoxelModelConstructorRegister.rulesless[geoId])
-                        continue;
-                    const faceIndex = this.geomtry.cullIndex.getValue(geoId, currentIndex, trueFaceIndex);
-                    if (faceIndex > -1 &&
-                        !this.builder.space
-                            .getConstructor(hashed)
-                            ?.isCondtionalStateFaceTransparent(this.builder.space.modCache[hashed], this.builder.space.stateCache[hashed], geoId, faceIndex))
-                        return false;
+            const offsetConditonalGeometry = this.builder.space.getConditionalGeomtry(hashed);
+            if (offsetConditonalGeometry) {
+                for (let i = 0; i < offsetConditonalGeometry.length; i++) {
+                    const cond = offsetConditonalGeometry[i];
+                    for (let k = 0; k < cond.length; k++) {
+                        const geoId = cond[k];
+                        if (VoxelModelConstructorRegister.rulesless[geoId])
+                            continue;
+                        const faceIndex = this.geomtry.cullIndex.getValue(geoId, currentIndex, trueFaceIndex);
+                        if (faceIndex > -1 &&
+                            !constructor.isCondtionalStateFaceTransparent(this.builder.space.modCache[hashed], this.builder.space.stateCache[hashed], geoId, faceIndex))
+                            return false;
+                    }
                 }
             }
         }
@@ -102,7 +99,7 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
                         if (this.geomtry.aoIndex.getValue(baseGeo[geoIndex], currentIndex, trueVertexIndex)) {
                             this._wasAOShaded = true;
                             worldAO.vertices[v]++;
-                            if (worldAO.vertices[v] > 4) {
+                            if (worldAO.vertices[v] >= 3) {
                                 shaded = true;
                                 break;
                             }
@@ -118,7 +115,7 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
                         if (this.geomtry.aoIndex.getValue(conditonalGeo[condtionsIndex][geoIndex], currentIndex, trueVertexIndex)) {
                             this._wasAOShaded = true;
                             worldAO.vertices[v]++;
-                            if (worldAO.vertices[v] > 4) {
+                            if (worldAO.vertices[v] >= 3) {
                                 shaded = true;
                                 break;
                             }
@@ -145,10 +142,10 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
         for (let face = 0; face < 6; face++) {
             if (args[face][ArgIndexes.Enabled] && this.isExposed(face)) {
                 added = true;
+                const quad = this.quads[face];
                 tool.calculateFaceData(face);
                 this.determineShading(face);
                 const faceArgs = args[face];
-                const quad = this.quads[face];
                 quad.flip = this.shouldFlip() || faceArgs[ArgIndexes.Fliped];
                 tool.vars.textureIndex = faceArgs[ArgIndexes.Texture];
                 const uvs = faceArgs[ArgIndexes.UVs];
@@ -164,7 +161,7 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
                 //4
                 quad.uvs.vertices[3].x = uvs[3][0];
                 quad.uvs.vertices[3].y = uvs[3][1];
-                VoxelGeometryBuilder.addQuad(tool, this.builder.origin, quad);
+                addVoxelQuad(tool, this.builder.origin, quad);
                 tool.updateBounds(this.quadBounds[face]);
             }
         }

package/Mesher/Models/Nodes/Ruled/QuadVoxelGeometryNode.js

@@ -1,5 +1,5 @@
 import { VoxelFaces } from "../../../../Math";
-import { VoxelGeometryBuilder } from "../../../Geomtry/VoxelGeometryBuilder";
+import { addVoxelQuad } from "../../../Geomtry/VoxelGeometryBuilder";
 import { GeoemtryNode } from "../GeometryNode";
 import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcConstants";
 import { VoxelRelativeCubeIndexPositionMap } from "../../../../Models/Indexing/VoxelRelativeCubeIndex";
@@ -148,7 +148,7 @@ export class QuadVoxelGometryNode extends GeoemtryNode {
         //4
         quad.uvs.vertices[3].x = uvs[3][0];
         quad.uvs.vertices[3].y = uvs[3][1];
-        VoxelGeometryBuilder.addQuad(this.builder, this.builder.origin, quad);
+        addVoxelQuad(this.builder, this.builder.origin, quad);
         this.builder.updateBounds(this.quadBounds);
         this.builder.vars.light.setAll(0);
         this.builder.vars.ao.setAll(0);

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

@@ -1,4 +1,4 @@
-import { VoxelGeometryBuilder } from "../../../Geomtry/VoxelGeometryBuilder";
+import { addVoxelQuad } from "../../../Geomtry/VoxelGeometryBuilder";
 import { BoxVoxelGometryInputs, } from "../../../../Models/Input/BoxVoxelGometryInputs";
 import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcConstants";
 import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
@@ -64,7 +64,7 @@ export class RulelessBoxVoxelGeometryNode extends GeoemtryNode {
                 //4
                 quad.uvs.vertices[3].x = uvs[3][0];
                 quad.uvs.vertices[3].y = uvs[3][1];
-                VoxelGeometryBuilder.addQuad(tool, tool.position, quad);
+                addVoxelQuad(tool, tool.position, quad);
                 this.builder.updateBounds(this.quadBounds[face]);
             }
         }

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

@@ -1,5 +1,5 @@
 import { VoxelFaces } from "../../../../Math";
-import { VoxelGeometryBuilder } from "../../../Geomtry/VoxelGeometryBuilder";
+import { addVoxelQuad, } from "../../../Geomtry/VoxelGeometryBuilder";
 import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcConstants";
 import { QuadVoxelGometryInputs, } from "../../../../Models/Input/QuadVoxelGometryInputs";
 import { GeoemtryNode } from "../GeometryNode";
@@ -68,7 +68,7 @@ export class RulelessQuadVoxelGeometryNode extends GeoemtryNode {
         //4
         quad.uvs.vertices[3].x = uvs[3][0];
         quad.uvs.vertices[3].y = uvs[3][1];
-        VoxelGeometryBuilder.addQuad(tool, tool.position, quad);
+        addVoxelQuad(tool, tool.position, quad);
         this.builder.updateBounds(this.quadBounds);
         this.builder.vars.light.setAll(0);
         this.builder.vars.ao.setAll(0);

package/Mesher/Models/VoxelConstructor.d.ts

@@ -18,10 +18,10 @@ export declare class VoxelConstructor {
     conditonalInputMap: any[];
     schema: StateSchema;
     effects: VoxelModelEffect;
-    shapeStateTree: StateTreeReader;
+    stateTree: StateTreeReader;
     condtioanlShapeStateTree: CondtionalTreeReader;
     constructor(id: string, builder: VoxelModelBuilder, data: CompiledVoxelModelData, voxleData: CompiledVoxelModelInputData);
-    isShapeStateFaceTransparent(modState: number, shapeState: number, geoId: number, faceIndex: number): boolean;
-    isCondtionalStateFaceTransparent(modState: number, shapeState: number, geoId: number, faceIndex: number): boolean;
+    isShapeStateFaceTransparent(modState: number, stateTree: number, geoId: number, faceIndex: number): boolean;
+    isCondtionalStateFaceTransparent(modState: number, state: number, geoId: number, faceIndex: number): boolean;
     process(): boolean;
 }

package/Mesher/Models/VoxelConstructor.js

@@ -17,7 +17,7 @@ export class VoxelConstructor {
     conditonalInputMap;
     schema;
     effects;
-    shapeStateTree;
+    stateTree;
     condtioanlShapeStateTree;
     constructor(id, builder, data, voxleData) {
         this.id = id;
@@ -27,17 +27,17 @@ export class VoxelConstructor {
         this.conditonalInputMap = voxleData.condiotnalGeometryInputMap;
         this.transparentIndex = new VoxelFaceTransparentResultsIndex(voxleData.transparentFaceIndex);
         this.schema = new StateSchema(data.schema);
-        this.shapeStateTree = new StateTreeReader(this.schema, 0, data.shapeStateTree);
+        this.stateTree = new StateTreeReader(this.schema, 0, data.stateTree);
         this.condtioanlShapeStateTree = new CondtionalTreeReader(this.schema, data.condiotnalStatements, data.condiotnalStateTree);
         this.modSchema = new StateSchema(voxleData.modSchema);
         this.modTree = new StateTreeReader(this.modSchema, 0, voxleData.modStateTree);
         this.effects = new VoxelModelEffect(this);
     }
-    isShapeStateFaceTransparent(modState, shapeState, geoId, faceIndex) {
-        return (this.transparentIndex.getValue(modState, this.data.relativeGeometryByteIndexMap[this.data.shapeStateRelativeGeometryMap[shapeState][geoId]], faceIndex) == 1);
+    isShapeStateFaceTransparent(modState, stateTree, geoId, faceIndex) {
+        return (this.transparentIndex.getValue(modState, this.data.relativeGeometryByteIndexMap[this.data.stateRelativeGeometryMap[stateTree][geoId]], faceIndex) == 1);
     }
-    isCondtionalStateFaceTransparent(modState, shapeState, geoId, faceIndex) {
-        return (this.transparentIndex.getValue(modState, this.data.relativeGeometryByteIndexMap[this.data.condiotnalShapeStateRelativeGeometryMap[shapeState][geoId]], faceIndex) == 1);
+    isCondtionalStateFaceTransparent(modState, state, geoId, faceIndex) {
+        return (this.transparentIndex.getValue(modState, this.data.relativeGeometryByteIndexMap[this.data.condiotnalShapeStateRelativeGeometryMap[state][geoId]], faceIndex) == 1);
     }
     process() {
         let added = false;
@@ -46,8 +46,8 @@ export class VoxelConstructor {
         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];
+            const geoLinks = this.data.stateMap[treeState];
+            const geometries = this.data.stateGeometryMap[treeState];
             const geometriesLength = geoLinks.length;
             const inputs = this.baseInputMap[modState][treeState];
             for (let i = 0; i < geometriesLength; i++) {

package/Mesher/Models/VoxelGeometryBuilderCacheSpace.d.ts

@@ -15,8 +15,8 @@ export declare class VoxelGeometryBuilderCacheSpace {
     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[][];
+    getGeomtry(index: number): number[] | null;
+    getConditionalGeomtry(index: number): number[][] | null;
     getHash(dataCursor: DataCursorInterface, x: number, y: number, z: number): number;
     private hashState;
 }

package/Mesher/Models/VoxelGeometryBuilderCacheSpace.js

@@ -42,12 +42,12 @@ export class VoxelGeometryBuilderCacheSpace {
     }
     getGeomtry(index) {
         if (this.foundHash[index] < 2)
-            return false;
-        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelCache[index]].data.shapeStateGeometryMap[this.stateCache[index]];
+            return null;
+        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelCache[index]].data.stateGeometryMap[this.stateCache[index]];
     }
     getConditionalGeomtry(index) {
         if (this.foundHash[index] < 2)
-            return false;
+            return null;
         return VoxelModelConstructorRegister.constructorsPaltte[this.voxelCache[index]].data.condiotnalShapeStateGeometryMap[this.conditonalStateCache[index]];
     }
     getHash(dataCursor, x, y, z) {
@@ -59,26 +59,26 @@ export class VoxelGeometryBuilderCacheSpace {
     }
     hashState(dataCursor, index, x, y, z) {
         if (this.foundHash[index] == 1)
-            return -1;
+            return;
         if (this.foundHash[index] == 2)
-            return this.stateCache[index];
+            return;
         const voxel = dataCursor.getVoxel(x, y, z);
         if (!voxel || !voxel.isRenderable()) {
             this.foundHash[index] = 1;
-            return -1;
+            return;
         }
         const voxelId = voxel.getId();
         const voxelConstructor = VoxelModelConstructorRegister.constructorsPaltte[voxelId];
         if (!voxelConstructor) {
             this.foundHash[index] = 1;
-            return -1;
+            return;
         }
         this.voxelCache[index] = voxelId;
         this.foundHash[index] = 2;
         //no ao
         this.noCastAO[index] = voxel.isLightSource() || voxel.noAO() ? 1 : 0;
         //state
-        const state = voxelConstructor.shapeStateTree.getState(voxel.getState());
+        const state = voxelConstructor.stateTree.getState(voxel.getState());
         this.stateCache[index] = state;
         //mod
         const mod = voxelConstructor.modTree.getState(voxel.getMod());
@@ -91,6 +91,5 @@ export class VoxelGeometryBuilderCacheSpace {
         voxelConstructor.schema.dataCursor = dataCursor;
         const conditonalState = voxelConstructor.condtioanlShapeStateTree.getState();
         this.conditonalStateCache[index] = conditonalState;
-        return 1;
     }
 }

package/Mesher/Models/VoxelModelBuilder.js

@@ -86,7 +86,7 @@ export class VoxelModelBuilder {
         this.bounds.max[0] = -Infinity;
         this.bounds.max[1] = -Infinity;
         this.bounds.max[2] = -Infinity;
-        this._boundsUpdate = true;
+        this._boundsUpdate = false;
     }
     endConstruction() {
         this.vars.reset();
@@ -94,13 +94,6 @@ export class VoxelModelBuilder {
             if (!this._boundsUpdate)
                 return false;
             this.bvhTool.updateVoxel(this.position.x, this.position.y, this.position.z, this._indexStart, this.materialIndex, this.mesh.indicieCount, this.bounds.min[0], this.bounds.min[1], this.bounds.min[2], this.bounds.max[0], this.bounds.max[1], this.bounds.max[2]);
-            this.bvhTool.structCursor.setIndex(0);
-            this.mesh.minBounds.x = this.bvhTool.structCursor.minX;
-            this.mesh.minBounds.y = this.bvhTool.structCursor.minY;
-            this.mesh.minBounds.z = this.bvhTool.structCursor.minZ;
-            this.mesh.maxBounds.x = this.bvhTool.structCursor.maxX;
-            this.mesh.maxBounds.y = this.bvhTool.structCursor.maxY;
-            this.mesh.maxBounds.z = this.bvhTool.structCursor.maxZ;
         }
         return true;
     }

package/Mesher/Types/Mesher.types.d.ts

@@ -1,4 +1,5 @@
 import { Vec3Array } from "@amodx/math";
+export type SetSectionMeshTask = ArrayBuffer;
 export type CompactSubMesh = [
     materialId: string,
     vertexBuffer: Float32Array,