@divinevoxel/vlox 0.0.4 → 0.0.6

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

@@ -1,24 +1,18 @@
 import { GeoemtryNode } from "../../GeometryNode";
-let flowAnimationState = 0;
 import { CompassAngles } from "@amodx/math";
-import { Quad } from "@amodx/meshing/Primitives/Quad.js";
-import { QuadVerticies } from "@amodx/meshing/Geometry.types.js";
-import { QuadScalarVertexData } from "@amodx/meshing/Primitives/QuadVertexData";
+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 { VoxelGeometry } from "../../../../../Mesher/Geometry/VoxelGeometry";
-import { LightData } from "../../../../../Voxels/LightData";
 import { shouldCauseFlip } from "../../../Common/Calc/CalcConstants";
-import { FlowGradient } from "./FlowGradient";
+import { getFlowAngle, getFlowGradient, FlowVerticies } from "./FlowGradient";
 import { GetBoxGeometryNodeData } from "../../../Common/BoxGeometryNode";
+import { VoxelLightData } from "../../../../../Voxels/Cursor/VoxelLightData";
+import { VoxelGeometryBuilder } from "../../../../Geomtry/VoxelGeometryBuilder";
 const vertexValue = new QuadScalarVertexData();
 const vertexLevel = new QuadScalarVertexData();
-var FlowStates;
-(function (FlowStates) {
-    FlowStates[FlowStates["None"] = 0] = "None";
-    FlowStates[FlowStates["Down"] = 1] = "Down";
-    FlowStates[FlowStates["Up"] = 2] = "Up";
-})(FlowStates || (FlowStates = {}));
+const lightData = new VoxelLightData();
 const waterHeight = 6 / 7;
 const quadRotations = {
     [CompassAngles.North]: Quad.RotateUvs(Quad.FullUVs, CompassAngles.North),
@@ -30,61 +24,6 @@ const quadRotations = {
     [CompassAngles.SouthWest]: Quad.RotateUvs(Quad.FullUVs, CompassAngles.SouthWest),
     [CompassAngles.SouthEast]: Quad.RotateUvs(Quad.FullUVs, CompassAngles.SouthEast),
 };
-const getFlowAngle = () => {
-    if (vertexLevel.isAllEqualTo(15)) {
-        flowAnimationState = FlowStates.None;
-        return 0;
-    }
-    const upRight = vertexLevel.vertices[QuadVerticies.TopRight];
-    const upLeft = vertexLevel.vertices[QuadVerticies.TopLeft];
-    const downLeft = vertexLevel.vertices[QuadVerticies.BottomLeft];
-    const downRight = vertexLevel.vertices[QuadVerticies.BottomRight];
-    const upEqual = upRight == upLeft;
-    const downEqual = downRight == downLeft;
-    const rightEqual = upRight == downRight;
-    const leftEqual = upLeft == downLeft;
-    if (upEqual && downEqual) {
-        if (upRight < downRight) {
-            flowAnimationState = FlowStates.Up;
-            return CompassAngles.North;
-        }
-        if (upRight > downRight) {
-            flowAnimationState = FlowStates.Up;
-            return CompassAngles.South;
-        }
-    }
-    if (rightEqual && leftEqual) {
-        if (upRight < upLeft) {
-            flowAnimationState = FlowStates.Up;
-            return CompassAngles.East;
-        }
-        if (upRight > upLeft) {
-            flowAnimationState = FlowStates.Up;
-            return CompassAngles.West;
-        }
-    }
-    if ((downRight < upRight && downRight < upLeft && downRight < downLeft) ||
-        (upLeft > upRight && upLeft > downRight && upLeft > downLeft)) {
-        flowAnimationState = FlowStates.Up;
-        return CompassAngles.SouthEast;
-    }
-    if ((upLeft < upRight && upLeft < downRight && upLeft < downLeft) ||
-        (downRight > upRight && downRight > upLeft && downRight > downLeft)) {
-        flowAnimationState = FlowStates.Up;
-        return CompassAngles.NorthWest;
-    }
-    if ((upRight < downRight && upRight < upLeft && upRight < downLeft) ||
-        (downLeft > downRight && downLeft > upLeft && downLeft > upRight)) {
-        flowAnimationState = FlowStates.Up;
-        return CompassAngles.NorthEast;
-    }
-    if ((downLeft < downRight && downLeft < upLeft && downLeft < upRight) ||
-        (upRight > downRight && upRight > upLeft && upRight > downLeft)) {
-        flowAnimationState = FlowStates.Up;
-        return CompassAngles.SouthWest;
-    }
-    return CompassAngles.North;
-};
 const uvs = [
     [1, 1],
     [0, 1],
@@ -95,9 +34,14 @@ const { quads: Quads, vertexWeights, quadBounds, } = GetBoxGeometryNodeData([
     [0, 0, 0],
     [1, waterHeight, 1],
 ], {});
+Quads[VoxelFaces.Up].setUVs(uvs);
+Quads[VoxelFaces.Down].setUVs(uvs);
 export class LiquidGeometryNode extends GeoemtryNode {
     worldLight;
-    init() { }
+    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);
         if (!nv ||
@@ -115,8 +59,8 @@ export class LiquidGeometryNode extends GeoemtryNode {
         }
     }
     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])));
