@divinevoxel/vlox 0.0.80 → 0.0.81

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

@@ -3,63 +3,77 @@ import { GeometryLUT } from "../../../../../Voxels/Data/GeometryLUT";
 import { getInterpolationValue } from "../Calc/CalcConstants";
 import { VoxelLUT } from "../../../../../Voxels/Data/VoxelLUT";
 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;
+    const voxel = builder.voxel;
+    const noAO = voxel.isLightSource() || voxel.noAO();
+    const worldLightVerts = builder.vars.light.vertices;
+    const worldAOVerts = builder.vars.ao.vertices;
+    const space = builder.space;
+    const foundHash = space.foundHash;
+    const posX = builder.position.x;
+    const posY = builder.position.y;
+    const posZ = builder.position.z;
+    const nVoxel = builder.nVoxel;
+    const aoVertexHitMap = GeometryLUT.aoVertexHitMap;
+    const geometryIndex = GeometryLUT.geometryIndex;
+    const aoIndex = GeometryLUT.aoIndex;
+    const voxelIdToState = VoxelLUT.voxelIdToState;
     for (let v = 0; v < vertexStride; v++) {
-        worldAO.vertices[v] = 0;
-        worldLight.vertices[v] = getInterpolationValue(lightData, vertexWeights[v]);
+        worldAOVerts[v] = 0;
+        worldLightVerts[v] = getInterpolationValue(lightData, vertexWeights[v]);
         if (noAO)
             continue;
-        const aoIndexes = GeometryLUT.aoVertexHitMap[trueFaceIndex][v];
+        const aoIndexes = aoVertexHitMap[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)
+            const hashed = space.getHash(nVoxel, posX + p[0], posY + p[1], posZ + p[2]);
+            if (foundHash[hashed] < 2)
                 continue;
-            const voxelId = builder.space.voxelCache[hashed];
-            const reltionalVoxelId = builder.space.reltionalVoxelCache[hashed];
-            const geometryIndex = VoxelLUT.getGeometryIndex(voxelId, reltionalVoxelId);
-            const baseGeo = GeometryLUT.geometryIndex[geometryIndex];
-            //  if (!baseGeo && !conditonalGeo) continue;
-            let shaded = false;
-            if (baseGeo) {
-                for (let geoIndex = 0; geoIndex < baseGeo.length; geoIndex++) {
-                    if (GeometryLUT.aoIndex.getValue(baseGeo[geoIndex], directionIndex, trueFaceIndex, v)) {
-                        worldAO.vertices[v]++;
-                        if (worldAO.vertices[v] >= 3) {
-                            shaded = true;
-                            break;
+            let count = 1;
+            for (let s = 0; s < count; s++) {
+                let secondary = s == 1 ? true : false;
+                if (space.getNoCastAO(hashed, secondary))
+                    continue;
+                const voxelId = space.getVoxelId(hashed, secondary);
+                const reltionalVoxelId = space.getRelationalVoxelId(hashed, secondary);
+                const geoIdx = VoxelLUT.getGeometryIndex(voxelId, reltionalVoxelId);
+                const baseGeo = geometryIndex[geoIdx];
+                let shaded = false;
+                if (baseGeo) {
+                    for (let geoIndex = 0; geoIndex < baseGeo.length; geoIndex++) {
+                        if (aoIndex.getValue(baseGeo[geoIndex], directionIndex, trueFaceIndex, v)) {
+                            if (++worldAOVerts[v] >= 3) {
+                                shaded = true;
+                                break;
+                            }
                         }
                     }
                 }
-            }
-            if (shaded)
-                continue;
-            const trueVoxelId = builder.space.trueVoxelCache[hashed];
-            const offsetConditonalGeometry = VoxelLUT.getConditionalGeometryNodes(trueVoxelId);
-            if (offsetConditonalGeometry) {
-                const modelState = VoxelLUT.voxelIdToModelState[voxelId];
-                const reltioanlModSeltate = builder.space.reltionalStateCache[hashed];
-                for (let i = 0; i < offsetConditonalGeometry.length; i++) {
-                    const [geoId, requiredModelState, requiredReltionalModelState] = offsetConditonalGeometry[i];
-                    if (requiredModelState !== modelState ||
-                        !requiredReltionalModelState[reltioanlModSeltate])
-                        continue;
-                    const geomerties = GeometryLUT.geometryIndex[geoId];
-                    for (let geoIndex = 0; geoIndex < geomerties.length; geoIndex++) {
-                        const geoId = geomerties[geoIndex];
-                        if (GeometryLUT.aoIndex.getValue(geoId, directionIndex, trueFaceIndex, v)) {
-                            worldAO.vertices[v]++;
-                            if (worldAO.vertices[v] >= 3) {
-                                shaded = true;
-                                break;
+                if (shaded)
+                    continue;
+                const trueVoxelId = space.getTrueVoxelId(hashed, secondary);
+                const offsetConditonalGeometry = VoxelLUT.getConditionalGeometryNodes(trueVoxelId);
+                if (offsetConditonalGeometry) {
+                    const modelState = voxelIdToState[voxelId];
+                    const relationalModState = space.getRelationalState(hashed, secondary);
+                    for (let j = 0; j < offsetConditonalGeometry.length; j++) {
+                        const [geoId, requiredModelState, requiredReltionalModelState] = offsetConditonalGeometry[j];
+                        if (requiredModelState !== modelState ||
+                            !requiredReltionalModelState[relationalModState])
+                            continue;
+                        const geometries = geometryIndex[geoId];
+                        for (let k = 0; k < geometries.length; k++) {
+                            if (aoIndex.getValue(geometries[k], directionIndex, trueFaceIndex, v)) {
+                                if (++worldAOVerts[v] >= 3) {
+                                    shaded = true;
+                                    break;
+                                }
                             }
                         }
+                        if (shaded)
+                            break;
                     }
                 }
             }

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

@@ -1,4 +1,3 @@
-import { QuadVerticies } from "../../../../../Geometry/Geometry.types";
 import { CompassAngles } from "@amodx/math";
 var FlowStates;
 (function (FlowStates) {
@@ -69,10 +68,10 @@ export function getFlowAngle(vertexLevel) {
         returnData[1] = FlowStates.None;
         return returnData;
     }
-    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 upRight = vertexLevel.vertices[0 /* QuadVerticies.TopRight */];
+    const upLeft = vertexLevel.vertices[1 /* QuadVerticies.TopLeft */];
+    const downLeft = vertexLevel.vertices[2 /* QuadVerticies.BottomLeft */];
+    const downRight = vertexLevel.vertices[3 /* QuadVerticies.BottomRight */];
     const upEqual = upRight == upLeft;
     const downEqual = downRight == downLeft;
     const rightEqual = upRight == downRight;

package/Mesher/Voxels/Models/Nodes/Custom/Liquid/LiquidGeometryNode.d.ts

@@ -4,7 +4,7 @@ import { VoxelFaces } from "../../../../../../Math";
 import type { LiquidVoxelModelArgs } from "../../../../../../Voxels/Models/Defaults/LiquidVoxelModel";
 export declare class LiquidGeometryNode extends GeoemtryNode<VoxelCustomGeometryNode, LiquidVoxelModelArgs> {
     init(): void;
-    isExposed(face: VoxelFaces): boolean;
+    isExposed(face: VoxelFaces, voxelId: number): boolean;
     determineShading(face: VoxelFaces): void;
     add(args: LiquidVoxelModelArgs): boolean;
 }

package/Mesher/Voxels/Models/Nodes/Custom/Liquid/LiquidGeometryNode.js

@@ -1,9 +1,8 @@
 import { GeoemtryNode } from "../../GeometryNode";
 import { CompassAngles } from "@amodx/math";
 import { Quad } from "../../../../../Geometry/Primitives/Quad";
-import { QuadVerticies, } from "../../../../../Geometry/Geometry.types";
 import { QuadScalarVertexData } from "../../../../../Geometry/Primitives/QuadVertexData";
-import { VoxelFaceDirections, VoxelFaces } from "../../../../../../Math";
+import { VoxelFaceDirections } from "../../../../../../Math";
 import { getFlowAngle, getFlowGradient, FlowVerticies } from "./FlowGradient";
 import { VoxelLightData } from "../../../../../../Voxels/Cursor/VoxelLightData";
 import { addVoxelQuad } from "../../../../Geometry/VoxelGeometryBuilder";
@@ -33,22 +32,20 @@ const { quads: Quads } = Box.Create([
     [0, 0, 0],
     [1, waterHeight, 1],
 ]);
-Quads[VoxelFaces.Up].setUVs(uvs);
-Quads[VoxelFaces.Down].setUVs(uvs);
+Quads[0 /* VoxelFaces.Up */].setUVs(uvs);
+Quads[1 /* VoxelFaces.Down */].setUVs(uvs);
 export class LiquidGeometryNode extends GeoemtryNode {
     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)
+    isExposed(face, voxelId) {
+        const hashed = this.builder.space.getHash(this.builder.nVoxel, VoxelFaceDirections[face][0] + this.builder.position.x, VoxelFaceDirections[face][1] + this.builder.position.y, VoxelFaceDirections[face][2] + this.builder.position.z);
+        const found = this.builder.space.foundHash[hashed];
+        if (!found)
             return true;
-        if (this.builder.voxel.isSameVoxel(nv))
+        if (voxelId == this.builder.space.getTrueVoxelId(hashed))
             return false;
-        if (nv.isAir() || nv.tags["dve_is_transparent"])
+        if (found == 1 || found == 3)
             return true;
-        if (face == VoxelFaces.Up)
+        if (face == 0 /* VoxelFaces.Up */)
             return true;
         return false;
     }
@@ -77,26 +74,27 @@ export class LiquidGeometryNode extends GeoemtryNode {
           flowTexture = 0;
           stillTexture = 0;
         } */
+        const voxelId = builder.voxel.getVoxelId();
         let added = false;
         let upFaceExposed = false;
-        if (this.isExposed(VoxelFaces.Up)) {
+        if (this.isExposed(0 /* VoxelFaces.Up */, voxelId)) {
             upFaceExposed = true;
             added = true;
             getFlowGradient(builder, vertexLevel);
-            const quad = Quads[VoxelFaces.Up];
-            this.determineShading(VoxelFaces.Up);
+            const quad = Quads[0 /* VoxelFaces.Up */];
+            this.determineShading(0 /* VoxelFaces.Up */);
             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]];
             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];
-            quad.uvs.vertices[QuadVerticies.TopLeft].y = uvSet[1][1];
-            quad.uvs.vertices[QuadVerticies.BottomLeft].x = uvSet[2][0];
-            quad.uvs.vertices[QuadVerticies.BottomLeft].y = uvSet[2][1];
-            quad.uvs.vertices[QuadVerticies.BottomRight].x = uvSet[3][0];
-            quad.uvs.vertices[QuadVerticies.BottomRight].y = uvSet[3][1];
+            quad.uvs.vertices[0 /* QuadVerticies.TopRight */].x = uvSet[0][0];
+            quad.uvs.vertices[0 /* QuadVerticies.TopRight */].y = uvSet[0][1];
+            quad.uvs.vertices[1 /* QuadVerticies.TopLeft */].x = uvSet[1][0];
+            quad.uvs.vertices[1 /* QuadVerticies.TopLeft */].y = uvSet[1][1];
+            quad.uvs.vertices[2 /* QuadVerticies.BottomLeft */].x = uvSet[2][0];
+            quad.uvs.vertices[2 /* QuadVerticies.BottomLeft */].y = uvSet[2][1];
+            quad.uvs.vertices[3 /* QuadVerticies.BottomRight */].x = uvSet[3][0];
+            quad.uvs.vertices[3 /* QuadVerticies.BottomRight */].y = uvSet[3][1];
             quad.positions.vertices[0].y = vertexValue.vertices[0] * waterHeight;
             quad.positions.vertices[1].y = vertexValue.vertices[1] * waterHeight;
             quad.positions.vertices[2].y = vertexValue.vertices[2] * waterHeight;
@@ -105,176 +103,176 @@ export class LiquidGeometryNode extends GeoemtryNode {
                 vertexLevel.vertices[1] != 7 ||
                 vertexLevel.vertices[2] != 7 ||
                 vertexLevel.vertices[3] != 7) {
-                GetTexture(builder, flowTexture, VoxelFaces.Up, quad);
+                GetTexture(builder, flowTexture, 0 /* VoxelFaces.Up */, quad);
             }
             else {
-                GetTexture(builder, stillTexture, VoxelFaces.Up, quad);
+                GetTexture(builder, stillTexture, 0 /* VoxelFaces.Up */, quad);
             }
             addVoxelQuad(builder, quad);
             builder.updateBounds(quad.bounds);
         }
-        if (this.isExposed(VoxelFaces.Down)) {
+        if (this.isExposed(1 /* VoxelFaces.Down */, voxelId)) {
             added = true;
-            const quad = Quads[VoxelFaces.Down];
+            const quad = Quads[1 /* 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;
+                quad.positions.vertices[0 /* QuadVerticies.TopRight */].y = currentHeight;
+                quad.positions.vertices[1 /* QuadVerticies.TopLeft */].y = currentHeight;
+                quad.positions.vertices[3 /* QuadVerticies.BottomRight */].y = currentHeight;
+                quad.positions.vertices[2 /* 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.positions.vertices[0 /* QuadVerticies.TopRight */].y = 0;
+                quad.positions.vertices[1 /* QuadVerticies.TopLeft */].y = 0;
+                quad.positions.vertices[2 /* QuadVerticies.BottomLeft */].y = 0;
+                quad.positions.vertices[3 /* QuadVerticies.BottomRight */].y = 0;
             }
             quad.setUVs(uvs);
-            this.determineShading(VoxelFaces.Down);
-            GetTexture(builder, stillTexture, VoxelFaces.Up, quad);
+            this.determineShading(1 /* VoxelFaces.Down */);
+            GetTexture(builder, stillTexture, 0 /* VoxelFaces.Up */, quad);
             addVoxelQuad(builder, quad);
             builder.updateBounds(quad.bounds);
         }
-        if (this.isExposed(VoxelFaces.North)) {
+        if (this.isExposed(2 /* VoxelFaces.North */, voxelId)) {
             added = true;
-            const quad = Quads[VoxelFaces.North];
+            const quad = Quads[2 /* VoxelFaces.North */];
             builder.vars.animation.setAll(1);
-            this.determineShading(VoxelFaces.North);
+            this.determineShading(2 /* VoxelFaces.North */);
             if (upFaceExposed) {
-                quad.positions.vertices[QuadVerticies.TopRight].y =
+                quad.positions.vertices[0 /* QuadVerticies.TopRight */].y =
                     vertexValue.vertices[FlowVerticies.NorthWest] * waterHeight;
-                quad.positions.vertices[QuadVerticies.TopLeft].y =
+                quad.positions.vertices[1 /* 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 =
+                quad.positions.vertices[2 /* QuadVerticies.BottomLeft */].y = 0;
+                quad.positions.vertices[3 /* QuadVerticies.BottomRight */].y = 0;
+                quad.uvs.vertices[0 /* QuadVerticies.TopRight */].y =
                     vertexValue.vertices[FlowVerticies.NorthWest];
-                quad.uvs.vertices[QuadVerticies.TopLeft].y =
+                quad.uvs.vertices[1 /* 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;
+                quad.positions.vertices[0 /* QuadVerticies.TopRight */].y = 1;
+                quad.positions.vertices[1 /* QuadVerticies.TopLeft */].y = 1;
+                quad.positions.vertices[3 /* QuadVerticies.BottomRight */].y = currentHeight;
+                quad.positions.vertices[2 /* QuadVerticies.BottomLeft */].y = currentHeight;
+                quad.uvs.vertices[3 /* QuadVerticies.BottomRight */].y = currentHeight;
+                quad.uvs.vertices[2 /* 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.positions.vertices[0 /* QuadVerticies.TopRight */].y = 1;
+                quad.positions.vertices[1 /* QuadVerticies.TopLeft */].y = 1;
+                quad.positions.vertices[2 /* QuadVerticies.BottomLeft */].y = 0;
+                quad.positions.vertices[3 /* QuadVerticies.BottomRight */].y = 0;
                 quad.setUVs(uvs);
             }
-            GetTexture(builder, flowTexture, VoxelFaces.North, quad);
+            GetTexture(builder, flowTexture, 2 /* VoxelFaces.North */, quad);
             addVoxelQuad(builder, quad);
             builder.updateBounds(quad.bounds);
         }
-        if (this.isExposed(VoxelFaces.South)) {
+        if (this.isExposed(3 /* VoxelFaces.South */, voxelId)) {
             added = true;
-            const quad = Quads[VoxelFaces.South];
+            const quad = Quads[3 /* VoxelFaces.South */];
             builder.vars.animation.setAll(1);
-            this.determineShading(VoxelFaces.South);
+            this.determineShading(3 /* VoxelFaces.South */);
             if (upFaceExposed) {
-                quad.positions.vertices[QuadVerticies.TopRight].y =
+                quad.positions.vertices[0 /* QuadVerticies.TopRight */].y =
                     vertexValue.vertices[FlowVerticies.SouthEsat] * waterHeight;
-                quad.positions.vertices[QuadVerticies.TopLeft].y =
+                quad.positions.vertices[1 /* 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 =
+                quad.positions.vertices[2 /* QuadVerticies.BottomLeft */].y = 0;
+                quad.positions.vertices[3 /* QuadVerticies.BottomRight */].y = 0;
+                quad.uvs.vertices[0 /* QuadVerticies.TopRight */].y =
                     vertexValue.vertices[FlowVerticies.SouthEsat];
-                quad.uvs.vertices[QuadVerticies.TopLeft].y =
+                quad.uvs.vertices[1 /* 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;
+                quad.positions.vertices[0 /* QuadVerticies.TopRight */].y = 1;
+                quad.positions.vertices[1 /* QuadVerticies.TopLeft */].y = 1;
+                quad.positions.vertices[3 /* QuadVerticies.BottomRight */].y = currentHeight;
+                quad.positions.vertices[2 /* QuadVerticies.BottomLeft */].y = currentHeight;
+                quad.uvs.vertices[3 /* QuadVerticies.BottomRight */].y = currentHeight;
+                quad.uvs.vertices[2 /* 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.positions.vertices[1 /* QuadVerticies.TopLeft */].y = 1;
+                quad.positions.vertices[0 /* QuadVerticies.TopRight */].y = 1;
+                quad.positions.vertices[2 /* QuadVerticies.BottomLeft */].y = 0;
+                quad.positions.vertices[3 /* QuadVerticies.BottomRight */].y = 0;
                 quad.setUVs(uvs);
             }
-            GetTexture(builder, flowTexture, VoxelFaces.Up, quad);
+            GetTexture(builder, flowTexture, 0 /* VoxelFaces.Up */, quad);
             addVoxelQuad(builder, quad);
             builder.updateBounds(quad.bounds);
         }
-        if (this.isExposed(VoxelFaces.East)) {
+        if (this.isExposed(4 /* VoxelFaces.East */, voxelId)) {
             added = true;
-            const quad = Quads[VoxelFaces.East];
+            const quad = Quads[4 /* VoxelFaces.East */];
             builder.vars.animation.setAll(1);
-            this.determineShading(VoxelFaces.East);
+            this.determineShading(4 /* VoxelFaces.East */);
             if (upFaceExposed) {
-                quad.positions.vertices[QuadVerticies.TopRight].y =
+                quad.positions.vertices[0 /* QuadVerticies.TopRight */].y =
                     vertexValue.vertices[FlowVerticies.NorthEast] * waterHeight;
-                quad.positions.vertices[QuadVerticies.TopLeft].y =
+                quad.positions.vertices[1 /* 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 =
+                quad.positions.vertices[2 /* QuadVerticies.BottomLeft */].y = 0;
+                quad.positions.vertices[3 /* QuadVerticies.BottomRight */].y = 0;
+                quad.uvs.vertices[0 /* QuadVerticies.TopRight */].y =
                     vertexValue.vertices[FlowVerticies.SouthEsat];
-                quad.uvs.vertices[QuadVerticies.TopLeft].y =
+                quad.uvs.vertices[1 /* 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;
+                quad.positions.vertices[0 /* QuadVerticies.TopRight */].y = 1;
+                quad.positions.vertices[1 /* QuadVerticies.TopLeft */].y = 1;
+                quad.positions.vertices[3 /* QuadVerticies.BottomRight */].y = currentHeight;
+                quad.positions.vertices[2 /* QuadVerticies.BottomLeft */].y = currentHeight;
+                quad.uvs.vertices[3 /* QuadVerticies.BottomRight */].y = currentHeight;
+                quad.uvs.vertices[2 /* 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.positions.vertices[1 /* QuadVerticies.TopLeft */].y = 1;
+                quad.positions.vertices[0 /* QuadVerticies.TopRight */].y = 1;
+                quad.positions.vertices[2 /* QuadVerticies.BottomLeft */].y = 0;
+                quad.positions.vertices[3 /* QuadVerticies.BottomRight */].y = 0;
                 quad.setUVs(uvs);
             }
-            GetTexture(builder, flowTexture, VoxelFaces.Up, quad);
+            GetTexture(builder, flowTexture, 0 /* VoxelFaces.Up */, quad);
             addVoxelQuad(builder, quad);
             builder.updateBounds(quad.bounds);
         }
-        if (this.isExposed(VoxelFaces.West)) {
+        if (this.isExposed(5 /* VoxelFaces.West */, voxelId)) {
             added = true;
-            const quad = Quads[VoxelFaces.West];
+            const quad = Quads[5 /* VoxelFaces.West */];
             builder.vars.animation.setAll(1);
-            this.determineShading(VoxelFaces.West);
+            this.determineShading(5 /* VoxelFaces.West */);
             if (upFaceExposed) {
-                quad.positions.vertices[QuadVerticies.TopRight].y =
+                quad.positions.vertices[0 /* QuadVerticies.TopRight */].y =
                     vertexValue.vertices[FlowVerticies.SouthWest] * waterHeight;
-                quad.positions.vertices[QuadVerticies.TopLeft].y =
+                quad.positions.vertices[1 /* 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 =
+                quad.positions.vertices[2 /* QuadVerticies.BottomLeft */].y = 0;
+                quad.positions.vertices[3 /* QuadVerticies.BottomRight */].y = 0;
+                quad.uvs.vertices[0 /* QuadVerticies.TopRight */].y =
                     vertexValue.vertices[FlowVerticies.SouthWest];
-                quad.uvs.vertices[QuadVerticies.TopLeft].y =
+                quad.uvs.vertices[1 /* 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;
+                quad.positions.vertices[0 /* QuadVerticies.TopRight */].y = 1;
+                quad.positions.vertices[1 /* QuadVerticies.TopLeft */].y = 1;
+                quad.positions.vertices[3 /* QuadVerticies.BottomRight */].y = currentHeight;
+                quad.positions.vertices[2 /* QuadVerticies.BottomLeft */].y = currentHeight;
+                quad.uvs.vertices[3 /* QuadVerticies.BottomRight */].y = currentHeight;
+                quad.uvs.vertices[2 /* 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.positions.vertices[1 /* QuadVerticies.TopLeft */].y = 1;
+                quad.positions.vertices[0 /* QuadVerticies.TopRight */].y = 1;
+                quad.positions.vertices[2 /* QuadVerticies.BottomLeft */].y = 0;
+                quad.positions.vertices[3 /* QuadVerticies.BottomRight */].y = 0;
                 quad.setUVs(uvs);
             }
-            GetTexture(builder, flowTexture, VoxelFaces.Up, quad);
+            GetTexture(builder, flowTexture, 0 /* VoxelFaces.Up */, quad);
             addVoxelQuad(builder, quad);
             builder.updateBounds(quad.bounds);
         }

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

@@ -22,14 +22,14 @@ export class QuadVoxelGometryNode extends GeoemtryNode {
     add(args) {
         if (!args[ArgIndexes.Enabled])
             return false;
+        const builder = this.builder;
         if (this.trueFaceIndex !== undefined &&
-            !CullRulledFace(this.builder, this.trueFaceIndex))
+            !CullRulledFace(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);
+            ? ShadeRulledFace(builder, this.trueFaceIndex, builder.lightData[this.closestFace], this.vertexWeights, 4)
+            : ShadeRulelessFace(builder, builder.lightData[this.closestFace], this.vertexWeights, 4);
         const quad = this.quad;
         quad.doubleSided = args[ArgIndexes.DoubleSided];
         const uvs = args[ArgIndexes.UVs];

package/Mesher/Voxels/Models/Nodes/VoxelGeometryConstructor.js

@@ -1,6 +1,6 @@
 import { QuadVoxelGometryNode } from "./Default/QuadVoxelGeometryNode";
 import { TriangleVoxelGeometryNode } from "./Default/TriangleVoxelGeometryNode";
-import { VoxelModelConstructorRegister } from "../VoxelModelConstructorRegister";
+import { VoxelGeometryConstructorRegister } from "../VoxelGeometryConstructorRegister";
 import { GeometryLUT } from "../../../../Voxels/Data/GeometryLUT";
 export class VoxelGeometryConstructor {
     geometryPaletteId;
@@ -13,7 +13,7 @@ export class VoxelGeometryConstructor {
         const nodes = GeometryLUT.compiledGeometry[geometryPaletteId];
         for (const node of nodes) {
             if (node.type == "custom") {
-                const nodeClass = VoxelModelConstructorRegister.getCustomNode(node.id);
+                const nodeClass = VoxelGeometryConstructorRegister.getCustomNode(node.id);
                 const newNode = new nodeClass(geometryPaletteId, this, node);
                 newNode.init();
                 this.nodes.push(newNode);