@divinevoxel/vlox 0.0.74 → 0.0.76

package/Mesher/Models/Common/Faces/CullRulledFace.js

@@ -0,0 +1,60 @@
+import { VoxelRelativeCubeIndexPositionMap } from "../../../../Voxels/Models/Indexing/VoxelRelativeCubeIndex";
+import { VoxelModelConstructorRegister } from "../../VoxelModelConstructorRegister";
+export function CullRulledFace(builder, trueFaceIndex) {
+    const faceIndexes = VoxelModelConstructorRegister.faceCullMap[trueFaceIndex];
+    if (!faceIndexes)
+        return true;
+    for (let i = 0; i < faceIndexes.length; i++) {
+        const directionIndex = faceIndexes[i];
+        const p = VoxelRelativeCubeIndexPositionMap[directionIndex];
+        const hashed = builder.space.getHash(builder.nVoxel, builder.position.x + p[0], builder.position.y + p[1], builder.position.z + p[2]);
+        if (builder.space.foundHash[hashed] < 2)
+            continue;
+        const constructor = builder.space.getConstructor(hashed);
+        const offsetBaseGometry = builder.space.getGeomtry(hashed);
+        if (offsetBaseGometry) {
+            for (let i = 0; i < offsetBaseGometry.length; i++) {
+                const geoId = offsetBaseGometry[i];
+                if (VoxelModelConstructorRegister.rulesless[geoId])
+                    continue;
+                const cullingProcedure = VoxelModelConstructorRegister.geometry[geoId].cullingProcedure;
+                if (cullingProcedure.type == "transparent") {
+                    if (constructor.id != builder.voxel.getStringId())
+                        continue;
+                }
+                else {
+                    if (cullingProcedure.type != "default")
+                        continue;
+                }
+                if (VoxelModelConstructorRegister.faceCullIndex.getValue(geoId, directionIndex, trueFaceIndex) == 1) {
+                    return false;
+                }
+            }
+        }
+        const offsetConditonalGeometry = builder.space.getConditionalGeomtry(hashed);
+        if (offsetConditonalGeometry) {
+            for (let i = 0; i < offsetConditonalGeometry.length; i++) {
+                const cond = offsetConditonalGeometry[i];
+                for (let k = 0; k < cond.length; k++) {
+                    const geoId = cond[k];
+                    if (VoxelModelConstructorRegister.rulesless[geoId])
+                        continue;
+                    const cullingProcedure = VoxelModelConstructorRegister.geometry[geoId].cullingProcedure;
+                    if (cullingProcedure.type == "transparent") {
+                        if (constructor.id != builder.voxel.getStringId())
+                            continue;
+                    }
+                    else {
+                        if (cullingProcedure.type != "default")
+                            continue;
+                    }
+                    if (VoxelModelConstructorRegister.rulesless[geoId])
+                        continue;
+                    if (VoxelModelConstructorRegister.faceCullIndex.getValue(geoId, directionIndex, trueFaceIndex) == 1)
+                        return false;
+                }
+            }
+        }
+    }
+    return true;
+}

package/Mesher/Models/Common/Faces/ShadeRulelessFace.d.ts

@@ -0,0 +1,4 @@
+import { QuadVerticies } from "../../../Geomtry/Geometry.types";
+import { VoxelModelBuilder } from "../../../Models/VoxelModelBuilder";
+import { Vec4Array } from "@amodx/math";
+export declare function ShadeRulelessFace(builder: VoxelModelBuilder, lightData: Record<QuadVerticies, number>, vertexWeights: Vec4Array[], verticesStride: number): void;

package/Mesher/Models/Common/Faces/ShadeRulelessFace.js

@@ -0,0 +1,12 @@
+import { getInterpolationValue } from "../Calc/CalcConstants";
+export function ShadeRulelessFace(builder, lightData, vertexWeights, verticesStride) {
+    const noAO = builder.voxel.isLightSource() || builder.voxel.noAO();
+    const worldLight = builder.vars.light;
+    const worldAO = builder.vars.ao;
+    for (let v = 0; v < verticesStride; v++) {
+        worldAO.vertices[v] = 0;
+        worldLight.vertices[v] = getInterpolationValue(lightData, vertexWeights[v]);
+        if (noAO)
+            continue;
+    }
+}