+        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])));
     }
     add(tool, originHash, origin, args) {
         vertexLevel.setAll(15);
@@ -124,19 +68,20 @@ export class LiquidGeometryNode extends GeoemtryNode {
         this.tool = tool;
         this.tool = tool;
         this.origin = tool.position;
-        //     this.worldAO = tool.getWorldAO();
-        this.worldLight = tool.getWorldLight();
+        this.worldLight = tool.vars.light;
         let upFaceExposed = false;
         if (this.isExposed(VoxelFaces.Up)) {
-            FlowGradient.calculate(tool, vertexLevel);
+            upFaceExposed = true;
+            getFlowGradient(tool, vertexLevel);
             const quad = Quads[VoxelFaces.Up];
             tool.calculateFaceData(VoxelFaces.Up);
             this.determineShading(VoxelFaces.Up);
             quad.flip = this.shouldFlip();
-            tool.setTexture(args.flowTexture);
+            tool.vars.textureIndex = args.stillTexture;
             vertexValue.set(vertexLevel.vertices[0] / 7, vertexLevel.vertices[1] / 7, vertexLevel.vertices[2] / 7, vertexLevel.vertices[3] / 7);
-            const uvAngle = getFlowAngle();
-            const uvSet = quadRotations[uvAngle];
+            const flowData = getFlowAngle(vertexLevel);
+            const uvSet = quadRotations[flowData[0]];
+            tool.vars.animation.setAll(flowData[1]);
             quad.uvs.vertices[QuadVerticies.TopRight].x = uvSet[0][0];
             quad.uvs.vertices[QuadVerticies.TopRight].y = uvSet[0][1];
             quad.uvs.vertices[QuadVerticies.TopLeft].x = uvSet[1][0];
@@ -149,120 +94,118 @@ 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;
-            tool.getAnimationData().setAll(flowAnimationState);
-            VoxelGeometry.addQuad(tool, origin, quad);
-            upFaceExposed = true;
+            VoxelGeometryBuilder.addQuad(tool, origin, quad);
             UpdateBounds(tool, origin, quadBounds[VoxelFaces.Up]);
         }
         if (this.isExposed(VoxelFaces.Down)) {
-            tool.setTexture(args.flowTexture);
+            tool.vars.textureIndex = args.stillTexture;
             const quad = Quads[VoxelFaces.Down];
             tool.calculateFaceData(VoxelFaces.Down);
             this.determineShading(VoxelFaces.Down);
             quad.flip = this.shouldFlip();
-            tool.setTexture(args.flowTexture);
-            VoxelGeometry.addQuad(tool, origin, quad);
+            tool.vars.textureIndex = args.stillTexture;
+            VoxelGeometryBuilder.addQuad(tool, origin, quad);
             UpdateBounds(tool, origin, quadBounds[VoxelFaces.Down]);
         }
         if (this.isExposed(VoxelFaces.North)) {
-            tool.setTexture(args.flowTexture);
+            tool.vars.textureIndex = args.stillTexture;
             const quad = Quads[VoxelFaces.North];
-            tool.getAnimationData().setAll(1);
+            tool.vars.animation.setAll(1);
             tool.calculateFaceData(VoxelFaces.North);
             this.determineShading(VoxelFaces.North);
             quad.flip = this.shouldFlip();
             if (upFaceExposed) {
                 quad.positions.vertices[QuadVerticies.TopRight].y =
-                    vertexValue.vertices[QuadVerticies.TopRight] * waterHeight;
+                    vertexValue.vertices[FlowVerticies.NorthWest] * waterHeight;
                 quad.positions.vertices[QuadVerticies.TopLeft].y =
-                    vertexValue.vertices[QuadVerticies.TopLeft] * waterHeight;
+                    vertexValue.vertices[FlowVerticies.NorthEast] * waterHeight;
                 quad.uvs.vertices[QuadVerticies.TopRight].y =
-                    vertexValue.vertices[QuadVerticies.TopRight];
+                    vertexValue.vertices[FlowVerticies.NorthWest];
                 quad.uvs.vertices[QuadVerticies.TopLeft].y =
-                    vertexValue.vertices[QuadVerticies.TopLeft];
+                    vertexValue.vertices[FlowVerticies.NorthEast];
             }
             else {
                 quad.positions.vertices[QuadVerticies.TopRight].y = 1;
                 quad.positions.vertices[QuadVerticies.TopLeft].y = 1;
                 quad.setUVs(uvs);
-                UpdateBounds(tool, origin, quadBounds[VoxelFaces.North]);
             }
-            VoxelGeometry.addQuad(tool, origin, quad);
+            VoxelGeometryBuilder.addQuad(tool, origin, quad);
+            UpdateBounds(tool, origin, quadBounds[VoxelFaces.North]);
         }
         if (this.isExposed(VoxelFaces.South)) {
-            tool.setTexture(args.flowTexture);
+            tool.vars.textureIndex = args.stillTexture;
             const quad = Quads[VoxelFaces.South];
-            tool.getAnimationData().setAll(1);
+            tool.vars.animation.setAll(1);
             tool.calculateFaceData(VoxelFaces.South);
             this.determineShading(VoxelFaces.South);
             quad.flip = this.shouldFlip();
             if (upFaceExposed) {
                 quad.positions.vertices[QuadVerticies.TopRight].y =
-                    vertexValue.vertices[QuadVerticies.BottomRight] * waterHeight;
+                    vertexValue.vertices[FlowVerticies.SouthEsat] * waterHeight;
                 quad.positions.vertices[QuadVerticies.TopLeft].y =
-                    vertexValue.vertices[QuadVerticies.BottomLeft] * waterHeight;
+                    vertexValue.vertices[FlowVerticies.SouthWest] * waterHeight;
                 quad.uvs.vertices[QuadVerticies.TopRight].y =
-                    vertexValue.vertices[QuadVerticies.BottomRight];
+                    vertexValue.vertices[FlowVerticies.SouthEsat];
                 quad.uvs.vertices[QuadVerticies.TopLeft].y =
-                    vertexValue.vertices[QuadVerticies.BottomLeft];
+                    vertexValue.vertices[FlowVerticies.SouthWest];
             }
             else {
                 quad.positions.vertices[QuadVerticies.TopLeft].y = 1;
                 quad.positions.vertices[QuadVerticies.TopRight].y = 1;
                 quad.setUVs(uvs);
-                UpdateBounds(tool, origin, quadBounds[VoxelFaces.South]);
             }
-            VoxelGeometry.addQuad(tool, origin, quad);
+            VoxelGeometryBuilder.addQuad(tool, origin, quad);
+            UpdateBounds(tool, origin, quadBounds[VoxelFaces.South]);
         }
         if (this.isExposed(VoxelFaces.East)) {
-            tool.setTexture(args.flowTexture);
+            tool.vars.textureIndex = args.stillTexture;
             const quad = Quads[VoxelFaces.East];
-            tool.getAnimationData().setAll(1);
+            tool.vars.animation.setAll(1);
             tool.calculateFaceData(VoxelFaces.East);
             this.determineShading(VoxelFaces.East);
-            quad.flip = this.shouldFlip();
+            //  quad.flip = this.shouldFlip();
             if (upFaceExposed) {
                 quad.positions.vertices[QuadVerticies.TopRight].y =
-                    vertexValue.vertices[QuadVerticies.TopRight] * waterHeight;
+                    vertexValue.vertices[FlowVerticies.NorthEast] * waterHeight;
                 quad.positions.vertices[QuadVerticies.TopLeft].y =
-                    vertexValue.vertices[QuadVerticies.BottomRight] * waterHeight;
+                    vertexValue.vertices[FlowVerticies.SouthEsat] * waterHeight;
                 quad.uvs.vertices[QuadVerticies.TopRight].y =
-                    vertexValue.vertices[QuadVerticies.TopRight];
+                    vertexValue.vertices[FlowVerticies.SouthEsat];
                 quad.uvs.vertices[QuadVerticies.TopLeft].y =
-                    vertexValue.vertices[QuadVerticies.BottomRight];
+                    vertexValue.vertices[FlowVerticies.NorthEast];
             }
             else {
                 quad.positions.vertices[QuadVerticies.TopLeft].y = 1;
                 quad.positions.vertices[QuadVerticies.TopRight].y = 1;
                 quad.setUVs(uvs);
-                UpdateBounds(tool, origin, quadBounds[VoxelFaces.East]);
             }
-            VoxelGeometry.addQuad(tool, origin, quad);
+            VoxelGeometryBuilder.addQuad(tool, origin, quad);
+            UpdateBounds(tool, origin, quadBounds[VoxelFaces.East]);
         }
         if (this.isExposed(VoxelFaces.West)) {
-            tool.setTexture(args.flowTexture);
+            tool.vars.textureIndex = args.stillTexture;
             const quad = Quads[VoxelFaces.West];
-            tool.getAnimationData().setAll(1);
+            tool.vars.animation.setAll(1);
             tool.calculateFaceData(VoxelFaces.West);
             this.determineShading(VoxelFaces.West);
             quad.flip = this.shouldFlip();
             if (upFaceExposed) {
                 quad.positions.vertices[QuadVerticies.TopRight].y =
-                    vertexValue.vertices[QuadVerticies.TopLeft] * waterHeight;
+                    vertexValue.vertices[FlowVerticies.SouthWest] * waterHeight;
                 quad.positions.vertices[QuadVerticies.TopLeft].y =
-                    vertexValue.vertices[QuadVerticies.BottomLeft] * waterHeight;
+                    vertexValue.vertices[FlowVerticies.NorthWest] * waterHeight;
                 quad.uvs.vertices[QuadVerticies.TopRight].y =
-                    vertexValue.vertices[QuadVerticies.TopLeft];
+                    vertexValue.vertices[FlowVerticies.SouthWest];
                 quad.uvs.vertices[QuadVerticies.TopLeft].y =
-                    vertexValue.vertices[QuadVerticies.BottomLeft];
+                    vertexValue.vertices[FlowVerticies.NorthWest];
             }
             else {
                 quad.positions.vertices[QuadVerticies.TopLeft].y = 1;
                 quad.positions.vertices[QuadVerticies.TopRight].y = 1;
                 quad.setUVs(uvs);
-                UpdateBounds(tool, origin, quadBounds[VoxelFaces.West]);
             }
-            VoxelGeometry.addQuad(tool, origin, quad);
+            VoxelGeometryBuilder.addQuad(tool, origin, quad);
+            UpdateBounds(tool, origin, quadBounds[VoxelFaces.West]);
         }
         this.worldLight.setAll(0);
     }

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

@@ -1,7 +1,7 @@
 import { VoxelMesherDataTool } from "../../../Mesher/Tools/VoxelMesherDataTool";
 import { Vector3Like } from "@amodx/math";
 import { VoxelGeometryConstructor } from "./VoxelGeometryConstructor";
-import { VoxelGeometryTransform } from "../../../Voxels/VoxelSyncData";
+import { VoxelGeometryTransform } from "../../../Voxels/Types/VoxelModelCompiledData.types";
 export interface GeoemtryNodeConstructor<Data = any, Args = any> {
     new (geometryPaletteId: number, geomtry: VoxelGeometryConstructor, data: Data, transform: VoxelGeometryTransform): GeoemtryNode<Data, Args>;
 }

package/Mesher/Models/Nodes/Ruled/BoxVoxelGeometryNode.d.ts

@@ -1,11 +1,12 @@
 import { Vec3Array, Vec4Array, Vector3Like } from "@amodx/math";
 import { VoxelFaces } from "../../../../Math";
-import { QuadScalarVertexData } from "@amodx/meshing";
+import { QuadScalarVertexData } from "../../../Geomtry/Primitives/QuadVertexData";
 import { VoxelBoxGeometryNode } from "../../../../Models/VoxelModel.types";
-import { Quad } from "@amodx/meshing/Primitives/Quad";
+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";
 export declare class BoxVoxelGometryNode extends GeoemtryNode<VoxelBoxGeometryNode, BoxVoxelGometryArgs> {
     quads: Record<VoxelFaces, Quad>;
     quadBounds: [Vec3Array, Vec3Array][];
@@ -17,6 +18,7 @@ export declare class BoxVoxelGometryNode extends GeoemtryNode<VoxelBoxGeometryNo
     ]>;
     worldLight: QuadScalarVertexData;
     worldAO: QuadScalarVertexData;
+    lightData: VoxelLightData;
     init(): void;
     isExposed(face: VoxelFaces): boolean;
     determineShading(face: VoxelFaces): void;

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

@@ -1,12 +1,12 @@
-import { VoxelGeometry } from "../../../../Mesher/Geometry/VoxelGeometry";
 import { BoxVoxelGometryInputs, } from "../../../../Models/Input/BoxVoxelGometryInputs";
 import { VoxelGeometryLookUp } from "../../VoxelGeometryLookUp";
 import { GeoemtryNode } from "../GeometryNode";
 import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcConstants";
-import { LightData } from "../../../../Voxels/LightData";
 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";
 const ArgIndexes = BoxVoxelGometryInputs.ArgIndexes;
 export class BoxVoxelGometryNode extends GeoemtryNode {
     quads;
@@ -14,6 +14,7 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
     vertexWeights;
     worldLight;
     worldAO;
+    lightData = new VoxelLightData();
     init() {
         this.faceCount = 6;
         this.vertexCount = this.faceCount * 4;
@@ -32,8 +33,8 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
             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.geometryCache[hashed];
-            const offsetConditonalGeometry = VoxelGeometryLookUp.conditionalGeometryCache[hashed];
+            const offsetBaseGometry = VoxelGeometryLookUp.space.getGeomtry(hashed);
+            const offsetConditonalGeometry = VoxelGeometryLookUp.space.getConditionalGeomtry(hashed);
             if (offsetBaseGometry) {
                 for (let i = 0; i < offsetBaseGometry.length; i++) {
                     const geoId = offsetBaseGometry[i];
@@ -41,7 +42,7 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
                         continue;
                     const faceIndex = this.geomtry.cullIndex.getValue(geoId, currentIndex, trueFaceIndex);
                     if (faceIndex > -1 &&
-                        !VoxelGeometryLookUp.voxelHash[hashed].isShapeStateFaceTransparent(VoxelGeometryLookUp.modCache[hashed], VoxelGeometryLookUp.stateCache[hashed], geoId, faceIndex)) {
+                        !VoxelGeometryLookUp.space.getConstructor(hashed)?.isShapeStateFaceTransparent(VoxelGeometryLookUp.space.modCache[hashed], VoxelGeometryLookUp.space.stateCache[hashed], geoId, faceIndex)) {
                         return false;
                     }
                 }
@@ -56,7 +57,7 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
                         continue;
                     const faceIndex = this.geomtry.cullIndex.getValue(geoId, currentIndex, trueFaceIndex);
                     if (faceIndex > -1 &&
-                        !VoxelGeometryLookUp.voxelHash[hashed].isCondtionalStateFaceTransparent(VoxelGeometryLookUp.modCache[hashed], VoxelGeometryLookUp.stateCache[hashed], geoId, faceIndex))
+                        !VoxelGeometryLookUp.space.getConstructor(hashed)?.isCondtionalStateFaceTransparent(VoxelGeometryLookUp.space.modCache[hashed], VoxelGeometryLookUp.space.stateCache[hashed], geoId, faceIndex))
                         return false;
                 }
             }
@@ -82,10 +83,10 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
                 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.noCastAO[hashed] === true)
