@divinevoxel/vlox 0.0.74 → 0.0.75

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

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

@@ -1,20 +1,14 @@
 import { VoxelModelBuilder } from "../VoxelModelBuilder";
 import { VoxelGeometryConstructor } from "./VoxelGeometryConstructor";
-import { VoxelGeometryTransform } from "../../../Voxels/Types/VoxelModelCompiledData.types";
 export interface GeoemtryNodeConstructor<Data = any, Args = any> {
-    new (geometryPaletteId: number, geomtry: VoxelGeometryConstructor, data: Data, transform: VoxelGeometryTransform): GeoemtryNode<Data, Args>;
+    new (geometryPaletteId: number, geomtry: VoxelGeometryConstructor, data: Data): GeoemtryNode<Data, Args>;
 }
 export declare abstract class GeoemtryNode<Data = any, Args = any> {
     geometryPaletteId: number;
     geomtry: VoxelGeometryConstructor;
     data: Data;
-    transform: VoxelGeometryTransform;
-    faceIndex: number;
-    vertexIndex: number;
-    faceCount: number;
-    vertexCount: number;
     builder: VoxelModelBuilder;
-    constructor(geometryPaletteId: number, geomtry: VoxelGeometryConstructor, data: Data, transform: VoxelGeometryTransform);
+    constructor(geometryPaletteId: number, geomtry: VoxelGeometryConstructor, data: Data);
     abstract init(): void;
     abstract add(args: Args): boolean;
 }

package/Mesher/Models/Nodes/GeometryNode.js