package/Mesher/Models/Common/Faces/ShadeRulledFace.d.ts

@@ -0,0 +1,4 @@
+import { VoxelModelBuilder } from "../../VoxelModelBuilder";
+import { Vec4Array } from "@amodx/math";
+import { QuadVerticies } from "../../../Geomtry/Geometry.types";
+export declare function ShadeRulledFace(builder: VoxelModelBuilder, trueFaceIndex: number, lightData: Record<QuadVerticies, number>, vertexWeights: Vec4Array[], vertexStride: number): void;

package/Mesher/Models/Common/Faces/ShadeRulledFace.js

@@ -0,0 +1,58 @@
+import { VoxelRelativeCubeIndexPositionMap } from "../../../../Voxels/Models/Indexing/VoxelRelativeCubeIndex";
+import { VoxelModelConstructorRegister } from "../../VoxelModelConstructorRegister";
+import { getInterpolationValue } from "../Calc/CalcConstants";
+export function ShadeRulledFace(builder, trueFaceIndex, lightData, vertexWeights, vertexStride) {
+    const noAO = builder.voxel.isLightSource() || builder.voxel.noAO();
+    const worldLight = builder.vars.light;
+    const worldAO = builder.vars.ao;
+    for (let v = 0; v < vertexStride; v++) {
+        worldAO.vertices[v] = 0;
+        worldLight.vertices[v] = getInterpolationValue(lightData, vertexWeights[v]);
+        if (noAO)
+            continue;
+        const aoIndexes = VoxelModelConstructorRegister.vertexHitMap[trueFaceIndex][v];
+        if (!aoIndexes)
+            continue;
+        for (let i = 0; i < aoIndexes.length; i++) {
+            const directionIndex = aoIndexes[i];
+            const p = VoxelRelativeCubeIndexPositionMap[directionIndex];
+            const hashed = builder.space.getHash(builder.nVoxel, builder.position.x + p[0], builder.position.y + p[1], builder.position.z + p[2]);
+            if (builder.space.foundHash[hashed] < 2 ||
+                builder.space.noCastAO[hashed] === 1)
+                continue;
+            const baseGeo = builder.space.getGeomtry(hashed);
+            const conditonalGeo = builder.space.getConditionalGeomtry(hashed);
+            if (!baseGeo && !conditonalGeo)
+                continue;
+            let length = 0;
+            let shaded = false;
+            if (baseGeo) {
+                length = baseGeo.length;
+                for (let geoIndex = 0; geoIndex < length; geoIndex++) {
+                    if (VoxelModelConstructorRegister.aoIndex.getValue(baseGeo[geoIndex], directionIndex, trueFaceIndex, v)) {
+                        worldAO.vertices[v]++;
+                        if (worldAO.vertices[v] >= 3) {
+                            shaded = true;
+                            break;
+                        }
+                    }
+                }
+            }
+            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 (VoxelModelConstructorRegister.aoIndex.getValue(conditonalGeo[condtionsIndex][geoIndex], directionIndex, trueFaceIndex, v)) {
+                        worldAO.vertices[v]++;
+                        if (worldAO.vertices[v] >= 3) {
+                            shaded = true;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+import { BaseVoxelGeomtryTextureProcedureData } from "../Procedures/TextureProcedure";
+import { VoxelModelBuilder } from "../VoxelModelBuilder";
+import { Quad } from "../../Geomtry";
+import { VoxelFaces } from "../../../Math";
+import { Triangle } from "../../Geomtry";
+export declare function GetTexture(builder: VoxelModelBuilder, data: number | BaseVoxelGeomtryTextureProcedureData, closestFace: VoxelFaces, primitive: Quad | Triangle): void;

package/Mesher/Models/Common/GetTexture.js

@@ -0,0 +1,12 @@
+import { TextureProcedureRegister } from "../Procedures/TextureProcedureRegister";
+export function GetTexture(builder, data, closestFace, primitive) {
+    if (typeof data == "number") {
+        builder.vars.textureIndex = data;
+    }
+    else {
+        const procedure = TextureProcedureRegister.get(data.type);
+        builder.vars.textureIndex = procedure.getTexture(builder, data, closestFace, primitive);
+        procedure.transformUVs(builder, data, closestFace, primitive);
+        procedure.getOverlayTexture(builder, data, closestFace, primitive, builder.vars.overlayTextures);
+    }
+}

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.Up;
+        returnData[1] = FlowStates.None;
         return returnData;
     }
     const upRight = vertexLevel.vertices[QuadVerticies.TopRight];

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

@@ -1,11 +1,10 @@
 import { GeoemtryNode } from "../../GeometryNode";
-import { VoxelCustomGeomtryNode } from "../../../../../Models/VoxelModel.types";
+import { VoxelCustomGeomtryNode } from "../../../../../Voxels/Models/VoxelModel.types";
 import { VoxelFaces } from "../../../../../Math";
-import type { LiquidVoxelModelArgs } from "../../../../../Models/Defaults/LiquidVoxelModel";
+import type { LiquidVoxelModelArgs } from "../../../../../Voxels/Models/Defaults/LiquidVoxelModel";
 export declare class LiquidGeometryNode extends GeoemtryNode<VoxelCustomGeomtryNode, LiquidVoxelModelArgs> {
     init(): void;
     isExposed(face: VoxelFaces): boolean;
     determineShading(face: VoxelFaces): void;
-    shouldFlip(): boolean;
     add(args: LiquidVoxelModelArgs): boolean;
 }

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

@@ -4,11 +4,11 @@ import { Quad } from "../../../../Geomtry/Primitives/Quad";
 import { QuadVerticies } from "../../../../Geomtry/Geometry.types";
 import { QuadScalarVertexData } from "../../../../Geomtry/Primitives/QuadVertexData";
 import { VoxelFaceDirections, VoxelFaces } from "../../../../../Math";
-import { shouldCauseFlip } from "../../../Common/Calc/CalcConstants";
 import { getFlowAngle, getFlowGradient, FlowVerticies } from "./FlowGradient";
-import { GetBoxGeometryNodeData } from "../../../Common/BoxGeometryNode";
 import { VoxelLightData } from "../../../../../Voxels/Cursor/VoxelLightData";
 import { addVoxelQuad } from "../../../../Geomtry/VoxelGeometryBuilder";
+import { GetTexture } from "../../../Common/GetTexture";
+import { Box } from "../../../../Geomtry/Shapes/Box";
 const vertexValue = new QuadScalarVertexData();
 const vertexLevel = new QuadScalarVertexData();
 const lightData = new VoxelLightData();
@@ -29,22 +29,28 @@ const uvs = [
     [0, 0],
     [1, 0],
 ];
-const { quads: Quads, vertexWeights, quadBounds, } = GetBoxGeometryNodeData([
+const { quads: Quads } = Box.Create([
     [0, 0, 0],
     [1, waterHeight, 1],
-], {});
+]);
+const { quads: Quads2 } = Box.Create([
+    [0, 0, 0],
+    [1, waterHeight, 1],
+]);
 Quads[VoxelFaces.Up].setUVs(uvs);
 Quads[VoxelFaces.Down].setUVs(uvs);
 export class LiquidGeometryNode extends GeoemtryNode {
-    init() {
-        this.faceCount = 1;
-        this.vertexCount = 0;
-    }
+    init() { }
     isExposed(face) {
+        /*     if (this.builder.voxel.getLevel() <= 0 || this.builder.voxel.getLevelState() && face !== VoxelFaces.Up) {
+              return true;
+            } */
         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.builder.voxel.isSameVoxel(nv) && face == VoxelFaces.Up))
+        if (!nv || (face == VoxelFaces.Up && nv.isAir()))
+            return true;
+        if (this.builder.voxel.isSameVoxel(nv))
+            return false;
+        if (nv.isAir() || nv.tags["dve_is_transparent"])
             return true;
         return false;
     }
@@ -57,29 +63,34 @@ export class LiquidGeometryNode extends GeoemtryNode {
         worldLight.vertices[2] = lightData[2];
         worldLight.vertices[3] = lightData[3];
     }
-    shouldFlip() {
-        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(args) {
         vertexLevel.setAll(15);
         vertexValue.setAll(0);
-        const tool = this.builder;
+        const builder = this.builder;
+        let flowTexture = args.flowTexture;
+        let stillTexture = args.stillTexture;
+        let reverseHeight = false;
+        let currentHeight = 0;
+        if (builder.voxel.getLevelState() == 1 && builder.voxel.getLevel() < 7) {
+            reverseHeight = true;
+            currentHeight = 1 - builder.voxel.getLevel() / 7;
+        }
+        /*     if (builder.voxel.getLevelState() == 1 || builder.voxel.getLevel() == 0) {
+              flowTexture = 0;
+              stillTexture = 0;
+            } */
         let added = false;
         let upFaceExposed = false;
         if (this.isExposed(VoxelFaces.Up)) {
             upFaceExposed = true;
             added = true;
-            getFlowGradient(tool, vertexLevel);
+            getFlowGradient(builder, vertexLevel);
             const quad = Quads[VoxelFaces.Up];
             this.determineShading(VoxelFaces.Up);
-            quad.flip = this.shouldFlip();
-            tool.vars.textureIndex = args.stillTexture;
             vertexValue.set(vertexLevel.vertices[0] / 7, vertexLevel.vertices[1] / 7, vertexLevel.vertices[2] / 7, vertexLevel.vertices[3] / 7);
             const flowData = getFlowAngle(vertexLevel);
             const uvSet = quadRotations[flowData[0]];
-            tool.vars.animation.setAll(flowData[1]);
+            builder.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];
@@ -92,119 +103,184 @@ 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;
-            addVoxelQuad(tool, tool.origin, quad);
-            tool.updateBounds(quadBounds[VoxelFaces.Up]);
+            if (vertexLevel.vertices[0] != 7 ||
+                vertexLevel.vertices[1] != 7 ||
+                vertexLevel.vertices[2] != 7 ||
+                vertexLevel.vertices[3] != 7) {
+                GetTexture(builder, flowTexture, VoxelFaces.Up, quad);
+            }
+            else {
+                GetTexture(builder, stillTexture, VoxelFaces.Up, quad);
+            }
+            addVoxelQuad(builder, quad);
+            builder.updateBounds(quad.bounds);
         }
         if (this.isExposed(VoxelFaces.Down)) {
             added = true;
-            tool.vars.textureIndex = args.stillTexture;
             const quad = Quads[VoxelFaces.Down];
+            if (reverseHeight) {
+                quad.positions.vertices[QuadVerticies.TopRight].y = currentHeight;
+                quad.positions.vertices[QuadVerticies.TopLeft].y = currentHeight;
+                quad.positions.vertices[QuadVerticies.BottomRight].y = currentHeight;
+                quad.positions.vertices[QuadVerticies.BottomLeft].y = currentHeight;
+            }
+            else {
+                quad.positions.vertices[QuadVerticies.TopRight].y = 0;
+                quad.positions.vertices[QuadVerticies.TopLeft].y = 0;
+                quad.positions.vertices[QuadVerticies.BottomLeft].y = 0;
+                quad.positions.vertices[QuadVerticies.BottomRight].y = 0;
+            }
+            quad.setUVs(uvs);
             this.determineShading(VoxelFaces.Down);
-            quad.flip = this.shouldFlip();
-            addVoxelQuad(tool, tool.origin, quad);
-            tool.updateBounds(quadBounds[VoxelFaces.Down]);
+            GetTexture(builder, stillTexture, VoxelFaces.Up, quad);
+            addVoxelQuad(builder, quad);
+            builder.updateBounds(quad.bounds);
         }
         if (this.isExposed(VoxelFaces.North)) {
             added = true;
-            tool.vars.textureIndex = args.flowTexture;
             const quad = Quads[VoxelFaces.North];
-            tool.vars.animation.setAll(1);
+            builder.vars.animation.setAll(1);
             this.determineShading(VoxelFaces.North);
-            quad.flip = this.shouldFlip();
             if (upFaceExposed) {
                 quad.positions.vertices[QuadVerticies.TopRight].y =
                     vertexValue.vertices[FlowVerticies.NorthWest] * waterHeight;
                 quad.positions.vertices[QuadVerticies.TopLeft].y =
                     vertexValue.vertices[FlowVerticies.NorthEast] * waterHeight;
+                quad.positions.vertices[QuadVerticies.BottomLeft].y = 0;
+                quad.positions.vertices[QuadVerticies.BottomRight].y = 0;
                 quad.uvs.vertices[QuadVerticies.TopRight].y =
                     vertexValue.vertices[FlowVerticies.NorthWest];
                 quad.uvs.vertices[QuadVerticies.TopLeft].y =
                     vertexValue.vertices[FlowVerticies.NorthEast];
             }
+            else if (reverseHeight) {
+                quad.positions.vertices[QuadVerticies.TopRight].y = 1;
+                quad.positions.vertices[QuadVerticies.TopLeft].y = 1;
+                quad.positions.vertices[QuadVerticies.BottomRight].y = currentHeight;
+                quad.positions.vertices[QuadVerticies.BottomLeft].y = currentHeight;
+                quad.uvs.vertices[QuadVerticies.BottomRight].y = currentHeight;
+                quad.uvs.vertices[QuadVerticies.BottomLeft].y = currentHeight;
+            }
             else {
                 quad.positions.vertices[QuadVerticies.TopRight].y = 1;
                 quad.positions.vertices[QuadVerticies.TopLeft].y = 1;
+                quad.positions.vertices[QuadVerticies.BottomLeft].y = 0;
+                quad.positions.vertices[QuadVerticies.BottomRight].y = 0;
                 quad.setUVs(uvs);
             }
-            addVoxelQuad(tool, tool.origin, quad);
-            tool.updateBounds(quadBounds[VoxelFaces.North]);
+            GetTexture(builder, flowTexture, VoxelFaces.North, quad);
+            addVoxelQuad(builder, quad);
+            builder.updateBounds(quad.bounds);
         }
         if (this.isExposed(VoxelFaces.South)) {
             added = true;
-            tool.vars.textureIndex = args.flowTexture;
             const quad = Quads[VoxelFaces.South];
-            tool.vars.animation.setAll(1);
+            builder.vars.animation.setAll(1);
             this.determineShading(VoxelFaces.South);
-            quad.flip = this.shouldFlip();
             if (upFaceExposed) {
                 quad.positions.vertices[QuadVerticies.TopRight].y =
                     vertexValue.vertices[FlowVerticies.SouthEsat] * waterHeight;
                 quad.positions.vertices[QuadVerticies.TopLeft].y =
                     vertexValue.vertices[FlowVerticies.SouthWest] * waterHeight;
+                quad.positions.vertices[QuadVerticies.BottomLeft].y = 0;
+                quad.positions.vertices[QuadVerticies.BottomRight].y = 0;
                 quad.uvs.vertices[QuadVerticies.TopRight].y =
                     vertexValue.vertices[FlowVerticies.SouthEsat];
                 quad.uvs.vertices[QuadVerticies.TopLeft].y =
                     vertexValue.vertices[FlowVerticies.SouthWest];
             }
+            else if (reverseHeight) {
+                quad.positions.vertices[QuadVerticies.TopRight].y = 1;
+                quad.positions.vertices[QuadVerticies.TopLeft].y = 1;
+                quad.positions.vertices[QuadVerticies.BottomRight].y = currentHeight;
+                quad.positions.vertices[QuadVerticies.BottomLeft].y = currentHeight;
+                quad.uvs.vertices[QuadVerticies.BottomRight].y = currentHeight;
+                quad.uvs.vertices[QuadVerticies.BottomLeft].y = currentHeight;
+            }
             else {
                 quad.positions.vertices[QuadVerticies.TopLeft].y = 1;
                 quad.positions.vertices[QuadVerticies.TopRight].y = 1;
+                quad.positions.vertices[QuadVerticies.BottomLeft].y = 0;
+                quad.positions.vertices[QuadVerticies.BottomRight].y = 0;
                 quad.setUVs(uvs);
             }
-            addVoxelQuad(tool, tool.origin, quad);
-            tool.updateBounds(quadBounds[VoxelFaces.South]);
+            GetTexture(builder, flowTexture, VoxelFaces.Up, quad);
+            addVoxelQuad(builder, quad);
+            builder.updateBounds(quad.bounds);
         }
         if (this.isExposed(VoxelFaces.East)) {
             added = true;
-            tool.vars.textureIndex = args.flowTexture;
             const quad = Quads[VoxelFaces.East];
-            tool.vars.animation.setAll(1);
+            builder.vars.animation.setAll(1);
             this.determineShading(VoxelFaces.East);
-            quad.flip = this.shouldFlip();
             if (upFaceExposed) {
                 quad.positions.vertices[QuadVerticies.TopRight].y =
                     vertexValue.vertices[FlowVerticies.NorthEast] * waterHeight;
                 quad.positions.vertices[QuadVerticies.TopLeft].y =
                     vertexValue.vertices[FlowVerticies.SouthEsat] * waterHeight;
+                quad.positions.vertices[QuadVerticies.BottomLeft].y = 0;
+                quad.positions.vertices[QuadVerticies.BottomRight].y = 0;
                 quad.uvs.vertices[QuadVerticies.TopRight].y =
                     vertexValue.vertices[FlowVerticies.SouthEsat];
                 quad.uvs.vertices[QuadVerticies.TopLeft].y =
                     vertexValue.vertices[FlowVerticies.NorthEast];
             }
+            else if (reverseHeight) {
+                quad.positions.vertices[QuadVerticies.TopRight].y = 1;
+                quad.positions.vertices[QuadVerticies.TopLeft].y = 1;
+                quad.positions.vertices[QuadVerticies.BottomRight].y = currentHeight;
+                quad.positions.vertices[QuadVerticies.BottomLeft].y = currentHeight;
+                quad.uvs.vertices[QuadVerticies.BottomRight].y = currentHeight;
+                quad.uvs.vertices[QuadVerticies.BottomLeft].y = currentHeight;
+            }
             else {
                 quad.positions.vertices[QuadVerticies.TopLeft].y = 1;
                 quad.positions.vertices[QuadVerticies.TopRight].y = 1;
+                quad.positions.vertices[QuadVerticies.BottomLeft].y = 0;
+                quad.positions.vertices[QuadVerticies.BottomRight].y = 0;
                 quad.setUVs(uvs);
             }
-            addVoxelQuad(tool, tool.origin, quad);
-            tool.updateBounds(quadBounds[VoxelFaces.East]);
+            GetTexture(builder, flowTexture, VoxelFaces.Up, quad);
+            addVoxelQuad(builder, quad);
+            builder.updateBounds(quad.bounds);
         }
         if (this.isExposed(VoxelFaces.West)) {
             added = true;
-            tool.vars.textureIndex = args.flowTexture;
             const quad = Quads[VoxelFaces.West];
-            tool.vars.animation.setAll(1);
+            builder.vars.animation.setAll(1);
             this.determineShading(VoxelFaces.West);
-            quad.flip = this.shouldFlip();
             if (upFaceExposed) {
                 quad.positions.vertices[QuadVerticies.TopRight].y =
                     vertexValue.vertices[FlowVerticies.SouthWest] * waterHeight;
                 quad.positions.vertices[QuadVerticies.TopLeft].y =
                     vertexValue.vertices[FlowVerticies.NorthWest] * waterHeight;
+                quad.positions.vertices[QuadVerticies.BottomLeft].y = 0;
+                quad.positions.vertices[QuadVerticies.BottomRight].y = 0;
                 quad.uvs.vertices[QuadVerticies.TopRight].y =
                     vertexValue.vertices[FlowVerticies.SouthWest];
                 quad.uvs.vertices[QuadVerticies.TopLeft].y =
                     vertexValue.vertices[FlowVerticies.NorthWest];
             }
+            else if (reverseHeight) {
+                quad.positions.vertices[QuadVerticies.TopRight].y = 1;
+                quad.positions.vertices[QuadVerticies.TopLeft].y = 1;
+                quad.positions.vertices[QuadVerticies.BottomRight].y = currentHeight;
+                quad.positions.vertices[QuadVerticies.BottomLeft].y = currentHeight;
+                quad.uvs.vertices[QuadVerticies.BottomRight].y = currentHeight;
+                quad.uvs.vertices[QuadVerticies.BottomLeft].y = currentHeight;
+            }
             else {
                 quad.positions.vertices[QuadVerticies.TopLeft].y = 1;
                 quad.positions.vertices[QuadVerticies.TopRight].y = 1;
+                quad.positions.vertices[QuadVerticies.BottomLeft].y = 0;
+                quad.positions.vertices[QuadVerticies.BottomRight].y = 0;
                 quad.setUVs(uvs);
             }
-            addVoxelQuad(tool, tool.origin, quad);
-            tool.updateBounds(quadBounds[VoxelFaces.West]);
+            GetTexture(builder, flowTexture, VoxelFaces.Up, quad);
+            addVoxelQuad(builder, quad);
+            builder.updateBounds(quad.bounds);
         }
-        this.builder.vars.light.setAll(0);
+        builder.vars.light.setAll(0);
         return added;
     }
 }

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

@@ -0,0 +1,13 @@
+import { Vec4Array } from "@amodx/math";
+import { VoxelFaces } from "../../../../Math";
+import { Quad } from "../../../Geomtry/Primitives/Quad";
+import { GeoemtryNode } from "../GeometryNode";
+import { CompiledQuadVoxelGeomtryNode, QuadVoxelGometryArgs } from "../Types/QuadVoxelGometryNodeTypes";
+export declare class QuadVoxelGometryNode extends GeoemtryNode<CompiledQuadVoxelGeomtryNode, QuadVoxelGometryArgs> {
+    quad: Quad;
+    vertexWeights: [Vec4Array, Vec4Array, Vec4Array, Vec4Array];
+    closestFace: VoxelFaces;
+    trueFaceIndex?: number;
+    init(): void;
+    add(args: QuadVoxelGometryArgs): boolean;
+}

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

@@ -0,0 +1,55 @@
+import { Quad } from "../../../Geomtry/Primitives/Quad";
+import { addVoxelQuad } from "../../../Geomtry/VoxelGeometryBuilder";
+import { GeoemtryNode } from "../GeometryNode";
+import { QuadVoxelGometryInputs, } from "../Types/QuadVoxelGometryNodeTypes";
+import { GetTexture } from "../../Common/GetTexture";
+import { CullRulledFace } from "../../Common/Faces/CullRulledFace";
+import { ShadeRulledFace } from "../../Common/Faces/ShadeRulledFace";
+import { ShadeRulelessFace } from "../../Common/Faces/ShadeRulelessFace";
+const ArgIndexes = QuadVoxelGometryInputs.ArgIndexes;
+export class QuadVoxelGometryNode extends GeoemtryNode {
+    quad;
+    vertexWeights;
+    closestFace;
+    trueFaceIndex;
+    init() {
+        this.quad = Quad.Create(this.data.positions);
+        this.vertexWeights = this.data.weights;
+        this.closestFace = this.data.closestFace;
+        if (this.data.trueFaceIndex !== undefined)
+            this.trueFaceIndex = this.data.trueFaceIndex;
+    }
+    add(args) {
+        if (!args[ArgIndexes.Enabled])
+            return false;
+        if (this.trueFaceIndex !== undefined &&
+            !CullRulledFace(this.builder, this.trueFaceIndex))
+            return false;
+        const builder = this.builder;
+        builder.calculateFaceData(this.closestFace);
+        this.trueFaceIndex !== undefined
+            ? ShadeRulledFace(this.builder, this.trueFaceIndex, this.builder.lightData[this.closestFace], this.vertexWeights, 4)
+            : ShadeRulelessFace(this.builder, this.builder.lightData[this.closestFace], this.vertexWeights, 4);
+        const quad = this.quad;
+        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];
+        GetTexture(builder, args[ArgIndexes.Texture], this.closestFace, quad);
+        addVoxelQuad(builder, quad);
+        builder.updateBounds(quad.bounds);
+        builder.vars.light.setAll(0);
+        builder.vars.ao.setAll(0);
+        return true;
+    }
+}

package/Mesher/Models/Nodes/Default/TriangleVoxelGeometryNode.d.ts

@@ -0,0 +1,13 @@
+import { Vec4Array } from "@amodx/math";
+import { VoxelFaces } from "../../../../Math";
+import { GeoemtryNode } from "../GeometryNode";
+import { CompiledTriangleVoxelGeomtryNode, TriangleVoxelGometryArgs } from "../Types/TriangleVoxelGometryNodeTypes";
+import { Triangle } from "../../../Geomtry/Primitives/Triangle";
+export declare class TriangleVoxelGeometryNode extends GeoemtryNode<CompiledTriangleVoxelGeomtryNode, TriangleVoxelGometryArgs> {
+    triangle: Triangle;
+    vertexWeights: Vec4Array[];
+    closestFace: VoxelFaces;
+    trueFaceIndex?: number;
+    init(): void;
+    add(args: TriangleVoxelGometryArgs): boolean;
+}

package/Mesher/Models/Nodes/Default/TriangleVoxelGeometryNode.js

@@ -0,0 +1,52 @@
+import { addVoxelTriangle } from "../../../Geomtry/VoxelGeometryBuilder";
+import { GeoemtryNode } from "../GeometryNode";
+import { GetTexture } from "../../Common/GetTexture";
+import { TriangleVoxelGometryInputs, } from "../Types/TriangleVoxelGometryNodeTypes";
+import { Triangle } from "../../../Geomtry/Primitives/Triangle";
+import { CullRulledFace } from "../../Common/Faces/CullRulledFace";
+import { ShadeRulledFace } from "../../Common/Faces/ShadeRulledFace";
+import { ShadeRulelessFace } from "../../Common/Faces/ShadeRulelessFace";
+const ArgIndexes = TriangleVoxelGometryInputs.ArgIndexes;
+export class TriangleVoxelGeometryNode extends GeoemtryNode {
+    triangle;
+    vertexWeights;
+    closestFace;
+    trueFaceIndex;
+    init() {
+        this.triangle = Triangle.Create(this.data.positions);
+        this.vertexWeights = this.data.weights;
+        this.closestFace = this.data.closestFace;
+        if (this.data.trueFaceIndex !== undefined)
+            this.trueFaceIndex = this.data.trueFaceIndex;
+    }
+    add(args) {
+        if (!args[ArgIndexes.Enabled])
+            return false;
+        if (this.trueFaceIndex !== undefined &&
+            !CullRulledFace(this.builder, this.trueFaceIndex))
+            return false;
+        const builder = this.builder;
+        builder.calculateFaceData(this.closestFace);
+        this.trueFaceIndex !== undefined
+            ? ShadeRulledFace(this.builder, this.trueFaceIndex, this.builder.lightData[this.closestFace], this.vertexWeights, 3)
+            : ShadeRulelessFace(this.builder, this.builder.lightData[this.closestFace], this.vertexWeights, 3);
+        const tri = this.triangle;
+        tri.doubleSided = args[ArgIndexes.DoubleSided];
+        const uvs = args[ArgIndexes.UVs];
+        //1
+        tri.uvs.vertices[0].x = uvs[0][0];
+        tri.uvs.vertices[0].y = uvs[0][1];
+        //2
+        tri.uvs.vertices[1].x = uvs[1][0];
+        tri.uvs.vertices[1].y = uvs[1][1];
+        //3
+        tri.uvs.vertices[2].x = uvs[2][0];
+        tri.uvs.vertices[2].y = uvs[2][1];
+        GetTexture(builder, args[ArgIndexes.Texture], this.closestFace, tri);
+        addVoxelTriangle(builder, tri);
+        builder.updateBounds(tri.bounds);
+        builder.vars.light.setAll(0);
+        builder.vars.ao.setAll(0);
+        return true;
+    }
+}