@divinevoxel/vlox 0.0.7 → 0.0.72

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

@@ -4,7 +4,6 @@ import { Quad } from "../../../../Geomtry/Primitives/Quad";
 import { QuadVerticies } from "../../../../Geomtry/Geometry.types";
 import { QuadScalarVertexData } from "../../../../Geomtry/Primitives/QuadVertexData";
 import { VoxelFaceDirections, VoxelFaces } from "../../../../../Math";
-import { UpdateBounds } from "../../../Common/BoundsFunctions";
 import { shouldCauseFlip } from "../../../Common/Calc/CalcConstants";
 import { getFlowAngle, getFlowGradient, FlowVerticies } from "./FlowGradient";
 import { GetBoxGeometryNodeData } from "../../../Common/BoxGeometryNode";
@@ -37,41 +36,40 @@ const { quads: Quads, vertexWeights, quadBounds, } = GetBoxGeometryNodeData([
 Quads[VoxelFaces.Up].setUVs(uvs);
 Quads[VoxelFaces.Down].setUVs(uvs);
 export class LiquidGeometryNode extends GeoemtryNode {
-    worldLight;
     init() {
         this.faceCount = 1;
         this.vertexCount = 0;
     }
     isExposed(face) {
-        const nv = this.tool.nVoxel.getVoxel(VoxelFaceDirections[face][0] + this.tool.position.x, VoxelFaceDirections[face][1] + this.tool.position.y, VoxelFaceDirections[face][2] + this.tool.position.z);
+        const nv = this.builder.nVoxel.getVoxel(VoxelFaceDirections[face][0] + this.builder.position.x, VoxelFaceDirections[face][1] + this.builder.position.y, VoxelFaceDirections[face][2] + this.builder.position.z);
         if (!nv ||
             nv.isAir() ||
-            (!this.tool.voxel.isSameVoxel(nv) && face == VoxelFaces.Up))
+            (!this.builder.voxel.isSameVoxel(nv) && face == VoxelFaces.Up))
             return true;
         return false;
     }
     determineShading(face) {
-        const tool = this.tool;
+        const tool = this.builder;
         const lightData = tool.lightData[face];
-        const worldLight = this.worldLight;
+        const worldLight = this.builder.vars.light;
         for (let v = 0; v < 4; v++) {
             worldLight.vertices[v] = lightData[v];
         }
     }
     shouldFlip() {
-        return (shouldCauseFlip(lightData.getS(this.worldLight.vertices[0]), lightData.getS(this.worldLight.vertices[1]), lightData.getS(this.worldLight.vertices[2]), lightData.getS(this.worldLight.vertices[3])) ||
-            shouldCauseFlip(lightData.sumRGB(this.worldLight.vertices[0]), lightData.sumRGB(this.worldLight.vertices[1]), lightData.sumRGB(this.worldLight.vertices[2]), lightData.sumRGB(this.worldLight.vertices[3])));
+        const worldLight = this.builder.vars.light;
+        return (shouldCauseFlip(lightData.getS(worldLight.vertices[0]), lightData.getS(worldLight.vertices[1]), lightData.getS(worldLight.vertices[2]), lightData.getS(worldLight.vertices[3])) ||
+            shouldCauseFlip(lightData.sumRGB(worldLight.vertices[0]), lightData.sumRGB(worldLight.vertices[1]), lightData.sumRGB(worldLight.vertices[2]), lightData.sumRGB(worldLight.vertices[3])));
     }
-    add(tool, originHash, origin, args) {
+    add(args) {
         vertexLevel.setAll(15);
         vertexValue.setAll(0);
-        this.tool = tool;
-        this.tool = tool;
-        this.origin = tool.position;
-        this.worldLight = tool.vars.light;
+        const tool = this.builder;
+        let added = false;
         let upFaceExposed = false;
         if (this.isExposed(VoxelFaces.Up)) {
             upFaceExposed = true;
+            added = true;
             getFlowGradient(tool, vertexLevel);
             const quad = Quads[VoxelFaces.Up];
             tool.calculateFaceData(VoxelFaces.Up);
@@ -94,20 +92,22 @@ 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, origin, quad);
-            UpdateBounds(tool, origin, quadBounds[VoxelFaces.Up]);
+            VoxelGeometryBuilder.addQuad(tool, tool.origin, quad);
+            tool.updateBounds(quadBounds[VoxelFaces.Up]);
         }
         if (this.isExposed(VoxelFaces.Down)) {
+            added = true;
             tool.vars.textureIndex = args.stillTexture;
             const quad = Quads[VoxelFaces.Down];
             tool.calculateFaceData(VoxelFaces.Down);
             this.determineShading(VoxelFaces.Down);
             quad.flip = this.shouldFlip();
             tool.vars.textureIndex = args.stillTexture;
-            VoxelGeometryBuilder.addQuad(tool, origin, quad);
-            UpdateBounds(tool, origin, quadBounds[VoxelFaces.Down]);
+            VoxelGeometryBuilder.addQuad(tool, tool.origin, quad);
+            tool.updateBounds(quadBounds[VoxelFaces.Down]);
         }
         if (this.isExposed(VoxelFaces.North)) {
+            added = true;
             tool.vars.textureIndex = args.stillTexture;
             const quad = Quads[VoxelFaces.North];
             tool.vars.animation.setAll(1);
@@ -129,10 +129,11 @@ export class LiquidGeometryNode extends GeoemtryNode {
                 quad.positions.vertices[QuadVerticies.TopLeft].y = 1;
                 quad.setUVs(uvs);
             }
-            VoxelGeometryBuilder.addQuad(tool, origin, quad);
-            UpdateBounds(tool, origin, quadBounds[VoxelFaces.North]);
+            VoxelGeometryBuilder.addQuad(tool, tool.origin, quad);
+            tool.updateBounds(quadBounds[VoxelFaces.North]);
         }
         if (this.isExposed(VoxelFaces.South)) {
+            added = true;
             tool.vars.textureIndex = args.stillTexture;
             const quad = Quads[VoxelFaces.South];
             tool.vars.animation.setAll(1);
@@ -154,10 +155,11 @@ export class LiquidGeometryNode extends GeoemtryNode {
                 quad.positions.vertices[QuadVerticies.TopRight].y = 1;
                 quad.setUVs(uvs);
             }
-            VoxelGeometryBuilder.addQuad(tool, origin, quad);
-            UpdateBounds(tool, origin, quadBounds[VoxelFaces.South]);
+            VoxelGeometryBuilder.addQuad(tool, tool.origin, quad);
+            tool.updateBounds(quadBounds[VoxelFaces.South]);
         }
         if (this.isExposed(VoxelFaces.East)) {
+            added = true;
             tool.vars.textureIndex = args.stillTexture;
             const quad = Quads[VoxelFaces.East];
             tool.vars.animation.setAll(1);
@@ -179,10 +181,11 @@ export class LiquidGeometryNode extends GeoemtryNode {
                 quad.positions.vertices[QuadVerticies.TopRight].y = 1;
                 quad.setUVs(uvs);
             }
-            VoxelGeometryBuilder.addQuad(tool, origin, quad);
-            UpdateBounds(tool, origin, quadBounds[VoxelFaces.East]);
+            VoxelGeometryBuilder.addQuad(tool, tool.origin, quad);
+            tool.updateBounds(quadBounds[VoxelFaces.East]);
         }
         if (this.isExposed(VoxelFaces.West)) {
+            added = true;
             tool.vars.textureIndex = args.stillTexture;
             const quad = Quads[VoxelFaces.West];
             tool.vars.animation.setAll(1);
@@ -204,9 +207,10 @@ export class LiquidGeometryNode extends GeoemtryNode {
                 quad.positions.vertices[QuadVerticies.TopRight].y = 1;
                 quad.setUVs(uvs);
             }
-            VoxelGeometryBuilder.addQuad(tool, origin, quad);
-            UpdateBounds(tool, origin, quadBounds[VoxelFaces.West]);
+            VoxelGeometryBuilder.addQuad(tool, tool.origin, quad);
+            tool.updateBounds(quadBounds[VoxelFaces.West]);
         }
-        this.worldLight.setAll(0);
+        this.builder.vars.light.setAll(0);
+        return added;
     }
 }

package/Mesher/Models/Nodes/GeometryNode.d.ts

@@ -1,5 +1,4 @@
 import { VoxelMesherDataTool } from "../../../Mesher/Tools/VoxelMesherDataTool";
-import { Vector3Like } from "@amodx/math";
 import { VoxelGeometryConstructor } from "./VoxelGeometryConstructor";
 import { VoxelGeometryTransform } from "../../../Voxels/Types/VoxelModelCompiledData.types";
 export interface GeoemtryNodeConstructor<Data = any, Args = any> {
@@ -14,9 +13,8 @@ export declare abstract class GeoemtryNode<Data = any, Args = any> {
     vertexIndex: number;
     faceCount: number;
     vertexCount: number;
-    tool: VoxelMesherDataTool;
-    origin: Vector3Like;
+    builder: VoxelMesherDataTool;
     constructor(geometryPaletteId: number, geomtry: VoxelGeometryConstructor, data: Data, transform: VoxelGeometryTransform);
     abstract init(): void;
-    abstract add(tool: VoxelMesherDataTool, originHash: number, origin: Vector3Like, args: Args): void;
+    abstract add(args: Args): boolean;
 }

package/Mesher/Models/Nodes/GeometryNode.js

@@ -7,8 +7,7 @@ export class GeoemtryNode {
     vertexIndex = -1;
     faceCount = -1;
     vertexCount = -1;
-    tool;
-    origin;
+    builder;
     constructor(geometryPaletteId, geomtry, data, transform) {
         this.geometryPaletteId = geometryPaletteId;
         this.geomtry = geomtry;

package/Mesher/Models/Nodes/Ruled/BoxVoxelGeometryNode.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 { VoxelBoxGeometryNode } from "../../../../Models/VoxelModel.types";
 import { Quad } from "../../../Geomtry/Primitives/Quad";
-import { VoxelMesherDataTool } from "../../../../Mesher/Tools/VoxelMesherDataTool";
 import { BoxVoxelGometryArgs } from "../../../../Models/Input/BoxVoxelGometryInputs";
 import { GeoemtryNode } from "../GeometryNode";
 import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
@@ -16,12 +14,10 @@ export declare class BoxVoxelGometryNode extends GeoemtryNode<VoxelBoxGeometryNo
         Vec4Array,
         Vec4Array
     ]>;
-    worldLight: QuadScalarVertexData;
-    worldAO: QuadScalarVertexData;
     lightData: VoxelLightData;
     init(): void;
     isExposed(face: VoxelFaces): boolean;
     determineShading(face: VoxelFaces): void;
     shouldFlip(): boolean;
-    add(tool: VoxelMesherDataTool, originHash: number, origin: Vector3Like, args: BoxVoxelGometryArgs): void;
+    add(args: BoxVoxelGometryArgs): boolean;
 }

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

@@ -1,19 +1,16 @@
 import { BoxVoxelGometryInputs, } from "../../../../Models/Input/BoxVoxelGometryInputs";
-import { VoxelGeometryLookUp } from "../../VoxelGeometryLookUp";
 import { GeoemtryNode } from "../GeometryNode";
 import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcConstants";
 import { VoxelRelativeCubeIndexPositionMap } from "../../../../Models/Indexing/VoxelRelativeCubeIndex";
 import { GetBoxGeometryNodeData } from "../../Common/BoxGeometryNode";
-import { UpdateBounds } from "../../Common/BoundsFunctions";
 import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
 import { VoxelGeometryBuilder } from "../../../Geomtry/VoxelGeometryBuilder";
+import { VoxelModelConstructorRegister } from "../../../Models/VoxelModelConstructorRegister";
 const ArgIndexes = BoxVoxelGometryInputs.ArgIndexes;
 export class BoxVoxelGometryNode extends GeoemtryNode {
     quads;
     quadBounds = [];
     vertexWeights;
-    worldLight;
-    worldAO;
     lightData = new VoxelLightData();
     init() {
         this.faceCount = 6;
@@ -28,23 +25,25 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
         const faceIndexes = this.geomtry.faceCullMap[trueFaceIndex];
         if (!faceIndexes)
             return true;
-        const tool = this.tool;
+        const tool = this.builder;
         for (let positionIndex = 0; positionIndex < faceIndexes.length; positionIndex++) {
             const currentIndex = faceIndexes[positionIndex];
             const p = VoxelRelativeCubeIndexPositionMap[currentIndex];
-            const hashed = VoxelGeometryLookUp.getHash(tool.nVoxel, tool.position.x + p[0], tool.position.y + p[1], tool.position.z + p[2]);
-            if (VoxelGeometryLookUp.space.foundHash[hashed] < 2)
+            const hashed = this.builder.space.getHash(tool.nVoxel, tool.position.x + p[0], tool.position.y + p[1], tool.position.z + p[2]);
+            if (this.builder.space.foundHash[hashed] < 2)
                 continue;
-            const offsetBaseGometry = VoxelGeometryLookUp.space.getGeomtry(hashed);
-            const offsetConditonalGeometry = VoxelGeometryLookUp.space.getConditionalGeomtry(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];
-                    if (VoxelGeometryLookUp.isRulesless(geoId))
+                    if (VoxelModelConstructorRegister.rulesless[geoId])
                         continue;
                     const faceIndex = this.geomtry.cullIndex.getValue(geoId, currentIndex, trueFaceIndex);
                     if (faceIndex > -1 &&
-                        !VoxelGeometryLookUp.space.getConstructor(hashed)?.isShapeStateFaceTransparent(VoxelGeometryLookUp.space.modCache[hashed], VoxelGeometryLookUp.space.stateCache[hashed], geoId, faceIndex)) {
+                        !this.builder
+                            .space.getConstructor(hashed)
+                            ?.isShapeStateFaceTransparent(this.builder.space.modCache[hashed], this.builder.space.stateCache[hashed], geoId, faceIndex)) {
                         return false;
                     }
                 }
@@ -55,11 +54,13 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
                 const cond = offsetConditonalGeometry[i];
                 for (let k = 0; k < cond.length; k++) {
                     const geoId = cond[k];
-                    if (VoxelGeometryLookUp.isRulesless(geoId))
+                    if (VoxelModelConstructorRegister.rulesless[geoId])
                         continue;
                     const faceIndex = this.geomtry.cullIndex.getValue(geoId, currentIndex, trueFaceIndex);
                     if (faceIndex > -1 &&
-                        !VoxelGeometryLookUp.space.getConstructor(hashed)?.isCondtionalStateFaceTransparent(VoxelGeometryLookUp.space.modCache[hashed], VoxelGeometryLookUp.space.stateCache[hashed], geoId, faceIndex))
+                        !this.builder
+                            .space.getConstructor(hashed)
+                            ?.isCondtionalStateFaceTransparent(this.builder.space.modCache[hashed], this.builder.space.stateCache[hashed], geoId, faceIndex))
                         return false;
                 }
             }
@@ -67,11 +68,11 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
         return true;
     }
     determineShading(face) {
-        const tool = this.tool;
+        const tool = this.builder;
         const lightData = tool.lightData[face];
-        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[face][v]);
@@ -84,12 +85,12 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
             for (let positionIndex = 0; positionIndex < aoIndexes.length; positionIndex++) {
                 const currentIndex = aoIndexes[positionIndex];
                 const p = VoxelRelativeCubeIndexPositionMap[currentIndex];
-                const hashed = VoxelGeometryLookUp.getHash(tool.nVoxel, tool.position.x + p[0], tool.position.y + p[1], tool.position.z + p[2]);
-                if (VoxelGeometryLookUp.space.foundHash[hashed] < 2 ||
-                    VoxelGeometryLookUp.space.noCastAO[hashed] === 1)
+                const hashed = this.builder.space.getHash(tool.nVoxel, tool.position.x + p[0], tool.position.y + p[1], tool.position.z + p[2]);
+                if (this.builder.space.foundHash[hashed] < 2 ||
+                    this.builder.space.noCastAO[hashed] === 1)
                     continue;
-                const baseGeo = VoxelGeometryLookUp.space.getGeomtry(hashed);
-                const conditonalGeo = VoxelGeometryLookUp.space.getConditionalGeomtry(hashed);
+                const baseGeo = this.builder.space.getGeomtry(hashed);
+                const conditonalGeo = this.builder.space.getConditionalGeomtry(hashed);
                 if (!baseGeo && !conditonalGeo)
                     continue;
                 let length = 0;
@@ -120,18 +121,19 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
         }
     }
     shouldFlip() {
-        if (shouldCauseFlip(this.worldAO.vertices[0], this.worldAO.vertices[1], this.worldAO.vertices[2], this.worldAO.vertices[3]))
+        const worldAO = this.builder.vars.ao;
+        const worldLight = this.builder.vars.light;
+        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;
+    add(args) {
+        let added = false;
+        const tool = this.builder;
         for (let face = 0; face < 6; face++) {
             if (args[face][ArgIndexes.Enabled] && this.isExposed(face)) {
+                added = true;
                 tool.calculateFaceData(face);
                 this.determineShading(face);
                 const faceArgs = args[face];
@@ -151,11 +153,12 @@ 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, origin, quad);
-                UpdateBounds(tool, origin, this.quadBounds[face]);
+                VoxelGeometryBuilder.addQuad(tool, this.builder.origin, quad);
+                tool.updateBounds(this.quadBounds[face]);
             }
         }
-        this.worldLight.setAll(0);
-        this.worldAO.setAll(0);
+        this.builder.vars.ao.setAll(0);
+        this.builder.vars.light.setAll(0);
+        return added;
     }
 }