@@ -2,16 +2,10 @@ export class GeoemtryNode {
     geometryPaletteId;
     geomtry;
     data;
-    transform;
-    faceIndex = -1;
-    vertexIndex = -1;
-    faceCount = -1;
-    vertexCount = -1;
     builder;
-    constructor(geometryPaletteId, geomtry, data, transform) {
+    constructor(geometryPaletteId, geomtry, data) {
         this.geometryPaletteId = geometryPaletteId;
         this.geomtry = geomtry;
         this.data = data;
-        this.transform = transform;
     }
 }

package/Mesher/Models/Nodes/Types/GeomtryNode.types.d.ts

@@ -0,0 +1,7 @@
+import { CompiledQuadVoxelGeomtryNode } from "./QuadVoxelGometryNodeTypes";
+import { CompiledTriangleVoxelGeomtryNode } from "./TriangleVoxelGometryNodeTypes";
+export type CompiledCustomGeomtryNode = {
+    type: "custom";
+    id: string;
+};
+export type CompiledGeomtryNodes = CompiledQuadVoxelGeomtryNode | CompiledTriangleVoxelGeomtryNode | CompiledCustomGeomtryNode;

package/Mesher/Models/Nodes/Types/QuadVoxelGometryNodeTypes.d.ts

@@ -0,0 +1,29 @@
+import { Vec3Array, Vec4Array } from "@amodx/math";
+import { QuadUVData } from "../../../Geomtry/Geometry.types";
+import { VoxelFaces } from "../../../../Math";
+export type QuadVoxelGometryArgs = [
+    enabled: boolean,
+    texture: number,
+    rotation: number,
+    doubleSided: boolean,
+    uvs: QuadUVData
+];
+declare enum ArgIndexes {
+    Enabled = 0,
+    Texture = 1,
+    Rotation = 2,
+    DoubleSided = 3,
+    UVs = 4
+}
+export type CompiledQuadVoxelGeomtryNode = {
+    type: "quad";
+    positions: [Vec3Array, Vec3Array, Vec3Array, Vec3Array];
+    weights: [Vec4Array, Vec4Array, Vec4Array, Vec4Array];
+    closestFace: VoxelFaces;
+    trueFaceIndex?: number;
+};
+export declare class QuadVoxelGometryInputs {
+    static ArgIndexes: typeof ArgIndexes;
+    static CreateArgs(): QuadVoxelGometryArgs;
+}
+export {};

package/{Models/Input/QuadVoxelGometryInputs.js → Mesher/Models/Nodes/Types/QuadVoxelGometryNodeTypes.js}

@@ -1,22 +1,18 @@
 var ArgIndexes;
 (function (ArgIndexes) {
     ArgIndexes[ArgIndexes["Enabled"] = 0] = "Enabled";
-    ArgIndexes[ArgIndexes["Fliped"] = 1] = "Fliped";
-    ArgIndexes[ArgIndexes["Texture"] = 2] = "Texture";
-    ArgIndexes[ArgIndexes["Rotation"] = 3] = "Rotation";
-    ArgIndexes[ArgIndexes["Transparent"] = 4] = "Transparent";
-    ArgIndexes[ArgIndexes["DoubleSided"] = 5] = "DoubleSided";
-    ArgIndexes[ArgIndexes["UVs"] = 6] = "UVs";
+    ArgIndexes[ArgIndexes["Texture"] = 1] = "Texture";
+    ArgIndexes[ArgIndexes["Rotation"] = 2] = "Rotation";
+    ArgIndexes[ArgIndexes["DoubleSided"] = 3] = "DoubleSided";
+    ArgIndexes[ArgIndexes["UVs"] = 4] = "UVs";
 })(ArgIndexes || (ArgIndexes = {}));
 export class QuadVoxelGometryInputs {
     static ArgIndexes = ArgIndexes;
     static CreateArgs() {
         const args = [];
         args[ArgIndexes.Enabled] = true;
-        args[ArgIndexes.Fliped] = false;
         args[ArgIndexes.Texture] = 0;
         args[ArgIndexes.Rotation] = 0;
-        args[ArgIndexes.Transparent] = false;
         args[ArgIndexes.DoubleSided] = false;
         args[ArgIndexes.UVs] = [
             [1, 1],

package/Mesher/Models/Nodes/Types/TriangleVoxelGometryNodeTypes.d.ts

@@ -0,0 +1,28 @@
+import { Vec2Array, Vec3Array, Vec4Array } from "@amodx/math";
+import { VoxelFaces } from "../../../../Math";
+export type TriangleVoxelGometryArgs = [
+    enabled: boolean,
+    texture: number,
+    rotation: number,
+    doubleSided: boolean,
+    uvs: [v1: Vec2Array, v2: Vec2Array, v3: Vec2Array]
+];
+declare enum ArgIndexes {
+    Enabled = 0,
+    Texture = 1,
+    Rotation = 2,
+    DoubleSided = 3,
+    UVs = 4
+}
+export type CompiledTriangleVoxelGeomtryNode = {
+    type: "triangle";
+    positions: [Vec3Array, Vec3Array, Vec3Array];
+    weights: [Vec4Array, Vec4Array, Vec4Array];
+    closestFace: VoxelFaces;
+    trueFaceIndex?: number;
+};
+export declare class TriangleVoxelGometryInputs {
+    static ArgIndexes: typeof ArgIndexes;
+    static CreateArgs(): TriangleVoxelGometryArgs;
+}
+export {};

package/Mesher/Models/Nodes/Types/TriangleVoxelGometryNodeTypes.js

@@ -0,0 +1,24 @@
+var ArgIndexes;
+(function (ArgIndexes) {
+    ArgIndexes[ArgIndexes["Enabled"] = 0] = "Enabled";
+    ArgIndexes[ArgIndexes["Texture"] = 1] = "Texture";
+    ArgIndexes[ArgIndexes["Rotation"] = 2] = "Rotation";
+    ArgIndexes[ArgIndexes["DoubleSided"] = 3] = "DoubleSided";
+    ArgIndexes[ArgIndexes["UVs"] = 4] = "UVs";
+})(ArgIndexes || (ArgIndexes = {}));
+export class TriangleVoxelGometryInputs {
+    static ArgIndexes = ArgIndexes;
+    static CreateArgs() {
+        const args = [];
+        args[ArgIndexes.Enabled] = true;
+        args[ArgIndexes.Texture] = 0;
+        args[ArgIndexes.Rotation] = 0;
+        args[ArgIndexes.DoubleSided] = false;
+        args[ArgIndexes.UVs] = [
+            [1, 1],
+            [0, 1],
+            [0, 0],
+        ];
+        return args;
+    }
+}

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

@@ -1,13 +1,9 @@
-import { VoxelFaceCullResultsIndex } from "../../../Models/Indexing/VoxelFaceCullResultsIndex";
-import { VoxelAOResultsIndex } from "../../../Models/Indexing/VoxelAOResultsIndex";
-import { CompiledVoxelGeometryRulessData, CompiledVoxelGeometrySyncData } from "../../../Voxels/Types/VoxelModelCompiledData.types";
+import { CompiledVoxelGeometrySyncData } from "../../../Voxels/Models/CompiledVoxelModel.types";
 import { GeoemtryNode } from "./GeometryNode";
+import { CullingProcedureData } from "../../../Voxels/Models/VoxelModel.types";
 export declare class VoxelGeometryConstructor {
     geometryPaletteId: number;
     nodes: GeoemtryNode<any, any>[];
-    faceCullMap: number[][];
-    vertexHitMap: number[][];
-    cullIndex: VoxelFaceCullResultsIndex;
-    aoIndex: VoxelAOResultsIndex;
-    constructor(geometryPaletteId: number, data: CompiledVoxelGeometrySyncData | CompiledVoxelGeometryRulessData);
+    cullingProcedure: CullingProcedureData;
+    constructor(geometryPaletteId: number, data: CompiledVoxelGeometrySyncData);
 }