@divinevoxel/vlox 0.0.71 → 0.0.73

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,11 @@ export declare class BoxVoxelGometryNode extends GeoemtryNode<VoxelBoxGeometryNo
         Vec4Array,
         Vec4Array
     ]>;
-    worldLight: QuadScalarVertexData;
-    worldAO: QuadScalarVertexData;
+    _wasAOShaded: boolean;
     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,17 @@
 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;
+    _wasAOShaded = false;
     lightData = new VoxelLightData();
     init() {
         this.faceCount = 6;
@@ -28,23 +26,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 +55,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 +69,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 +86,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;
@@ -98,21 +100,28 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
                     length = baseGeo.length;
                     for (let geoIndex = 0; geoIndex < length; geoIndex++) {
                         if (this.geomtry.aoIndex.getValue(baseGeo[geoIndex], currentIndex, trueVertexIndex)) {
-                            worldAO.vertices[v] = 1;
-                            shaded = true;
-                            break;
+                            this._wasAOShaded = true;
+                            worldAO.vertices[v]++;
+                            if (worldAO.vertices[v] > 4) {
+                                shaded = true;
+                                break;
+                            }
                         }
                     }
                 }
-                if (!conditonalGeo)
+                if (!conditonalGeo || shaded)
                     continue;
                 length = conditonalGeo.length;
                 for (let condtionsIndex = 0; condtionsIndex < length; condtionsIndex++) {
                     const condiotnalength = conditonalGeo[condtionsIndex].length;
                     for (let geoIndex = 0; geoIndex < condiotnalength; geoIndex++) {
                         if (this.geomtry.aoIndex.getValue(conditonalGeo[condtionsIndex][geoIndex], currentIndex, trueVertexIndex)) {
-                            worldAO.vertices[v] = 1;
-                            break;
+                            this._wasAOShaded = true;
+                            worldAO.vertices[v]++;
+                            if (worldAO.vertices[v] > 4) {
+                                shaded = true;
+                                break;
+                            }
                         }
                     }
                 }
@@ -120,18 +129,22 @@ 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;
+        if (shouldCauseFlip(worldAO.vertices[0], worldAO.vertices[1], worldAO.vertices[2], worldAO.vertices[3]) &&
+            this._wasAOShaded)
             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])));
+        if (this._wasAOShaded)
+            return false;
+        const worldLight = this.builder.vars.light;
+        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 +164,13 @@ 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);
+        this._wasAOShaded = false;
+        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;
     }
 }

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;
 }