@divinevoxel/vlox 0.0.1 → 0.0.3

package/Mesher/Models/Common/QuadGeometryNode.js

@@ -0,0 +1,51 @@
+import { Vector3Like } from "@amodx/math";
+import { VoxelFaces } from "../../../Math";
+import { Quad } from "@amodx/meshing/Primitives/Quad";
+import { addQuadWeights, closestUnitNormal, } from "./Calc/CalcConstants";
+import { TransformQuad } from "../../../Models/Shared/Transform";
+import { GetBounds } from "./BoundsFunctions";
+export function GetQuadGeometryData(data, transform) {
+    const quad = TransformQuad(Quad.Create(data.points), transform);
+    quad.orientation = 0;
+    const normals = quad.normals.getAsArray();
+    const averageNormal = [0, 0, 0];
+    for (let i = 0; i < normals.length; i++) {
+        averageNormal[0] += normals[i].x;
+        averageNormal[1] += normals[i].y;
+        averageNormal[2] += normals[i].z;
+    }
+    averageNormal[0] /= normals.length;
+    averageNormal[1] /= normals.length;
+    averageNormal[2] /= normals.length;
+    // Normalize the average normal
+    const magnitude = Math.sqrt(averageNormal[0] * averageNormal[0] +
+        averageNormal[1] * averageNormal[1] +
+        averageNormal[2] * averageNormal[2]);
+    if (magnitude !== 0) {
+        averageNormal[0] /= magnitude;
+        averageNormal[1] /= magnitude;
+        averageNormal[2] /= magnitude;
+    }
+    const unitNormal = closestUnitNormal(averageNormal);
+    let closestFace = VoxelFaces.Up;
+    if (unitNormal[0] == 1)
+        closestFace = VoxelFaces.East;
+    if (unitNormal[0] == -1)
+        closestFace = VoxelFaces.West;
+    if (unitNormal[1] == 1)
+        closestFace = VoxelFaces.Up;
+    if (unitNormal[1] == -1)
+        closestFace = VoxelFaces.Down;
+    if (unitNormal[2] == 1)
+        closestFace = VoxelFaces.North;
+    if (unitNormal[2] == -1)
+        closestFace = VoxelFaces.South;
+    const vertexWeights = addQuadWeights(quad, closestFace);
+    closestFace = closestFace;
+    return {
+        quad,
+        vertexWeights,
+        closestFace,
+        quadBounds: GetBounds(quad.positions.getAsArray().map((_) => Vector3Like.ToArray(_)))
+    };
+}

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

@@ -0,0 +1,6 @@
+import type { VoxelMesherDataTool } from "../../../../../Mesher/Tools/VoxelMesherDataTool";
+import { QuadScalarVertexData } from "@amodx/meshing/Primitives/QuadVertexData";
+export declare const FlowGradient: {
+    getLevel(tool: VoxelMesherDataTool, x: number, y: number, z: number): number;
+    calculate(tool: VoxelMesherDataTool, flowStates: QuadScalarVertexData): QuadScalarVertexData;
+};

package/Mesher/{Calc/Flow → Models/Nodes/Custom/Liquid}/FlowGradient.js

