@divinevoxel/vlox 0.0.71 → 0.0.73

package/Mesher/Geomtry/VoxelMeshBuffers.js

@@ -0,0 +1,49 @@
+export class VoxelVertexBuffer {
+    vertexFloatSize;
+    sectorVertexSize;
+    _buffers = [];
+    sectorSize = 0;
+    constructor(vertexFloatSize, sectorVertexSize, startingSectorSize = 4) {
+        this.vertexFloatSize = vertexFloatSize;
+        this.sectorVertexSize = sectorVertexSize;
+        this.sectorSize = vertexFloatSize * sectorVertexSize;
+        for (let i = 0; i < startingSectorSize; i++) {
+            this._buffers.push(new Float32Array(this.sectorSize));
+        }
+    }
+    currentArray;
+    curentIndex = 0;
+    _index = 0;
+    setIndex(index) {
+        this._index = index;
+        const bufferIndex = Math.floor((index * this.vertexFloatSize) / this.sectorSize);
+        if (!this._buffers[bufferIndex])
+            this._buffers[bufferIndex] = new Float32Array(this.sectorSize);
+        this.curentIndex =
+            (index * this.vertexFloatSize - bufferIndex * this.sectorSize) /
+                this.vertexFloatSize;
+        this.currentArray = this._buffers[bufferIndex];
+    }
+}
+export class VoxelIndiceBuffer {
+    sectorSize;
+    _buffers = [];
+    constructor(sectorSize, startingSectorSize = 4) {
+        this.sectorSize = sectorSize;
+        for (let i = 0; i < startingSectorSize; i++) {
+            this._buffers.push(new Uint32Array(sectorSize));
+        }
+    }
+    currentArray;
+    curentIndex = 0;
+    _index = 0;
+    setIndex(index) {
+        this._index = index;
+        const bufferIndex = Math.floor(index / this.sectorSize);
+        if (!this._buffers[bufferIndex])
+            this._buffers[bufferIndex] = new Uint32Array(this.sectorSize);
+        this.curentIndex = index - bufferIndex * this.sectorSize;
+        this.currentArray = this._buffers[bufferIndex];
+        return this;
+    }
+}

package/Mesher/{Tools → Geomtry}/VoxelMeshVertexStructCursor.d.ts

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

package/Mesher/{Tools → Geomtry}/VoxelMeshVertexStructCursor.js

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

package/Mesher/Geomtry/index.d.ts

@@ -1,2 +1 @@
 export * from "./Primitives/index";
-export * from "./Tools/index.js";

package/Mesher/Geomtry/index.js

@@ -1,2 +1 @@
 export * from "./Primitives/index";
-export * from "./Tools/index.js";

package/Mesher/InitMesher.js

@@ -1,8 +1,6 @@
-import { RenderedMaterials } from "./RenderedMaterials";
+import { RenderedMaterials } from "./Models/RenderedMaterials";
 import { VoxelModelConstructorRegister } from "./Models/VoxelModelConstructorRegister.js";
 import { LiquidGeometryNode } from "./Models/Nodes/Custom/Liquid/LiquidGeomtryNode.js";