package/Mesher/Models/Nodes/Ruled/QuadVoxelGeometryNode.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 { GeoemtryNode } from "../GeometryNode";
 import { QuadVoxelGometryArgs } from "../../../../Models/Input/QuadVoxelGometryInputs";
 import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
@@ -11,13 +9,11 @@ export declare class QuadVoxelGometryNode extends GeoemtryNode<VoxelQuadGeometry
     quad: Quad;
     quadBounds: [Vec3Array, Vec3Array];
     vertexWeights: [Vec4Array, Vec4Array, Vec4Array, Vec4Array];
-    worldLight: QuadScalarVertexData;
-    worldAO: QuadScalarVertexData;
     closestFace: VoxelFaces;
     lightData: VoxelLightData;
     init(): void;
     isExposed(): boolean;
     determineShading(): void;
     shouldFlip(): boolean;
-    add(tool: VoxelMesherDataTool, originHash: number, origin: Vector3Like, args: QuadVoxelGometryArgs): void;
+    add(args: QuadVoxelGometryArgs): boolean;
 }

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

@@ -1,12 +1,10 @@
 import { VoxelFaces } from "../../../../Math";
 import { VoxelGeometryBuilder } from "../../../Geomtry/VoxelGeometryBuilder";
-import { VoxelGeometryLookUp } from "../../VoxelGeometryLookUp";
 import { GeoemtryNode } from "../GeometryNode";
 import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcConstants";
 import { VoxelRelativeCubeIndexPositionMap } from "../../../../Models/Indexing/VoxelRelativeCubeIndex";
 import { QuadVoxelGometryInputs, } from "../../../../Models/Input/QuadVoxelGometryInputs";
 import { GetQuadGeometryData } from "../../Common/QuadGeometryNode";