+                if (VoxelGeometryLookUp.space.noCastAO[hashed] === 1)
                     continue;
-                const baseGeo = VoxelGeometryLookUp.geometryCache[hashed];
-                const conditonalGeo = VoxelGeometryLookUp.conditionalGeometryCache[hashed];
+                const baseGeo = VoxelGeometryLookUp.space.getGeomtry(hashed);
+                const conditonalGeo = VoxelGeometryLookUp.space.getConditionalGeomtry(hashed);
                 if (!baseGeo && !conditonalGeo)
                     continue;
                 let length = 0;
@@ -118,14 +119,14 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
     shouldFlip() {
         if (shouldCauseFlip(this.worldAO.vertices[0], this.worldAO.vertices[1], this.worldAO.vertices[2], this.worldAO.vertices[3]))
             return true;
-        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])));
+        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])));
     }
     add(tool, originHash, origin, args) {
         this.tool = tool;
         this.origin = tool.position;
-        this.worldAO = tool.getWorldAO();
-        this.worldLight = tool.getWorldLight();
+        this.worldAO = tool.vars.ao;
+        this.worldLight = tool.vars.light;
         for (let face = 0; face < 6; face++) {
             if (args[face][ArgIndexes.Enabled] && this.isExposed(face)) {
                 tool.calculateFaceData(face);
@@ -133,7 +134,7 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
                 const faceArgs = args[face];
                 const quad = this.quads[face];
                 quad.flip = this.shouldFlip() || faceArgs[ArgIndexes.Fliped];
-                tool.setTexture(faceArgs[ArgIndexes.Texture]);
+                tool.vars.textureIndex = faceArgs[ArgIndexes.Texture];
                 const uvs = faceArgs[ArgIndexes.UVs];
                 //1
                 quad.uvs.vertices[0].x = uvs[0][0];
@@ -147,7 +148,7 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
                 //4
                 quad.uvs.vertices[3].x = uvs[3][0];
                 quad.uvs.vertices[3].y = uvs[3][1];
-                VoxelGeometry.addQuad(tool, origin, quad);
+                VoxelGeometryBuilder.addQuad(tool, origin, quad);
                 UpdateBounds(tool, origin, this.quadBounds[face]);
             }
         }

package/Mesher/Models/Nodes/Ruled/QuadVoxelGeometryNode.d.ts

@@ -1,11 +1,12 @@
 import { Vec3Array, Vec4Array, Vector3Like } from "@amodx/math";
 import { VoxelFaces } from "../../../../Math";
-import { QuadScalarVertexData } from "@amodx/meshing";
+import { QuadScalarVertexData } from "../../../Geomtry/Primitives/QuadVertexData";
 import { VoxelQuadGeometryNode } from "../../../../Models/VoxelModel.types";
-import { Quad } from "@amodx/meshing/Primitives/Quad";
+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";
 export declare class QuadVoxelGometryNode extends GeoemtryNode<VoxelQuadGeometryNode, QuadVoxelGometryArgs> {
     quad: Quad;
     quadBounds: [Vec3Array, Vec3Array];
@@ -13,6 +14,7 @@ export declare class QuadVoxelGometryNode extends GeoemtryNode<VoxelQuadGeometry
     worldLight: QuadScalarVertexData;
     worldAO: QuadScalarVertexData;
     closestFace: VoxelFaces;
+    lightData: VoxelLightData;
     init(): void;
     isExposed(): boolean;
     determineShading(): void;

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

@@ -1,13 +1,13 @@
 import { VoxelFaces } from "../../../../Math";
-import { VoxelGeometry } from "../../../../Mesher/Geometry/VoxelGeometry";
+import { VoxelGeometryBuilder } from "../../../Geomtry/VoxelGeometryBuilder";
 import { VoxelGeometryLookUp } from "../../VoxelGeometryLookUp";
 import { GeoemtryNode } from "../GeometryNode";
 import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcConstants";
-import { LightData } from "../../../../Voxels/LightData";
 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 {
     quad;
@@ -19,6 +19,7 @@ export class QuadVoxelGometryNode extends GeoemtryNode {
     worldLight;
     worldAO;
     closestFace;
+    lightData = new VoxelLightData();
     init() {
         this.faceCount = 6;
         this.vertexCount = this.faceCount * 4;
@@ -38,13 +39,13 @@ export class QuadVoxelGometryNode extends GeoemtryNode {
             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.geometryCache[hashed];
-            const offsetConditonalGeometry = VoxelGeometryLookUp.conditionalGeometryCache[hashed];
+            const offsetBaseGometry = VoxelGeometryLookUp.space.getGeomtry(hashed);
+            const offsetConditonalGeometry = VoxelGeometryLookUp.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.voxelHash[hashed].isShapeStateFaceTransparent(VoxelGeometryLookUp.modCache[hashed], VoxelGeometryLookUp.stateCache[hashed], offsetBaseGometry[i], faceIndex)) {
+                        !VoxelGeometryLookUp.space.getConstructor(hashed)?.isShapeStateFaceTransparent(VoxelGeometryLookUp.space.modCache[hashed], VoxelGeometryLookUp.space.stateCache[hashed], offsetBaseGometry[i], faceIndex)) {
                         return false;
                     }
                 }
@@ -56,7 +57,7 @@ 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.voxelHash[hashed].isCondtionalStateFaceTransparent(VoxelGeometryLookUp.modCache[hashed], VoxelGeometryLookUp.stateCache[hashed], cond[i], faceIndex))
+                        !VoxelGeometryLookUp.space.getConstructor(hashed)?.isCondtionalStateFaceTransparent(VoxelGeometryLookUp.space.modCache[hashed], VoxelGeometryLookUp.space.stateCache[hashed], cond[i], faceIndex))
                         return false;
                 }
             }