-import { SchemaRegister } from "../Voxels/State/SchemaRegister.js";
-import { VoxelTagStates } from "../Voxels/State/VoxelTagStates.js";
 import { VoxelConstructor } from "./Models/VoxelConstructor.js";
 export default function (materials, modelData) {
     RenderedMaterials.register(materials);
@@ -10,14 +8,7 @@ export default function (materials, modelData) {
     VoxelModelConstructorRegister.setGeometryPalette(modelData.geometryPalette);
     VoxelModelConstructorRegister.registerGeometry(modelData.geometry);
     VoxelModelConstructorRegister.registerModels(modelData.models);
-    for (const model of modelData.models) {
-        SchemaRegister.registerModel(model.id, model.schema);
-    }
-    for (const voxel of modelData.voxels) {
-        SchemaRegister.registerVoxel(voxel.id, voxel.modelId, voxel.modSchema);
-    }
-    VoxelTagStates.load(modelData.tagState);
     for (const voxel of modelData.voxels) {
-        VoxelModelConstructorRegister.registerVoxel(new VoxelConstructor(voxel.id, VoxelModelConstructorRegister.modelData.get(voxel.modelId), voxel));
+        VoxelModelConstructorRegister.registerVoxel(new VoxelConstructor(voxel.id, RenderedMaterials.meshersMap.get(voxel.materialId), VoxelModelConstructorRegister.modelData.get(voxel.modelId), voxel));
     }
 }

package/Mesher/InitTask.js

@@ -1,43 +1,31 @@
 import { Threads } from "@amodx/threads";
 import { WorldRegister } from "../World/WorldRegister";
-import { WorldSpaces } from "../World/WorldSpaces";
 import { MeshSection } from "./Functions/MeshSection";
 import { TasksIds } from "../Tasks/TasksIds";
 export default function (rendererThread) {
     Threads.registerTask(TasksIds.BuildSection, (location) => {
-        const section = MeshSection(location);
+        const transfers = [];
+        const section = MeshSection(location, transfers);
         if (!section)
             return;
-        rendererThread.runTask("set-section", section[0], section[1]);
+        rendererThread.runTask("set-section", section, transfers);
     });
     Threads.registerTask(TasksIds.BuildSector, (location) => {
-        const sectorPosition = WorldSpaces.sector.getPosition(location[1], location[2], location[3]);
-        const sector = WorldRegister.sectors.get(location[0], sectorPosition.x, sectorPosition.y, sectorPosition.z);
+        const sector = WorldRegister.sectors.getAt(location);
         if (!sector) {
-            console.warn("Tried building a sector that does not exists.", [
-                sectorPosition.x,
-                sectorPosition.y,
-                sectorPosition.z,
-            ]);
-            return;
-        }
-        if (sector.sections.length == 0) {
-            console.warn("Tried building a sector with no sections.", sector.position);
+            console.warn("Tried building a sector that does not exists.", location);
             return;
         }
         for (let i = 0; i < sector.sections.length; i++) {
             const section = sector.sections[i];
-            if (!section)
+            let [minY, maxY] = section.getMinMax();
+            if (Math.abs(minY) == Infinity && Math.abs(maxY) == Infinity)
                 continue;
-            const sectionMesh = MeshSection([
-                location[0],
-                sector.position[0],
-                sector.position[1] + i * WorldSpaces.section.bounds.y,
-                sector.position[2],
-            ]);
+            const transfers = [];
+            const sectionMesh = MeshSection([location[0], ...section.getPosition()], transfers);
             if (!sectionMesh)
                 continue;
-            rendererThread.runTask("set-section", sectionMesh[0], sectionMesh[1]);
+            rendererThread.runTask("set-section", sectionMesh, transfers);
         }
     });
 }

package/Mesher/Models/Common/BoundsFunctions.d.ts

@@ -1,4 +1,2 @@
-import { Vec3Array, Vector3Like } from "@amodx/math";
-import { VoxelMesherDataTool } from "../../../Mesher/Tools/VoxelMesherDataTool";
-export declare function UpdateBounds(tool: VoxelMesherDataTool, origin: Vector3Like, bounds: [Vec3Array, Vec3Array]): void;
+import { Vec3Array } from "@amodx/math";
 export declare function GetBounds(vectors: Vec3Array[]): [Vec3Array, Vec3Array];

package/Mesher/Models/Common/BoundsFunctions.js

@@ -1,19 +1,3 @@
-export function UpdateBounds(tool, origin, bounds) {
-    //min
-    if (origin.x + bounds[0][0] < tool.bounds.min[0])
-        tool.bounds.min[0] = origin.x + bounds[0][0];
-    if (origin.y + bounds[0][1] < tool.bounds.min[1])
-        tool.bounds.min[1] = origin.y + bounds[0][1];
-    if (origin.z + bounds[0][2] < tool.bounds.min[2])
-        tool.bounds.min[2] = origin.z + bounds[0][2];
-    //max
-    if (origin.x + bounds[1][0] > tool.bounds.max[0])
-        tool.bounds.max[0] = origin.x + bounds[1][0];
-    if (origin.y + bounds[1][1] > tool.bounds.max[1])
-        tool.bounds.max[1] = origin.y + bounds[1][1];
-    if (origin.z + bounds[1][2] > tool.bounds.max[2])
-        tool.bounds.max[2] = origin.z + bounds[1][2];
-}
 export function GetBounds(vectors) {
     let minX = Infinity;
     let minY = Infinity;

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

@@ -2,7 +2,6 @@ import { QuadVerticies, QuadVerticiesArray, } from "../../../Geomtry/Geometry.ty
 import { VoxelFaces, VoxelFacesArray } from "../../../../Math";
 import { VoxelRelativeCubeIndex } from "../../../../Models/Indexing/VoxelRelativeCubeIndex";
 import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
-const lightData = new VoxelLightData();
 export const GradientCheckSets = [];
 GradientCheckSets[VoxelFaces.Up] = [];
 GradientCheckSets[VoxelFaces.Up][QuadVerticies.TopRight] = [
@@ -311,37 +310,21 @@ export function getVertexWeights(face, x, y, z) {
     }
     return getInterpolationWeights(u, v, flip);
 }
-const lightValues1 = [0, 0, 0, 0];
-const lightValues2 = [0, 0, 0, 0];
-const lightValues3 = [0, 0, 0, 0];
-const lightValues4 = [0, 0, 0, 0];
-const lightValues5 = [0, 0, 0, 0];
+const lightData = new VoxelLightData();
 export function getInterpolationValue(value, weights) {
-    lightData.getLightValuesToRef(value[0], lightValues1);
-    lightData.getLightValuesToRef(value[1], lightValues2);
-    lightData.getLightValuesToRef(value[2], lightValues3);
-    lightData.getLightValuesToRef(value[3], lightValues4);
-    lightValues5[0] =
-        lightValues1[0] * weights[0] +
-            lightValues2[0] * weights[1] +
-            lightValues3[0] * weights[2] +
-            lightValues4[0] * weights[3];
-    lightValues5[1] =
-        lightValues1[1] * weights[0] +
-            lightValues2[1] * weights[1] +
-            lightValues3[1] * weights[2] +
-            lightValues4[1] * weights[3];
-    lightValues5[2] =
-        lightValues1[2] * weights[0] +
-            lightValues2[2] * weights[1] +
-            lightValues3[2] * weights[2] +
-            lightValues4[2] * weights[3];
-    lightValues5[3] =
-        lightValues1[3] * weights[0] +
-            lightValues2[3] * weights[1] +
-            lightValues3[3] * weights[2] +
-            lightValues4[3] * weights[3];
-    return lightData.setLightValues(lightValues5);
+    return lightData.createLightValue(lightData.getS(value[0]) * weights[0] +
+        lightData.getS(value[1]) * weights[1] +
+        lightData.getS(value[2]) * weights[2] +
+        lightData.getS(value[3]) * weights[3], lightData.getR(value[0]) * weights[0] +
+        lightData.getR(value[1]) * weights[1] +
+        lightData.getR(value[2]) * weights[2] +
+        lightData.getR(value[3]) * weights[3], lightData.getG(value[0]) * weights[0] +
+        lightData.getG(value[1]) * weights[1] +
+        lightData.getG(value[2]) * weights[2] +
+        lightData.getG(value[3]) * weights[3], lightData.getB(value[0]) * weights[0] +
+        lightData.getB(value[1]) * weights[1] +
+        lightData.getB(value[2]) * weights[2] +
+        lightData.getB(value[3]) * weights[3]);
 }
 export const addQuadWeights = (quad, direction) => {
     const returnArray = [];

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

@@ -1,9 +1,3 @@
-import type { VoxelMesherDataTool } from "../../../../Mesher/Tools/VoxelMesherDataTool.js";
+import type { VoxelModelBuilder } from "../../VoxelModelBuilder.js";
 import { VoxelFaces } from "../../../../Math/index.js";
-export declare const FaceDataCalc: {
-    settings: {
-        doAO: boolean;
-        doLight: boolean;
-    };
-    calculate(face: VoxelFaces, tool: VoxelMesherDataTool): void;
-};
+export default function calculateFaceData(face: VoxelFaces, builder: VoxelModelBuilder): void;

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

@@ -2,56 +2,54 @@ import { VoxelFaceDirections } from "../../../../Math/index.js";
 import { GradientCheckSets } from "./CalcConstants.js";
 import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData.js";
 const lightData = new VoxelLightData();
-const currentLightValues = new Uint16Array([0, 0, 0, 0]);
-const loadedLightValues = new Uint16Array([0, 0, 0, 0]);
-const faceLength = 9 * 4;
-const settings = {
-    doAO: true,
-    doLight: true,
-};
-export const FaceDataCalc = {
-    settings,
-    calculate(face, tool) {
-        let light = tool.voxel.getLight();
-        const faceNormal = VoxelFaceDirections[face];
-        const nVoxel = tool.nVoxel.getVoxel(tool.position.x + faceNormal[0], tool.position.y + faceNormal[1], tool.position.z + faceNormal[2]);
-        const otherLight = nVoxel?.getLight() || 0;
-        light = otherLight >= 0 ? otherLight : light >= 0 ? light : 0;
-        for (let vertex = 0; vertex < 4; vertex++) {
-            if (settings.doLight) {
-                tool.lightData[face][vertex] = light;
-                lightData.getLightValuesToRef(light, currentLightValues);
-            }
-            for (let i = 0; i < 9; i += 3) {
-                const loadedVoxel = tool.nVoxel.getVoxel(GradientCheckSets[face][vertex][i] + tool.position.x, GradientCheckSets[face][vertex][i + 1] + tool.position.y, GradientCheckSets[face][vertex][i + 2] + tool.position.z);
-                if (!settings.doLight || !loadedVoxel)
-                    continue;
-                const nl = loadedVoxel.getLight();
-                if (nl <= 0)
-                    continue;
-                /*
-              Do Light
-              */
-                lightData.getLightValuesToRef(nl, loadedLightValues);
-                currentLightValues[0] =
-                    currentLightValues[0] < loadedLightValues[0]
-                        ? loadedLightValues[0]
-                        : currentLightValues[0];
-                currentLightValues[1] =
-                    currentLightValues[1] < loadedLightValues[1]
-                        ? loadedLightValues[1]
-                        : currentLightValues[1];
-                currentLightValues[2] =
-                    currentLightValues[2] < loadedLightValues[2]
-                        ? loadedLightValues[2]
-                        : currentLightValues[2];
-                currentLightValues[3] =
-                    currentLightValues[3] < loadedLightValues[3]
-                        ? loadedLightValues[3]
-                        : currentLightValues[3];
-            }
-            tool.lightData[face][vertex] =
-                lightData.setLightValues(currentLightValues);
+export default function calculateFaceData(face, builder) {
+    const x = builder.position.x;
+    const y = builder.position.y;
+    const z = builder.position.z;
+    const vertexData = builder.lightData[face];
+    const nVoxel = builder.nVoxel;
+    const checkSet = GradientCheckSets[face];
+    let startLight = 0;
+    if (builder.voxel.isLightSource()) {
+        startLight = builder.voxel.getLightSourceValue();
+    }
+    else {
+        startLight =
+            nVoxel
+                .getVoxel(x + VoxelFaceDirections[face][0], y + VoxelFaceDirections[face][1], z + VoxelFaceDirections[face][2])
+                ?.getLight() || 0;
+    }
+    if (startLight < 0)
+        startLight = 0;
+    const startS = lightData.getS(startLight);
+    const startR = lightData.getR(startLight);
+    const startG = lightData.getG(startLight);
+    const startB = lightData.getB(startLight);
+    for (let vertex = 0; vertex < 4; vertex++) {
+        vertexData[vertex] = startLight;
+        let s = startS;
+        let r = startR;
+        let g = startG;
+        let b = startB;
+        for (let i = 0; i < 9; i += 3) {
+            const nl = nVoxel
+                .getVoxel(checkSet[vertex][i] + x, checkSet[vertex][i + 1] + y, checkSet[vertex][i + 2] + z)
+                ?.getLight() || -1;
+            if (nl <= 0)
+                continue;
+            let ns = lightData.getS(nl);
+            let nr = lightData.getR(nl);
+            let ng = lightData.getG(nl);
+            let nb = lightData.getB(nl);
+            if (s < ns)
+                s = ns;
+            if (r < nr)
+                r = nr;
+            if (g < ng)
+                g = ng;
+            if (b < nb)
+                b = nb;
         }
-    },
-};
+        vertexData[vertex] = lightData.createLightValue(s, r, g, b);
+    }
+}

package/Mesher/Models/Nodes/Custom/Liquid/FlowGradient.d.ts

@@ -1,4 +1,4 @@
-import type { VoxelMesherDataTool } from "../../../../../Mesher/Tools/VoxelMesherDataTool";
+import type { VoxelModelBuilder } from "../../../VoxelModelBuilder";
 import { QuadScalarVertexData } from "../../../../Geomtry/Primitives/QuadVertexData";
 import { CompassAngles } from "@amodx/math";
 export declare enum FlowVerticies {
@@ -8,4 +8,4 @@ export declare enum FlowVerticies {
     SouthEsat = 3
 }
 export declare function getFlowAngle(vertexLevel: QuadScalarVertexData): [angle: CompassAngles, flow: number];
-export declare function getFlowGradient(tool: VoxelMesherDataTool, flowStates: QuadScalarVertexData): QuadScalarVertexData;
+export declare function getFlowGradient(tool: VoxelModelBuilder, flowStates: QuadScalarVertexData): QuadScalarVertexData;

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

@@ -66,7 +66,7 @@ const returnData = [
 export function getFlowAngle(vertexLevel) {
     if (vertexLevel.isAllEqualTo(7)) {
         returnData[0] = 0;
-        returnData[1] = FlowStates.None;
+        returnData[1] = FlowStates.Up;
         return returnData;
     }
     const upRight = vertexLevel.vertices[QuadVerticies.TopRight];

package/Mesher/Models/Nodes/Custom/Liquid/LiquidGeomtryNode.d.ts

@@ -1,15 +1,11 @@
-import { Vector3Like } from "@amodx/math";
-import { VoxelMesherDataTool } from "Mesher/Tools/VoxelMesherDataTool";
 import { GeoemtryNode } from "../../GeometryNode";
 import { VoxelCustomGeomtryNode } from "../../../../../Models/VoxelModel.types";
-import { QuadScalarVertexData } from "../../../../Geomtry/Primitives/QuadVertexData";
 import { VoxelFaces } from "../../../../../Math";
 import type { LiquidVoxelModelArgs } from "../../../../../Models/Defaults/LiquidVoxelModel";
 export declare class LiquidGeometryNode extends GeoemtryNode<VoxelCustomGeomtryNode, LiquidVoxelModelArgs> {
-    worldLight: QuadScalarVertexData;
     init(): void;
     isExposed(face: VoxelFaces): boolean;
     determineShading(face: VoxelFaces): void;
     shouldFlip(): boolean;
-    add(tool: VoxelMesherDataTool, originHash: number, origin: Vector3Like, args: LiquidVoxelModelArgs): void;
+    add(args: LiquidVoxelModelArgs): boolean;
 }

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,44 +36,43 @@ 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 lightData = tool.lightData[face];
-        const worldLight = this.worldLight;
-        for (let v = 0; v < 4; v++) {
-            worldLight.vertices[v] = lightData[v];
-        }
+        this.builder.calculateFaceData(face);
+        const lightData = this.builder.lightData[face];
+        const worldLight = this.builder.vars.light;
+        worldLight.vertices[0] = lightData[0];
+        worldLight.vertices[1] = lightData[1];
+        worldLight.vertices[2] = lightData[2];
+        worldLight.vertices[3] = lightData[3];
     }
     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);
             this.determineShading(VoxelFaces.Up);
             quad.flip = this.shouldFlip();
             tool.vars.textureIndex = args.stillTexture;
@@ -94,24 +92,23 @@ 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)) {
-            tool.vars.textureIndex = args.stillTexture;
+            added = true;
+            tool.vars.textureIndex = args.flowTexture;
             const quad = Quads[VoxelFaces.North];
             tool.vars.animation.setAll(1);
-            tool.calculateFaceData(VoxelFaces.North);
             this.determineShading(VoxelFaces.North);
             quad.flip = this.shouldFlip();
             if (upFaceExposed) {
@@ -129,14 +126,14 @@ 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)) {
-            tool.vars.textureIndex = args.stillTexture;
+            added = true;
+            tool.vars.textureIndex = args.flowTexture;
             const quad = Quads[VoxelFaces.South];
             tool.vars.animation.setAll(1);
-            tool.calculateFaceData(VoxelFaces.South);
             this.determineShading(VoxelFaces.South);
             quad.flip = this.shouldFlip();
             if (upFaceExposed) {
@@ -154,16 +151,16 @@ 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)) {
-            tool.vars.textureIndex = args.stillTexture;
+            added = true;
+            tool.vars.textureIndex = args.flowTexture;
             const quad = Quads[VoxelFaces.East];
             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[FlowVerticies.NorthEast] * waterHeight;
@@ -179,14 +176,14 @@ 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)) {
-            tool.vars.textureIndex = args.stillTexture;
+            added = true;
+            tool.vars.textureIndex = args.flowTexture;
             const quad = Quads[VoxelFaces.West];
             tool.vars.animation.setAll(1);
-            tool.calculateFaceData(VoxelFaces.West);
             this.determineShading(VoxelFaces.West);
             quad.flip = this.shouldFlip();
             if (upFaceExposed) {
@@ -204,9 +201,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 { VoxelModelBuilder } from "../VoxelModelBuilder";
 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: VoxelModelBuilder;
     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;