-import { UpdateBounds } from "../../Common/BoundsFunctions";
 import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
 const ArgIndexes = QuadVoxelGometryInputs.ArgIndexes;
 export class QuadVoxelGometryNode extends GeoemtryNode {
@@ -16,8 +14,6 @@ export class QuadVoxelGometryNode extends GeoemtryNode {
         [0, 0, 0],
     ];
     vertexWeights;
-    worldLight;
-    worldAO;
     closestFace;
     lightData = new VoxelLightData();
     init() {
@@ -34,18 +30,20 @@ export class QuadVoxelGometryNode extends GeoemtryNode {
         const faceIndexes = this.geomtry.faceCullMap[trueFaceIndex];
         if (!faceIndexes)
             return true;
-        const tool = this.tool;
+        const tool = this.builder;
         for (let positionIndex = 0; positionIndex < faceIndexes.length; positionIndex++) {
             const currentIndex = faceIndexes[positionIndex];
             const p = VoxelRelativeCubeIndexPositionMap[currentIndex];
-            const hashed = VoxelGeometryLookUp.getHash(tool.nVoxel, tool.position.x + p[0], tool.position.y + p[1], tool.position.z + p[2]);
-            const offsetBaseGometry = VoxelGeometryLookUp.space.getGeomtry(hashed);
-            const offsetConditonalGeometry = VoxelGeometryLookUp.space.getConditionalGeomtry(hashed);
+            const hashed = this.builder.space.getHash(tool.nVoxel, tool.position.x + p[0], tool.position.y + p[1], tool.position.z + p[2]);
+            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 faceIndex = this.geomtry.cullIndex.getValue(offsetBaseGometry[i], currentIndex, trueFaceIndex);
                     if (faceIndex > -1 &&
-                        !VoxelGeometryLookUp.space.getConstructor(hashed)?.isShapeStateFaceTransparent(VoxelGeometryLookUp.space.modCache[hashed], VoxelGeometryLookUp.space.stateCache[hashed], offsetBaseGometry[i], faceIndex)) {
+                        !this.builder
+                            .space.getConstructor(hashed)
+                            ?.isShapeStateFaceTransparent(this.builder.space.modCache[hashed], this.builder.space.stateCache[hashed], offsetBaseGometry[i], faceIndex)) {
                         return false;
                     }
                 }
@@ -57,7 +55,9 @@ export class QuadVoxelGometryNode extends GeoemtryNode {
                 for (let k = 0; k < cond.length; k++) {
                     const faceIndex = this.geomtry.cullIndex.getValue(cond[k], currentIndex, trueFaceIndex);
                     if (faceIndex > -1 &&
-                        !VoxelGeometryLookUp.space.getConstructor(hashed)?.isCondtionalStateFaceTransparent(VoxelGeometryLookUp.space.modCache[hashed], VoxelGeometryLookUp.space.stateCache[hashed], cond[i], faceIndex))
+                        !this.builder
+                            .space.getConstructor(hashed)
+                            ?.isCondtionalStateFaceTransparent(this.builder.space.modCache[hashed], this.builder.space.stateCache[hashed], cond[i], faceIndex))
                         return false;
                 }
             }
@@ -65,11 +65,11 @@ export class QuadVoxelGometryNode extends GeoemtryNode {
         return true;
     }
     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 = tool.vars.light;
+        const worldAO = tool.vars.ao;
         for (let v = 0; v < 4; v++) {
             worldAO.vertices[v] = 0;
             worldLight.vertices[v] = getInterpolationValue(lightData, this.vertexWeights[v]);
@@ -82,11 +82,11 @@ export class QuadVoxelGometryNode extends GeoemtryNode {
             for (let positionIndex = 0; positionIndex < aoIndexes.length; positionIndex++) {
                 const currentIndex = aoIndexes[positionIndex];
                 const p = VoxelRelativeCubeIndexPositionMap[currentIndex];
-                const hashed = VoxelGeometryLookUp.getHash(tool.nVoxel, tool.position.x + p[0], tool.position.y + p[1], tool.position.z + p[2]);
-                if (VoxelGeometryLookUp.space.noCastAO[hashed] === 1)
+                const hashed = this.builder.space.getHash(tool.nVoxel, tool.position.x + p[0], tool.position.y + p[1], tool.position.z + p[2]);
+                if (this.builder.space.noCastAO[hashed] === 1)
                     continue;
-                const baseGeo = VoxelGeometryLookUp.space.getGeomtry(hashed);
-                const conditonalGeo = VoxelGeometryLookUp.space.getConditionalGeomtry(hashed);
+                const baseGeo = this.builder.space.getGeomtry(hashed);
+                const conditonalGeo = this.builder.space.getConditionalGeomtry(hashed);
                 if (!baseGeo && !conditonalGeo)
                     continue;
                 let length = 0;
@@ -117,40 +117,41 @@ export class QuadVoxelGometryNode extends GeoemtryNode {
         }
     }
     shouldFlip() {
-        if (shouldCauseFlip(this.worldAO.vertices[0], this.worldAO.vertices[1], this.worldAO.vertices[2], this.worldAO.vertices[3]))
+        const worldAO = this.builder.vars.ao;
+        const worldLight = this.builder.vars.light;
+        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] && this.isExposed()) {
-            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;
+        if (!this.isExposed())
+            return false;
+        this.builder.calculateFaceData(this.closestFace);
+        this.determineShading();
+        const quad = this.quad;
+        quad.flip = this.shouldFlip() || args[ArgIndexes.Fliped];
+        this.builder.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(this.builder, this.builder.origin, quad);
+        this.builder.updateBounds(this.quadBounds);
+        this.builder.vars.light.setAll(0);
+        this.builder.vars.ao.setAll(0);
+        return true;
     }
 }

package/Mesher/Models/Nodes/Ruleless/RulelessBoxVoxelGeometryNode.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 { VoxelBoxGeometryNode } from "../../../../Models/VoxelModel.types";
 import { Quad } from "../../../Geomtry/Primitives/Quad";
-import { VoxelMesherDataTool } from "../../../../Mesher/Tools/VoxelMesherDataTool";
 import { BoxVoxelGometryArgs } from "../../../../Models/Input/BoxVoxelGometryInputs";
 import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
 import { GeoemtryNode } from "../GeometryNode";
@@ -16,11 +14,9 @@ export declare class RulelessBoxVoxelGeometryNode extends GeoemtryNode<VoxelBoxG
         Vec4Array,
         Vec4Array
     ]>;
-    worldLight: QuadScalarVertexData;
-    worldAO: QuadScalarVertexData;
     lightData: VoxelLightData;
     init(): void;
     determineShading(face: VoxelFaces): void;
     shouldFlip(): boolean;
-    add(tool: VoxelMesherDataTool, originHash: number, origin: Vector3Like, args: BoxVoxelGometryArgs): void;
+    add(args: BoxVoxelGometryArgs): boolean;
 }

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