@@ -82,10 +83,10 @@ export class QuadVoxelGometryNode extends GeoemtryNode {
                 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.noCastAO[hashed] === true)
+                if (VoxelGeometryLookUp.space.noCastAO[hashed] === 1)
                     continue;
-                const baseGeo = VoxelGeometryLookUp.geometryCache[hashed];
-                const conditonalGeo = VoxelGeometryLookUp.conditionalGeometryCache[hashed];
+                const baseGeo = VoxelGeometryLookUp.space.getGeomtry(hashed);
+                const conditonalGeo = VoxelGeometryLookUp.space.getConditionalGeomtry(hashed);
                 if (!baseGeo && !conditonalGeo)
                     continue;
                 let length = 0;
@@ -118,20 +119,20 @@ export class QuadVoxelGometryNode extends GeoemtryNode {
     shouldFlip() {
         if (shouldCauseFlip(this.worldAO.vertices[0], this.worldAO.vertices[1], this.worldAO.vertices[2], this.worldAO.vertices[3]))
             return true;
-        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])));
+        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])));
     }
     add(tool, originHash, origin, args) {
         this.tool = tool;
         this.origin = tool.position;
-        this.worldAO = tool.getWorldAO();
-        this.worldLight = tool.getWorldLight();
+        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.setTexture(args[ArgIndexes.Texture]);
+            tool.vars.textureIndex = args[ArgIndexes.Texture];
             quad.doubleSided = args[ArgIndexes.DoubleSided];
             const uvs = args[ArgIndexes.UVs];
             //1
@@ -146,7 +147,7 @@ export class QuadVoxelGometryNode extends GeoemtryNode {
             //4
             quad.uvs.vertices[3].x = uvs[3][0];
             quad.uvs.vertices[3].y = uvs[3][1];
-            VoxelGeometry.addQuad(tool, origin, quad);
+            VoxelGeometryBuilder.addQuad(tool, origin, quad);
             UpdateBounds(tool, origin, this.quadBounds);
         }
         this.worldLight.setAll(0);

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

@@ -1,17 +1,24 @@
 import { Vec3Array, Vec4Array, Vector3Like } from "@amodx/math";
 import { VoxelFaces } from "../../../../Math";
-import { QuadScalarVertexData } from "@amodx/meshing";
+import { QuadScalarVertexData } from "../../../Geomtry/Primitives/QuadVertexData";
 import { VoxelBoxGeometryNode } from "../../../../Models/VoxelModel.types";
-import { Quad } from "@amodx/meshing/Primitives/Quad";
+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";
 export declare class RulelessBoxVoxelGeometryNode extends GeoemtryNode<VoxelBoxGeometryNode, BoxVoxelGometryArgs> {
     quads: Record<VoxelFaces, Quad>;
     quadBounds: [Vec3Array, Vec3Array][];
-    vertexWeights: Record<VoxelFaces, [Vec4Array, Vec4Array, Vec4Array, Vec4Array]>;
+    vertexWeights: Record<VoxelFaces, [
+        Vec4Array,
+        Vec4Array,
+        Vec4Array,
+        Vec4Array
+    ]>;
     worldLight: QuadScalarVertexData;
     worldAO: QuadScalarVertexData;
+    lightData: VoxelLightData;
     init(): void;
     determineShading(face: VoxelFaces): void;
     shouldFlip(): boolean;