@@ -1,4 +1,3 @@
-import { QuadScalarVertexData } from "@amodx/meshing/Classes/QuadVertexData";
 import { QuadVerticies } from "@amodx/meshing/Geometry.types";
 const checkSets = {
     [QuadVerticies.TopRight]: [
@@ -22,26 +21,24 @@ const checkSets = {
         1, -1,
     ],
 };
-const flowStates = new QuadScalarVertexData();
 export const FlowGradient = {
     getLevel(tool, x, y, z) {
-        if (!tool.nVoxel.loadInAt(x, y, z))
+        const voxel = tool.nVoxel.getVoxel(x, y, z);
+        if (!voxel || !voxel.isRenderable())
             return -1;
-        if (!tool.nVoxel.isRenderable())
+        if (!tool.voxel.isSameVoxel(voxel))
             return -1;
-        if (!tool.voxel.isSameVoxel(tool.nVoxel))
-            return -1;
-        const level = tool.nVoxel.getLevel();
-        const levelState = tool.nVoxel.getLevelState();
+        const level = voxel.getLevel();
+        const levelState = voxel.getLevelState();
         if (levelState > 0)
             return 7;
         return level;
     },
-    calculate(tool) {
+    calculate(tool, flowStates) {
         const cl = tool.voxel.getLevel();
         const cs = tool.voxel.getLevelState();
         let log = false;
-        if (tool.voxel.x == -1 && tool.voxel.z == -1) {
+        if (tool.position.x == -1 && tool.position.z == -1) {
             log = true;
         }
         for (let vertex = 0; vertex <= 3; vertex++) {
@@ -49,14 +46,14 @@ export const FlowGradient = {
             let finalLevel = cl;
             let zerCount = 0;
             for (let i = 0; i < 6; i += 2) {
-                const cx = checkSet[i] + tool.voxel.x;
-                const cz = checkSet[i + 1] + tool.voxel.z;
-                const aboveLevel = this.getLevel(tool, cx, tool.voxel.y + 1, cz);
+                const cx = checkSet[i] + tool.position.x;
+                const cz = checkSet[i + 1] + tool.position.z;
+                const aboveLevel = this.getLevel(tool, cx, tool.position.y + 1, cz);
                 if (aboveLevel > 0) {
                     finalLevel = 9;
                     break;
                 }
-                const level = this.getLevel(tool, cx, tool.voxel.y, cz);
+                const level = this.getLevel(tool, cx, tool.position.y, cz);
                 if (level == -1) {
                     zerCount++;
                 }
@@ -69,6 +66,6 @@ export const FlowGradient = {
             }
             flowStates.vertices[vertex] = finalLevel;
         }
-        tool.getWorldLevel().setFromQuadData(flowStates);
+        return flowStates;
     },
 };

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

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

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

@@ -0,0 +1,269 @@
+import { GeoemtryNode } from "../../GeometryNode";
+let flowAnimationState = 0;
+import { CompassAngles } from "@amodx/math";
+import { Quad } from "@amodx/meshing/Primitives/Quad.js";
+import { QuadVerticies } from "@amodx/meshing/Geometry.types.js";
+import { QuadScalarVertexData } from "@amodx/meshing/Primitives/QuadVertexData";
+import { VoxelFaceDirections, VoxelFaces } from "../../../../../Math";
+import { UpdateBounds } from "../../../Common/BoundsFunctions";
+import { VoxelGeometry } from "../../../../../Mesher/Geometry/VoxelGeometry";
+import { LightData } from "../../../../../Voxels/LightData";
+import { shouldCauseFlip } from "../../../Common/Calc/CalcConstants";
+import { FlowGradient } from "./FlowGradient";
+import { GetBoxGeometryNodeData } from "../../../Common/BoxGeometryNode";
+const vertexValue = new QuadScalarVertexData();
+const vertexLevel = new QuadScalarVertexData();
+var FlowStates;
+(function (FlowStates) {
+    FlowStates[FlowStates["None"] = 0] = "None";
+    FlowStates[FlowStates["Down"] = 1] = "Down";
+    FlowStates[FlowStates["Up"] = 2] = "Up";
+})(FlowStates || (FlowStates = {}));
+const waterHeight = 6 / 7;
+const quadRotations = {
+    [CompassAngles.North]: Quad.RotateUvs(Quad.FullUVs, CompassAngles.North),
+    [CompassAngles.South]: Quad.RotateUvs(Quad.FullUVs, CompassAngles.South),
+    [CompassAngles.East]: Quad.RotateUvs(Quad.FullUVs, CompassAngles.East),
+    [CompassAngles.West]: Quad.RotateUvs(Quad.FullUVs, CompassAngles.West),
+    [CompassAngles.NorthWest]: Quad.RotateUvs(Quad.FullUVs, CompassAngles.NorthWest),
+    [CompassAngles.NorthEast]: Quad.RotateUvs(Quad.FullUVs, CompassAngles.NorthEast),
+    [CompassAngles.SouthWest]: Quad.RotateUvs(Quad.FullUVs, CompassAngles.SouthWest),
+    [CompassAngles.SouthEast]: Quad.RotateUvs(Quad.FullUVs, CompassAngles.SouthEast),
+};
+const getFlowAngle = () => {
+    if (vertexLevel.isAllEqualTo(15)) {
+        flowAnimationState = FlowStates.None;
+        return 0;
+    }
+    const upRight = vertexLevel.vertices[QuadVerticies.TopRight];
+    const upLeft = vertexLevel.vertices[QuadVerticies.TopLeft];
+    const downLeft = vertexLevel.vertices[QuadVerticies.BottomLeft];
+    const downRight = vertexLevel.vertices[QuadVerticies.BottomRight];
+    const upEqual = upRight == upLeft;
+    const downEqual = downRight == downLeft;
+    const rightEqual = upRight == downRight;
+    const leftEqual = upLeft == downLeft;
+    if (upEqual && downEqual) {
+        if (upRight < downRight) {
+            flowAnimationState = FlowStates.Up;
+            return CompassAngles.North;
+        }
+        if (upRight > downRight) {
+            flowAnimationState = FlowStates.Up;
+            return CompassAngles.South;
+        }
+    }
+    if (rightEqual && leftEqual) {
+        if (upRight < upLeft) {
+            flowAnimationState = FlowStates.Up;
+            return CompassAngles.East;
+        }
+        if (upRight > upLeft) {
+            flowAnimationState = FlowStates.Up;
+            return CompassAngles.West;
+        }
+    }
+    if ((downRight < upRight && downRight < upLeft && downRight < downLeft) ||
+        (upLeft > upRight && upLeft > downRight && upLeft > downLeft)) {
+        flowAnimationState = FlowStates.Up;
+        return CompassAngles.SouthEast;
+    }
+    if ((upLeft < upRight && upLeft < downRight && upLeft < downLeft) ||
+        (downRight > upRight && downRight > upLeft && downRight > downLeft)) {
+        flowAnimationState = FlowStates.Up;
+        return CompassAngles.NorthWest;
+    }
+    if ((upRight < downRight && upRight < upLeft && upRight < downLeft) ||
+        (downLeft > downRight && downLeft > upLeft && downLeft > upRight)) {
+        flowAnimationState = FlowStates.Up;
+        return CompassAngles.NorthEast;
+    }
+    if ((downLeft < downRight && downLeft < upLeft && downLeft < upRight) ||
+        (upRight > downRight && upRight > upLeft && upRight > downLeft)) {
+        flowAnimationState = FlowStates.Up;
+        return CompassAngles.SouthWest;
+    }
+    return CompassAngles.North;
+};
+const uvs = [
+    [1, 1],
+    [0, 1],
+    [0, 0],
+    [1, 0],
+];
+const { quads: Quads, vertexWeights, quadBounds, } = GetBoxGeometryNodeData([
+    [0, 0, 0],
+    [1, waterHeight, 1],
+], {});
+export class LiquidGeometryNode extends GeoemtryNode {
+    worldLight;
+    init() { }
+    isExposed(face) {
+        const nv = this.tool.nVoxel.getVoxel(VoxelFaceDirections[face][0] + this.tool.position.x, VoxelFaceDirections[face][1] + this.tool.position.y, VoxelFaceDirections[face][2] + this.tool.position.z);
+        if (!nv ||
+            nv.isAir() ||
+            (!this.tool.voxel.isSameVoxel(nv) && face == VoxelFaces.Up))
+            return true;
+        return false;
+    }
+    determineShading(face) {
+        const tool = this.tool;
+        const lightData = tool.lightData[face];
+        const worldLight = this.worldLight;
+        for (let v = 0; v < 4; v++) {
+            worldLight.vertices[v] = lightData[v];
+        }
+    }
+    shouldFlip() {
+        return (shouldCauseFlip(LightData.getS(this.worldLight.vertices[0]), LightData.getS(this.worldLight.vertices[1]), LightData.getS(this.worldLight.vertices[2]), LightData.getS(this.worldLight.vertices[3])) ||
+            shouldCauseFlip(LightData.sumRGB(this.worldLight.vertices[0]), LightData.sumRGB(this.worldLight.vertices[1]), LightData.sumRGB(this.worldLight.vertices[2]), LightData.sumRGB(this.worldLight.vertices[3])));
+    }
+    add(tool, originHash, origin, args) {
+        vertexLevel.setAll(15);
+        vertexValue.setAll(0);
+        this.tool = tool;
+        this.tool = tool;
+        this.origin = tool.position;
+        //     this.worldAO = tool.getWorldAO();
+        this.worldLight = tool.getWorldLight();
+        let upFaceExposed = false;
+        if (this.isExposed(VoxelFaces.Up)) {
+            FlowGradient.calculate(tool, vertexLevel);
+            const quad = Quads[VoxelFaces.Up];
+            tool.calculateFaceData(VoxelFaces.Up);
+            this.determineShading(VoxelFaces.Up);
+            quad.flip = this.shouldFlip();
+            tool.setTexture(args.flowTexture);
+            vertexValue.set(vertexLevel.vertices[0] / 7, vertexLevel.vertices[1] / 7, vertexLevel.vertices[2] / 7, vertexLevel.vertices[3] / 7);
+            const uvAngle = getFlowAngle();
+            const uvSet = quadRotations[uvAngle];
+            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.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;
+            quad.positions.vertices[3].y = vertexValue.vertices[3] * waterHeight;
+            tool.getAnimationData().setAll(flowAnimationState);
+            VoxelGeometry.addQuad(tool, origin, quad);
+            upFaceExposed = true;
+            UpdateBounds(tool, origin, quadBounds[VoxelFaces.Up]);
+        }
+        if (this.isExposed(VoxelFaces.Down)) {
+            tool.setTexture(args.flowTexture);
+            const quad = Quads[VoxelFaces.Down];
+            tool.calculateFaceData(VoxelFaces.Down);
+            this.determineShading(VoxelFaces.Down);
+            quad.flip = this.shouldFlip();
+            tool.setTexture(args.flowTexture);
+            VoxelGeometry.addQuad(tool, origin, quad);
+            UpdateBounds(tool, origin, quadBounds[VoxelFaces.Down]);
+        }
+        if (this.isExposed(VoxelFaces.North)) {
+            tool.setTexture(args.flowTexture);
+            const quad = Quads[VoxelFaces.North];
+            tool.getAnimationData().setAll(1);
+            tool.calculateFaceData(VoxelFaces.North);
+            this.determineShading(VoxelFaces.North);
+            quad.flip = this.shouldFlip();
+            if (upFaceExposed) {
+                quad.positions.vertices[QuadVerticies.TopRight].y =
+                    vertexValue.vertices[QuadVerticies.TopRight] * waterHeight;
+                quad.positions.vertices[QuadVerticies.TopLeft].y =
+                    vertexValue.vertices[QuadVerticies.TopLeft] * waterHeight;
+                quad.uvs.vertices[QuadVerticies.TopRight].y =
+                    vertexValue.vertices[QuadVerticies.TopRight];
+                quad.uvs.vertices[QuadVerticies.TopLeft].y =
+                    vertexValue.vertices[QuadVerticies.TopLeft];
+            }
+            else {
+                quad.positions.vertices[QuadVerticies.TopRight].y = 1;
+                quad.positions.vertices[QuadVerticies.TopLeft].y = 1;
+                quad.setUVs(uvs);
+                UpdateBounds(tool, origin, quadBounds[VoxelFaces.North]);
+            }
+            VoxelGeometry.addQuad(tool, origin, quad);
+        }
+        if (this.isExposed(VoxelFaces.South)) {
+            tool.setTexture(args.flowTexture);
+            const quad = Quads[VoxelFaces.South];
+            tool.getAnimationData().setAll(1);
+            tool.calculateFaceData(VoxelFaces.South);
+            this.determineShading(VoxelFaces.South);
+            quad.flip = this.shouldFlip();
+            if (upFaceExposed) {
+                quad.positions.vertices[QuadVerticies.TopRight].y =
+                    vertexValue.vertices[QuadVerticies.BottomRight] * waterHeight;
+                quad.positions.vertices[QuadVerticies.TopLeft].y =
+                    vertexValue.vertices[QuadVerticies.BottomLeft] * waterHeight;
+                quad.uvs.vertices[QuadVerticies.TopRight].y =
+                    vertexValue.vertices[QuadVerticies.BottomRight];
+                quad.uvs.vertices[QuadVerticies.TopLeft].y =
+                    vertexValue.vertices[QuadVerticies.BottomLeft];
+            }
+            else {
+                quad.positions.vertices[QuadVerticies.TopLeft].y = 1;
+                quad.positions.vertices[QuadVerticies.TopRight].y = 1;
+                quad.setUVs(uvs);
+                UpdateBounds(tool, origin, quadBounds[VoxelFaces.South]);
+            }
+            VoxelGeometry.addQuad(tool, origin, quad);
+        }
+        if (this.isExposed(VoxelFaces.East)) {
+            tool.setTexture(args.flowTexture);
+            const quad = Quads[VoxelFaces.East];
+            tool.getAnimationData().setAll(1);
+            tool.calculateFaceData(VoxelFaces.East);
+            this.determineShading(VoxelFaces.East);
+            quad.flip = this.shouldFlip();
+            if (upFaceExposed) {
+                quad.positions.vertices[QuadVerticies.TopRight].y =
+                    vertexValue.vertices[QuadVerticies.TopRight] * waterHeight;
+                quad.positions.vertices[QuadVerticies.TopLeft].y =
+                    vertexValue.vertices[QuadVerticies.BottomRight] * waterHeight;
+                quad.uvs.vertices[QuadVerticies.TopRight].y =
+                    vertexValue.vertices[QuadVerticies.TopRight];
+                quad.uvs.vertices[QuadVerticies.TopLeft].y =
+                    vertexValue.vertices[QuadVerticies.BottomRight];
+            }
+            else {
+                quad.positions.vertices[QuadVerticies.TopLeft].y = 1;
+                quad.positions.vertices[QuadVerticies.TopRight].y = 1;
+                quad.setUVs(uvs);
+                UpdateBounds(tool, origin, quadBounds[VoxelFaces.East]);
+            }
+            VoxelGeometry.addQuad(tool, origin, quad);
+        }
+        if (this.isExposed(VoxelFaces.West)) {
+            tool.setTexture(args.flowTexture);
+            const quad = Quads[VoxelFaces.West];
+            tool.getAnimationData().setAll(1);
+            tool.calculateFaceData(VoxelFaces.West);
+            this.determineShading(VoxelFaces.West);
+            quad.flip = this.shouldFlip();
+            if (upFaceExposed) {
+                quad.positions.vertices[QuadVerticies.TopRight].y =
+                    vertexValue.vertices[QuadVerticies.TopLeft] * waterHeight;
+                quad.positions.vertices[QuadVerticies.TopLeft].y =
+                    vertexValue.vertices[QuadVerticies.BottomLeft] * waterHeight;
+                quad.uvs.vertices[QuadVerticies.TopRight].y =
+                    vertexValue.vertices[QuadVerticies.TopLeft];
+                quad.uvs.vertices[QuadVerticies.TopLeft].y =
+                    vertexValue.vertices[QuadVerticies.BottomLeft];
+            }
+            else {
+                quad.positions.vertices[QuadVerticies.TopLeft].y = 1;
+                quad.positions.vertices[QuadVerticies.TopRight].y = 1;
+                quad.setUVs(uvs);
+                UpdateBounds(tool, origin, quadBounds[VoxelFaces.West]);
+            }
+            VoxelGeometry.addQuad(tool, origin, quad);
+        }
+        this.worldLight.setAll(0);
+    }
+}

package/Mesher/Models/Nodes/Custom/index.js

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1,22 @@
+import { VoxelMesherDataTool } from "../../../Mesher/Tools/VoxelMesherDataTool";
+import { Vector3Like } from "@amodx/math";
+import { VoxelGeometryConstructor } from "./VoxelGeometryConstructor";
+import { VoxelGeometryTransform } from "../../../Voxels/VoxelSyncData";
+export interface GeoemtryNodeConstructor<Data = any, Args = any> {
+    new (geometryPaletteId: number, geomtry: VoxelGeometryConstructor, data: Data, transform: VoxelGeometryTransform): 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;
+    tool: VoxelMesherDataTool;
+    origin: Vector3Like;
+    constructor(geometryPaletteId: number, geomtry: VoxelGeometryConstructor, data: Data, transform: VoxelGeometryTransform);
+    abstract init(): void;
+    abstract add(tool: VoxelMesherDataTool, originHash: number, origin: Vector3Like, args: Args): void;
+}

package/{VoxelModels/Constructor → Mesher/Models}/Nodes/GeometryNode.js

@@ -1,14 +1,18 @@
 export class GeoemtryNode {
     geometryPaletteId;
     geomtry;
+    data;
+    transform;
     faceIndex = -1;
     vertexIndex = -1;
     faceCount = -1;
     vertexCount = -1;
     tool;
     origin;
-    constructor(geometryPaletteId, geomtry) {
+    constructor(geometryPaletteId, geomtry, data, transform) {
         this.geometryPaletteId = geometryPaletteId;
         this.geomtry = geomtry;
+        this.data = data;
+        this.transform = transform;
     }
 }

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

@@ -0,0 +1,25 @@
+import { Vec3Array, Vec4Array, Vector3Like } from "@amodx/math";
+import { VoxelFaces } from "../../../../Math";
+import { QuadScalarVertexData } from "@amodx/meshing";
+import { VoxelBoxGeometryNode } from "../../../../Models/VoxelModel.types";
+import { Quad } from "@amodx/meshing/Primitives/Quad";
+import { VoxelMesherDataTool } from "../../../../Mesher/Tools/VoxelMesherDataTool";
+import { BoxVoxelGometryArgs } from "../../../../Models/Input/BoxVoxelGometryInputs";
+import { GeoemtryNode } from "../GeometryNode";
+export declare class BoxVoxelGometryNode extends GeoemtryNode<VoxelBoxGeometryNode, BoxVoxelGometryArgs> {
+    quads: Record<VoxelFaces, Quad>;
+    quadBounds: [Vec3Array, Vec3Array][];
+    vertexWeights: Record<VoxelFaces, [
+        Vec4Array,
+        Vec4Array,
+        Vec4Array,
+        Vec4Array
+    ]>;
+    worldLight: QuadScalarVertexData;
+    worldAO: QuadScalarVertexData;
+    init(): void;
+    isExposed(face: VoxelFaces): boolean;
+    determineShading(face: VoxelFaces): void;
+    shouldFlip(): boolean;
+    add(tool: VoxelMesherDataTool, originHash: number, origin: Vector3Like, args: BoxVoxelGometryArgs): void;
+}

package/{VoxelModels/Constructor → Mesher/Models}/Nodes/Ruled/BoxVoxelGeometryNode.js

@@ -1,101 +1,37 @@
-import { Vector3Like } from "@amodx/math";
-import { VoxelFaces } from "../../../../Math";
-import { Quad } from "@amodx/meshing/Classes/Quad";
 import { VoxelGeometry } from "../../../../Mesher/Geometry/VoxelGeometry";
-import { BoxVoxelGometryInputs, } from "../../../Input/BoxVoxelGometryInputs";
+import { BoxVoxelGometryInputs, } from "../../../../Models/Input/BoxVoxelGometryInputs";
 import { VoxelGeometryLookUp } from "../../VoxelGeometryLookUp";
 import { GeoemtryNode } from "../GeometryNode";
-import { addQuadWeights, getInterpolationValue, shouldCauseFlip, } from "../../../../Mesher/Calc/CalcConstants";
-import { LightData } from "../../../../Data/LightData";
-import { VoxelRelativeCubeIndexPositionMap } from "../../../Indexing/VoxelRelativeCubeIndex";
-import { TransformBox } from "../../../Shared/Transform";
+import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcConstants";
+import { LightData } from "../../../../Voxels/LightData";
+import { VoxelRelativeCubeIndexPositionMap } from "../../../../Models/Indexing/VoxelRelativeCubeIndex";
+import { GetBoxGeometryNodeData } from "../../Common/BoxGeometryNode";
+import { UpdateBounds } from "../../Common/BoundsFunctions";
 const ArgIndexes = BoxVoxelGometryInputs.ArgIndexes;
 export class BoxVoxelGometryNode extends GeoemtryNode {
-    data;
-    quads = [];
-    vertexWeights = [];
+    quads;
+    quadBounds = [];
+    vertexWeights;
     worldLight;
     worldAO;
-    constructor(geometryPaletteId, geometry, data, transform) {
-        super(geometryPaletteId, geometry);
-        this.data = data;
-        const [start, end] = data.points.map((_) => Vector3Like.Create(..._));
+    init() {
         this.faceCount = 6;
         this.vertexCount = this.faceCount * 4;
-        const quadPoints = [
-            //top
-            [
-                [end.x, end.y, end.z],
-                [start.x, end.y, end.z],
-                [start.x, end.y, start.z],
-                [end.x, end.y, start.z],
-            ],
-            //bottom
-            [
-                [start.x, start.y, end.z],
-                [end.x, start.y, end.z],
-                [end.x, start.y, start.z],
-                [start.x, start.y, start.z],
-            ],
-            //north
-            [
-                [start.x, end.y, end.z],
-                [end.x, end.y, end.z],
-                [end.x, start.y, end.z],
-                [start.x, start.y, end.z],
-            ],
-            //south
-            [
-                [end.x, end.y, start.z],
-                [start.x, end.y, start.z],
-                [start.x, start.y, start.z],
-                [end.x, start.y, start.z],
-            ],
-            //east
-            [
-                [end.x, end.y, end.z],
-                [end.x, end.y, start.z],
-                [end.x, start.y, start.z],
-                [end.x, start.y, end.z],
-            ],
-            //west
-            [
-                [start.x, end.y, start.z],
-                [start.x, end.y, end.z],
-                [start.x, start.y, end.z],
-                [start.x, start.y, start.z],
-            ],
-        ];
-        const tranformed = TransformBox(quadPoints.map((_) => Quad.Create(_)), transform);
-        this.quads[VoxelFaces.Up] = tranformed[VoxelFaces.Up];
-        tranformed[VoxelFaces.Up].orientation = 0;
-        this.vertexWeights[VoxelFaces.Up] = addQuadWeights(this.quads[VoxelFaces.Up], VoxelFaces.Up);
-        this.quads[VoxelFaces.Down] = tranformed[VoxelFaces.Down];
-        tranformed[VoxelFaces.Down].orientation = 0;
-        this.vertexWeights[VoxelFaces.Down] = addQuadWeights(this.quads[VoxelFaces.Down], VoxelFaces.Down);
-        this.quads[VoxelFaces.North] = tranformed[VoxelFaces.North];
-        tranformed[VoxelFaces.North].orientation = 0;
-        this.vertexWeights[VoxelFaces.North] = addQuadWeights(this.quads[VoxelFaces.North], VoxelFaces.North);
-        this.quads[VoxelFaces.South] = tranformed[VoxelFaces.South];
-        tranformed[VoxelFaces.South].orientation = 0;
-        this.vertexWeights[VoxelFaces.South] = addQuadWeights(this.quads[VoxelFaces.South], VoxelFaces.South);
-        this.quads[VoxelFaces.East] = tranformed[VoxelFaces.East];
-        tranformed[VoxelFaces.East].orientation = 0;
-        this.vertexWeights[VoxelFaces.East] = addQuadWeights(this.quads[VoxelFaces.East], VoxelFaces.East);
-        this.quads[VoxelFaces.West] = tranformed[VoxelFaces.West];
-        tranformed[VoxelFaces.West].orientation = 0;
-        this.vertexWeights[VoxelFaces.West] = addQuadWeights(this.quads[VoxelFaces.West], VoxelFaces.West);
+        const { quads, vertexWeights, quadBounds } = GetBoxGeometryNodeData(this.data.points, this.transform);
+        this.quads = quads;
+        this.vertexWeights = vertexWeights;
+        this.quadBounds = quadBounds;
     }
     isExposed(face) {
         const trueFaceIndex = face + this.faceIndex;
-        const faceIndexes = this.geomtry.data.faceCullMap[trueFaceIndex];
+        const faceIndexes = this.geomtry.faceCullMap[trueFaceIndex];
         if (!faceIndexes)
             return true;
         const tool = this.tool;
         for (let positionIndex = 0; positionIndex < faceIndexes.length; positionIndex++) {
             const currentIndex = faceIndexes[positionIndex];
             const p = VoxelRelativeCubeIndexPositionMap[currentIndex];
-            const hashed = VoxelGeometryLookUp.getHash(tool.voxel.x + p[0], tool.voxel.y + p[1], tool.voxel.z + p[2]);
+            const hashed = VoxelGeometryLookUp.getHash(tool.nVoxel, tool.position.x + p[0], tool.position.y + p[1], tool.position.z + p[2]);
             const offsetBaseGometry = VoxelGeometryLookUp.geometryCache[hashed];
             const offsetConditonalGeometry = VoxelGeometryLookUp.conditionalGeometryCache[hashed];
             if (offsetBaseGometry) {
@@ -139,13 +75,13 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
             if (noAO)
                 continue;
             const trueVertexIndex = this.vertexIndex + face * 4 + v;
-            const aoIndexes = this.geomtry.data.vertexHitMap[trueVertexIndex];
+            const aoIndexes = this.geomtry.vertexHitMap[trueVertexIndex];
             if (!aoIndexes)
                 continue;
             for (let positionIndex = 0; positionIndex < aoIndexes.length; positionIndex++) {
                 const currentIndex = aoIndexes[positionIndex];
                 const p = VoxelRelativeCubeIndexPositionMap[currentIndex];
-                const hashed = VoxelGeometryLookUp.getHash(tool.voxel.x + p[0], tool.voxel.y + p[1], tool.voxel.z + p[2]);
+                const hashed = VoxelGeometryLookUp.getHash(tool.nVoxel, tool.position.x + p[0], tool.position.y + p[1], tool.position.z + p[2]);
                 if (VoxelGeometryLookUp.noCastAO[hashed] === true)
                     continue;
                 const baseGeo = VoxelGeometryLookUp.geometryCache[hashed];
@@ -187,7 +123,7 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
     }
     add(tool, originHash, origin, args) {
         this.tool = tool;
-        this.origin = tool.voxel;
+        this.origin = tool.position;
         this.worldAO = tool.getWorldAO();
         this.worldLight = tool.getWorldLight();
         for (let face = 0; face < 6; face++) {
@@ -212,6 +148,7 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
                 quad.uvs.vertices[3].x = uvs[3][0];
                 quad.uvs.vertices[3].y = uvs[3][1];
                 VoxelGeometry.addQuad(tool, origin, quad);
+                UpdateBounds(tool, origin, this.quadBounds[face]);
             }
         }
         this.worldLight.setAll(0);

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

@@ -0,0 +1,21 @@
+import { Vec3Array, Vec4Array, Vector3Like } from "@amodx/math";
+import { VoxelFaces } from "../../../../Math";
+import { QuadScalarVertexData } from "@amodx/meshing";
+import { VoxelQuadGeometryNode } from "../../../../Models/VoxelModel.types";
+import { Quad } from "@amodx/meshing/Primitives/Quad";
+import { VoxelMesherDataTool } from "../../../../Mesher/Tools/VoxelMesherDataTool";
+import { GeoemtryNode } from "../GeometryNode";
+import { QuadVoxelGometryArgs } from "../../../../Models/Input/QuadVoxelGometryInputs";
+export declare class QuadVoxelGometryNode extends GeoemtryNode<VoxelQuadGeometryNode, QuadVoxelGometryArgs> {
+    quad: Quad;
+    quadBounds: [Vec3Array, Vec3Array];
+    vertexWeights: [Vec4Array, Vec4Array, Vec4Array, Vec4Array];
+    worldLight: QuadScalarVertexData;
+    worldAO: QuadScalarVertexData;
+    closestFace: VoxelFaces;
+    init(): void;
+    isExposed(): boolean;
+    determineShading(): void;
+    shouldFlip(): boolean;
+    add(tool: VoxelMesherDataTool, originHash: number, origin: Vector3Like, args: QuadVoxelGometryArgs): void;
+}