@@ -4,14 +4,11 @@ import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcC
 import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
 import { GeoemtryNode } from "../GeometryNode";
 import { GetBoxGeometryNodeData } from "../../Common/BoxGeometryNode";
-import { UpdateBounds } from "../../Common/BoundsFunctions";
 const ArgIndexes = BoxVoxelGometryInputs.ArgIndexes;
 export class RulelessBoxVoxelGeometryNode extends GeoemtryNode {
     quads;
     quadBounds = [];
     vertexWeights;
-    worldLight;
-    worldAO;
     lightData = new VoxelLightData();
     init() {
         this.faceCount = 6;
@@ -22,11 +19,11 @@ export class RulelessBoxVoxelGeometryNode extends GeoemtryNode {
         this.vertexWeights = vertexWeights;
     }
     determineShading(face) {
-        const tool = this.tool;
+        const tool = this.builder;
         const lightData = tool.lightData[face];
-        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[face][v]);
@@ -35,18 +32,19 @@ export class RulelessBoxVoxelGeometryNode 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;
+    add(args) {
+        const tool = this.builder;
+        let added = false;
         for (let face = 0; face < 6; face++) {
             if (args[face][ArgIndexes.Enabled]) {
+                added = true;
                 tool.calculateFaceData(face);
                 this.determineShading(face);
                 const faceArgs = args[face];
@@ -66,11 +64,12 @@ 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, origin, quad);
-                UpdateBounds(tool, origin, this.quadBounds[face]);
+                VoxelGeometryBuilder.addQuad(tool, tool.position, quad);
+                this.builder.updateBounds(this.quadBounds[face]);
             }
         }
-        this.worldLight.setAll(0);
-        this.worldAO.setAll(0);
+        this.builder.vars.light.setAll(0);
+        this.builder.vars.ao.setAll(0);
+        return added;
     }
 }