@divinevoxel/vlox 0.0.73 → 0.0.75

package/Mesher/Models/Common/BoxGeometryNode.js

@@ -1,80 +0,0 @@
-import { Vector3Like } from "@amodx/math";
-import { VoxelFaces } from "../../../Math";
-import { Quad } from "../../Geomtry/Primitives/Quad";
-import { addQuadWeights } from "./Calc/CalcConstants";
-import { TransformBox } from "../../../Models/Shared/Transform";
-import { GetBounds } from "./BoundsFunctions";
-export function GetBoxGeometryNodeData(points, transform) {
-    // const quads: Quad[] = [];
-    const vertexWeights = [];
-    const start = Vector3Like.Create(...points[0]);
-    const end = Vector3Like.Create(...points[1]);
-    const quads = [];
-    //top
-    quads[VoxelFaces.Up] = Quad.Create([
-        [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
-    quads[VoxelFaces.Down] = Quad.Create([
-        [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
-    quads[VoxelFaces.North] = Quad.Create([
-        [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
-    quads[VoxelFaces.South] = Quad.Create([
-        [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
-    quads[VoxelFaces.East] = Quad.Create([
-        [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
-    quads[VoxelFaces.West] = Quad.Create([
-        [start.x, end.y, start.z],
-        [start.x, end.y, end.z],
-        [start.x, start.y, end.z],
-        [start.x, start.y, start.z],
-    ]);
-    TransformBox(quads, transform);
-    const quadBounds = new Array(quads.length);
-    for (let i = 0; i < quads.length; i++) {
-        const positions = [];
-        const quadPositions = quads[i].positions.getAsArray();
-        for (let i = 0; i < 4; i++) {
-            positions.push([
-                quadPositions[i].x,
-                quadPositions[i].y,
-                quadPositions[i].z,
-            ]);
-        }
-        quadBounds[i] = GetBounds(positions);
-    }
-    vertexWeights[VoxelFaces.Up] = addQuadWeights(quads[VoxelFaces.Up], VoxelFaces.Up);
-    vertexWeights[VoxelFaces.Down] = addQuadWeights(quads[VoxelFaces.Down], VoxelFaces.Down);
-    vertexWeights[VoxelFaces.North] = addQuadWeights(quads[VoxelFaces.North], VoxelFaces.North);
-    vertexWeights[VoxelFaces.South] = addQuadWeights(quads[VoxelFaces.South], VoxelFaces.South);
-    vertexWeights[VoxelFaces.East] = addQuadWeights(quads[VoxelFaces.East], VoxelFaces.East);
-    vertexWeights[VoxelFaces.West] = addQuadWeights(quads[VoxelFaces.West], VoxelFaces.West);
-    return {
-        quads,
-        vertexWeights,
-        quadBounds,
-    };
-}

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

@@ -1,11 +0,0 @@
-import { Vec3Array } from "@amodx/math";
-import { VoxelFaces } from "../../../Math";
-import { VoxelQuadGeometryNode } from "../../../Models/VoxelModel.types";
-import { Quad } from "../../Geomtry/Primitives/Quad";
-import { VoxelGeometryTransform } from "../../../Voxels/Types/VoxelModelCompiledData.types";
-export declare function GetQuadGeometryData(data: VoxelQuadGeometryNode, transform: VoxelGeometryTransform): {
-    quad: Quad;
-    vertexWeights: import("./Calc/CalcConstants").QuadVertexWeights;
-    closestFace: VoxelFaces;
-    quadBounds: [Vec3Array, Vec3Array];
-};

package/Mesher/Models/Common/QuadGeometryNode.js

@@ -1,51 +0,0 @@
-import { Vector3Like } from "@amodx/math";
-import { VoxelFaces } from "../../../Math";
-import { Quad } from "../../Geomtry/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/Ruled/BoxVoxelGeometryNode.d.ts

@@ -1,24 +0,0 @@
-import { Vec3Array, Vec4Array } from "@amodx/math";
-import { VoxelFaces } from "../../../../Math";
-import { VoxelBoxGeometryNode } from "../../../../Models/VoxelModel.types";
-import { Quad } from "../../../Geomtry/Primitives/Quad";
-import { BoxVoxelGometryArgs } from "../../../../Models/Input/BoxVoxelGometryInputs";
-import { GeoemtryNode } from "../GeometryNode";
-import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
-export declare class BoxVoxelGometryNode extends GeoemtryNode<VoxelBoxGeometryNode, BoxVoxelGometryArgs> {
-    quads: Record<VoxelFaces, Quad>;
-    quadBounds: [Vec3Array, Vec3Array][];
-    vertexWeights: Record<VoxelFaces, [
-        Vec4Array,
-        Vec4Array,
-        Vec4Array,
-        Vec4Array
-    ]>;
-    _wasAOShaded: boolean;
-    lightData: VoxelLightData;
-    init(): void;
-    isExposed(face: VoxelFaces): boolean;
-    determineShading(face: VoxelFaces): void;
-    shouldFlip(): boolean;
-    add(args: BoxVoxelGometryArgs): boolean;
-}

package/Mesher/Models/Nodes/Ruled/BoxVoxelGeometryNode.js

@@ -1,176 +0,0 @@
-import { BoxVoxelGometryInputs, } from "../../../../Models/Input/BoxVoxelGometryInputs";
-import { GeoemtryNode } from "../GeometryNode";
-import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcConstants";
-import { VoxelRelativeCubeIndexPositionMap } from "../../../../Models/Indexing/VoxelRelativeCubeIndex";
-import { GetBoxGeometryNodeData } from "../../Common/BoxGeometryNode";
-import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
-import { VoxelGeometryBuilder } from "../../../Geomtry/VoxelGeometryBuilder";
-import { VoxelModelConstructorRegister } from "../../../Models/VoxelModelConstructorRegister";
-const ArgIndexes = BoxVoxelGometryInputs.ArgIndexes;
-export class BoxVoxelGometryNode extends GeoemtryNode {
-    quads;
-    quadBounds = [];
-    vertexWeights;
-    _wasAOShaded = false;
-    lightData = new VoxelLightData();
-    init() {
-        this.faceCount = 6;
-        this.vertexCount = this.faceCount * 4;
-        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.faceCullMap[trueFaceIndex];
-        if (!faceIndexes)
-            return true;
-        const tool = this.builder;
-        for (let positionIndex = 0; positionIndex < faceIndexes.length; positionIndex++) {
-            const currentIndex = faceIndexes[positionIndex];
-            const p = VoxelRelativeCubeIndexPositionMap[currentIndex];
-            const hashed = this.builder.space.getHash(tool.nVoxel, tool.position.x + p[0], tool.position.y + p[1], tool.position.z + p[2]);
-            if (this.builder.space.foundHash[hashed] < 2)
-                continue;
-            const offsetBaseGometry = this.builder.space.getGeomtry(hashed);
-            const offsetConditonalGeometry = this.builder.space.getConditionalGeomtry(hashed);
-            if (offsetBaseGometry) {
-                for (let i = 0; i < offsetBaseGometry.length; i++) {
-                    const geoId = offsetBaseGometry[i];
-                    if (VoxelModelConstructorRegister.rulesless[geoId])
-                        continue;
-                    const faceIndex = this.geomtry.cullIndex.getValue(geoId, currentIndex, trueFaceIndex);
-                    if (faceIndex > -1 &&
-                        !this.builder.space
-                            .getConstructor(hashed)
-                            ?.isShapeStateFaceTransparent(this.builder.space.modCache[hashed], this.builder.space.stateCache[hashed], geoId, faceIndex)) {
-                        return false;
-                    }
-                }
-            }
-            if (!offsetConditonalGeometry)
-                continue;
-            for (let i = 0; i < offsetConditonalGeometry.length; i++) {
-                const cond = offsetConditonalGeometry[i];
-                for (let k = 0; k < cond.length; k++) {
-                    const geoId = cond[k];
-                    if (VoxelModelConstructorRegister.rulesless[geoId])
-                        continue;
-                    const faceIndex = this.geomtry.cullIndex.getValue(geoId, currentIndex, trueFaceIndex);
-                    if (faceIndex > -1 &&
-                        !this.builder.space
-                            .getConstructor(hashed)
-                            ?.isCondtionalStateFaceTransparent(this.builder.space.modCache[hashed], this.builder.space.stateCache[hashed], geoId, faceIndex))
-                        return false;
-                }
-            }
-        }
-        return true;
-    }
-    determineShading(face) {
-        const tool = this.builder;
-        const lightData = tool.lightData[face];
-        const noAO = this.builder.voxel.isLightSource() || this.builder.voxel.noAO();
-        const worldLight = this.builder.vars.light;
-        const worldAO = this.builder.vars.ao;
-        for (let v = 0; v < 4; v++) {
-            worldAO.vertices[v] = 0;
-            worldLight.vertices[v] = getInterpolationValue(lightData, this.vertexWeights[face][v]);
-            if (noAO)
-                continue;
-            const trueVertexIndex = this.vertexIndex + face * 4 + v;
-            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 = this.builder.space.getHash(tool.nVoxel, tool.position.x + p[0], tool.position.y + p[1], tool.position.z + p[2]);
-                if (this.builder.space.foundHash[hashed] < 2 ||
-                    this.builder.space.noCastAO[hashed] === 1)
-                    continue;
-                const baseGeo = this.builder.space.getGeomtry(hashed);
-                const conditonalGeo = this.builder.space.getConditionalGeomtry(hashed);
-                if (!baseGeo && !conditonalGeo)
-                    continue;
-                let length = 0;
-                let shaded = false;
-                if (baseGeo) {
-                    length = baseGeo.length;
-                    for (let geoIndex = 0; geoIndex < length; geoIndex++) {
-                        if (this.geomtry.aoIndex.getValue(baseGeo[geoIndex], currentIndex, trueVertexIndex)) {
-                            this._wasAOShaded = true;
-                            worldAO.vertices[v]++;
-                            if (worldAO.vertices[v] > 4) {
-                                shaded = true;
-                                break;
-                            }
-                        }
-                    }
-                }
-                if (!conditonalGeo || shaded)
-                    continue;
-                length = conditonalGeo.length;
-                for (let condtionsIndex = 0; condtionsIndex < length; condtionsIndex++) {
-                    const condiotnalength = conditonalGeo[condtionsIndex].length;
-                    for (let geoIndex = 0; geoIndex < condiotnalength; geoIndex++) {
-                        if (this.geomtry.aoIndex.getValue(conditonalGeo[condtionsIndex][geoIndex], currentIndex, trueVertexIndex)) {
-                            this._wasAOShaded = true;
-                            worldAO.vertices[v]++;
-                            if (worldAO.vertices[v] > 4) {
-                                shaded = true;
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-    shouldFlip() {
-        const worldAO = this.builder.vars.ao;
-        if (shouldCauseFlip(worldAO.vertices[0], worldAO.vertices[1], worldAO.vertices[2], worldAO.vertices[3]) &&
-            this._wasAOShaded)
-            return true;
-        if (this._wasAOShaded)
-            return false;
-        const worldLight = this.builder.vars.light;
-        return (shouldCauseFlip(this.lightData.getS(worldLight.vertices[0]), this.lightData.getS(worldLight.vertices[1]), this.lightData.getS(worldLight.vertices[2]), this.lightData.getS(worldLight.vertices[3])) ||
-            shouldCauseFlip(this.lightData.sumRGB(worldLight.vertices[0]), this.lightData.sumRGB(worldLight.vertices[1]), this.lightData.sumRGB(worldLight.vertices[2]), this.lightData.sumRGB(worldLight.vertices[3])));
-    }
-    add(args) {
-        let added = false;
-        const tool = this.builder;
-        for (let face = 0; face < 6; face++) {
-            if (args[face][ArgIndexes.Enabled] && this.isExposed(face)) {
-                added = true;
-                tool.calculateFaceData(face);
-                this.determineShading(face);
-                const faceArgs = args[face];
-                const quad = this.quads[face];
-                quad.flip = this.shouldFlip() || faceArgs[ArgIndexes.Fliped];
-                tool.vars.textureIndex = faceArgs[ArgIndexes.Texture];
-                const uvs = faceArgs[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];
-                VoxelGeometryBuilder.addQuad(tool, this.builder.origin, quad);
-                tool.updateBounds(this.quadBounds[face]);
-            }
-        }
-        this.builder.vars.ao.setAll(0);
-        this.builder.vars.light.setAll(0);
-        this._wasAOShaded = false;
-        return added;
-    }
-}

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

@@ -1,19 +0,0 @@
-import { Vec3Array, Vec4Array } from "@amodx/math";
-import { VoxelFaces } from "../../../../Math";
-import { VoxelQuadGeometryNode } from "../../../../Models/VoxelModel.types";
-import { Quad } from "../../../Geomtry/Primitives/Quad";
-import { GeoemtryNode } from "../GeometryNode";
-import { QuadVoxelGometryArgs } from "../../../../Models/Input/QuadVoxelGometryInputs";
-import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
-export declare class QuadVoxelGometryNode extends GeoemtryNode<VoxelQuadGeometryNode, QuadVoxelGometryArgs> {
-    quad: Quad;
-    quadBounds: [Vec3Array, Vec3Array];
-    vertexWeights: [Vec4Array, Vec4Array, Vec4Array, Vec4Array];
-    closestFace: VoxelFaces;
-    lightData: VoxelLightData;
-    init(): void;
-    isExposed(): boolean;
-    determineShading(): void;
-    shouldFlip(): boolean;
-    add(args: QuadVoxelGometryArgs): boolean;
-}

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

@@ -1,157 +0,0 @@
-import { VoxelFaces } from "../../../../Math";
-import { VoxelGeometryBuilder } from "../../../Geomtry/VoxelGeometryBuilder";
-import { GeoemtryNode } from "../GeometryNode";
-import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcConstants";
-import { VoxelRelativeCubeIndexPositionMap } from "../../../../Models/Indexing/VoxelRelativeCubeIndex";
-import { QuadVoxelGometryInputs, } from "../../../../Models/Input/QuadVoxelGometryInputs";
-import { GetQuadGeometryData } from "../../Common/QuadGeometryNode";
-import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
-const ArgIndexes = QuadVoxelGometryInputs.ArgIndexes;
-export class QuadVoxelGometryNode extends GeoemtryNode {
-    quad;
-    quadBounds = [
-        [0, 0, 0],
-        [0, 0, 0],
-    ];
-    vertexWeights;
-    closestFace;
-    lightData = new VoxelLightData();
-    init() {
-        this.faceCount = 6;
-        this.vertexCount = this.faceCount * 4;
-        const { quad, quadBounds, closestFace, vertexWeights } = GetQuadGeometryData(this.data, this.transform);
-        this.quad = quad;
-        this.quadBounds = quadBounds;
-        this.vertexWeights = vertexWeights;
-        this.closestFace = closestFace;
-    }
-    isExposed() {
-        const trueFaceIndex = this.faceIndex;
-        const faceIndexes = this.geomtry.faceCullMap[trueFaceIndex];
-        if (!faceIndexes)
-            return true;
-        const tool = this.builder;
-        for (let positionIndex = 0; positionIndex < faceIndexes.length; positionIndex++) {
-            const currentIndex = faceIndexes[positionIndex];
-            const p = VoxelRelativeCubeIndexPositionMap[currentIndex];
-            const hashed = this.builder.space.getHash(tool.nVoxel, tool.position.x + p[0], tool.position.y + p[1], tool.position.z + p[2]);
-            const offsetBaseGometry = this.builder.space.getGeomtry(hashed);
-            const offsetConditonalGeometry = this.builder.space.getConditionalGeomtry(hashed);
-            if (offsetBaseGometry) {
-                for (let i = 0; i < offsetBaseGometry.length; i++) {
-                    const faceIndex = this.geomtry.cullIndex.getValue(offsetBaseGometry[i], currentIndex, trueFaceIndex);
-                    if (faceIndex > -1 &&
-                        !this.builder
-                            .space.getConstructor(hashed)
-                            ?.isShapeStateFaceTransparent(this.builder.space.modCache[hashed], this.builder.space.stateCache[hashed], offsetBaseGometry[i], faceIndex)) {
-                        return false;
-                    }
-                }
-            }
-            if (!offsetConditonalGeometry)
-                continue;
-            for (let i = 0; i < offsetConditonalGeometry.length; i++) {
-                const cond = offsetConditonalGeometry[i];
-                for (let k = 0; k < cond.length; k++) {
-                    const faceIndex = this.geomtry.cullIndex.getValue(cond[k], currentIndex, trueFaceIndex);
-                    if (faceIndex > -1 &&
-                        !this.builder
-                            .space.getConstructor(hashed)
-                            ?.isCondtionalStateFaceTransparent(this.builder.space.modCache[hashed], this.builder.space.stateCache[hashed], cond[i], faceIndex))
-                        return false;
-                }
-            }
-        }
-        return true;
-    }
-    determineShading() {
-        const tool = this.builder;
-        const lightData = tool.lightData[VoxelFaces.Up];
-        const noAO = this.builder.voxel.isLightSource() || this.builder.voxel.noAO();
-        const worldLight = tool.vars.light;
-        const worldAO = tool.vars.ao;
-        for (let v = 0; v < 4; v++) {
-            worldAO.vertices[v] = 0;
-            worldLight.vertices[v] = getInterpolationValue(lightData, this.vertexWeights[v]);
-            if (noAO)
-                continue;
-            const trueVertexIndex = this.vertexIndex + 4 + v;
-            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 = this.builder.space.getHash(tool.nVoxel, tool.position.x + p[0], tool.position.y + p[1], tool.position.z + p[2]);
-                if (this.builder.space.noCastAO[hashed] === 1)
-                    continue;
-                const baseGeo = this.builder.space.getGeomtry(hashed);
-                const conditonalGeo = this.builder.space.getConditionalGeomtry(hashed);
-                if (!baseGeo && !conditonalGeo)
-                    continue;
-                let length = 0;
-                let shaded = false;
-                if (baseGeo) {
-                    length = baseGeo.length;
-                    for (let geoIndex = 0; geoIndex < length; geoIndex++) {
-                        if (this.geomtry.aoIndex.getValue(baseGeo[geoIndex], currentIndex, trueVertexIndex)) {
-                            worldAO.vertices[v] = 1;
-                            shaded = true;
-                            break;
-                        }
-                    }
-                }
-                if (!conditonalGeo)
-                    continue;
-                length = conditonalGeo.length;
-                for (let condtionsIndex = 0; condtionsIndex < length; condtionsIndex++) {
-                    const condiotnalength = conditonalGeo[condtionsIndex].length;
-                    for (let geoIndex = 0; geoIndex < condiotnalength; geoIndex++) {
-                        if (this.geomtry.aoIndex.getValue(conditonalGeo[condtionsIndex][geoIndex], currentIndex, trueVertexIndex)) {
-                            worldAO.vertices[v] = 1;
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-    }
-    shouldFlip() {
-        const worldAO = this.builder.vars.ao;
-        const worldLight = this.builder.vars.light;
-        if (shouldCauseFlip(worldAO.vertices[0], worldAO.vertices[1], worldAO.vertices[2], worldAO.vertices[3]))
-            return true;
-        return (shouldCauseFlip(this.lightData.getS(worldLight.vertices[0]), this.lightData.getS(worldLight.vertices[1]), this.lightData.getS(worldLight.vertices[2]), this.lightData.getS(worldLight.vertices[3])) ||
-            shouldCauseFlip(this.lightData.sumRGB(worldLight.vertices[0]), this.lightData.sumRGB(worldLight.vertices[1]), this.lightData.sumRGB(worldLight.vertices[2]), this.lightData.sumRGB(worldLight.vertices[3])));
-    }
-    add(args) {
-        if (!args[ArgIndexes.Enabled])
-            return false;
-        if (!this.isExposed())
-            return false;
-        this.builder.calculateFaceData(this.closestFace);
-        this.determineShading();
-        const quad = this.quad;
-        quad.flip = this.shouldFlip() || args[ArgIndexes.Fliped];
-        this.builder.vars.textureIndex = args[ArgIndexes.Texture];
-        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];
-        VoxelGeometryBuilder.addQuad(this.builder, this.builder.origin, quad);
-        this.builder.updateBounds(this.quadBounds);
-        this.builder.vars.light.setAll(0);
-        this.builder.vars.ao.setAll(0);
-        return true;
-    }
-}

package/Mesher/Models/Nodes/Ruleless/RulelessBoxVoxelGeometryNode.d.ts

@@ -1,22 +0,0 @@
-import { Vec3Array, Vec4Array } from "@amodx/math";
-import { VoxelFaces } from "../../../../Math";
-import { VoxelBoxGeometryNode } from "../../../../Models/VoxelModel.types";
-import { Quad } from "../../../Geomtry/Primitives/Quad";
-import { BoxVoxelGometryArgs } from "../../../../Models/Input/BoxVoxelGometryInputs";
-import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
-import { GeoemtryNode } from "../GeometryNode";
-export declare class RulelessBoxVoxelGeometryNode extends GeoemtryNode<VoxelBoxGeometryNode, BoxVoxelGometryArgs> {
-    quads: Record<VoxelFaces, Quad>;
-    quadBounds: [Vec3Array, Vec3Array][];
-    vertexWeights: Record<VoxelFaces, [
-        Vec4Array,
-        Vec4Array,
-        Vec4Array,
-        Vec4Array
-    ]>;
-    lightData: VoxelLightData;
-    init(): void;
-    determineShading(face: VoxelFaces): void;
-    shouldFlip(): boolean;
-    add(args: BoxVoxelGometryArgs): boolean;
-}

package/Mesher/Models/Nodes/Ruleless/RulelessBoxVoxelGeometryNode.js

@@ -1,75 +0,0 @@
-import { VoxelGeometryBuilder } from "../../../Geomtry/VoxelGeometryBuilder";
-import { BoxVoxelGometryInputs, } from "../../../../Models/Input/BoxVoxelGometryInputs";
-import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcConstants";
-import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
-import { GeoemtryNode } from "../GeometryNode";
-import { GetBoxGeometryNodeData } from "../../Common/BoxGeometryNode";
-const ArgIndexes = BoxVoxelGometryInputs.ArgIndexes;
-export class RulelessBoxVoxelGeometryNode extends GeoemtryNode {
-    quads;
-    quadBounds = [];
-    vertexWeights;
-    lightData = new VoxelLightData();
-    init() {
-        this.faceCount = 6;
-        this.vertexCount = this.faceCount * 4;
-        const { quads, vertexWeights, quadBounds } = GetBoxGeometryNodeData(this.data.points, this.transform);
-        this.quads = quads;
-        this.quadBounds = quadBounds;
-        this.vertexWeights = vertexWeights;
-    }
-    determineShading(face) {
-        const tool = this.builder;
-        const lightData = tool.lightData[face];
-        const noAO = this.builder.voxel.isLightSource() || this.builder.voxel.noAO();
-        const worldLight = this.builder.vars.light;
-        const worldAO = this.builder.vars.ao;
-        for (let v = 0; v < 4; v++) {
-            worldAO.vertices[v] = 0;
-            worldLight.vertices[v] = getInterpolationValue(lightData, this.vertexWeights[face][v]);
-            if (noAO)
-                continue;
-        }
-    }
-    shouldFlip() {
-        const worldLight = this.builder.vars.light;
-        const worldAO = this.builder.vars.ao;
-        if (shouldCauseFlip(worldAO.vertices[0], worldAO.vertices[1], worldAO.vertices[2], worldAO.vertices[3]))
-            return true;
-        return (shouldCauseFlip(this.lightData.getS(worldLight.vertices[0]), this.lightData.getS(worldLight.vertices[1]), this.lightData.getS(worldLight.vertices[2]), this.lightData.getS(worldLight.vertices[3])) ||
-            shouldCauseFlip(this.lightData.sumRGB(worldLight.vertices[0]), this.lightData.sumRGB(worldLight.vertices[1]), this.lightData.sumRGB(worldLight.vertices[2]), this.lightData.sumRGB(worldLight.vertices[3])));
-    }
-    add(args) {
-        const tool = this.builder;
-        let added = false;
-        for (let face = 0; face < 6; face++) {
-            if (args[face][ArgIndexes.Enabled]) {
-                added = true;
-                tool.calculateFaceData(face);
-                this.determineShading(face);
-                const faceArgs = args[face];
-                const quad = this.quads[face];
-                quad.flip = this.shouldFlip() || faceArgs[ArgIndexes.Fliped];
-                tool.vars.textureIndex = faceArgs[ArgIndexes.Texture];
-                const uvs = faceArgs[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];
-                VoxelGeometryBuilder.addQuad(tool, tool.position, quad);
-                this.builder.updateBounds(this.quadBounds[face]);
-            }
-        }
-        this.builder.vars.light.setAll(0);
-        this.builder.vars.ao.setAll(0);
-        return added;
-    }
-}

package/Mesher/Models/Nodes/Ruleless/RulelessQuadVoxelGeometryNode.d.ts

@@ -1,18 +0,0 @@
-import { Vec3Array, Vec4Array } from "@amodx/math";
-import { VoxelFaces } from "../../../../Math";
-import { VoxelQuadGeometryNode } from "../../../../Models/VoxelModel.types";
-import { Quad } from "../../../Geomtry/Primitives/Quad";
-import { QuadVoxelGometryArgs } from "../../../../Models/Input/QuadVoxelGometryInputs";
-import { GeoemtryNode } from "../GeometryNode";
-import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
-export declare class RulelessQuadVoxelGeometryNode extends GeoemtryNode<VoxelQuadGeometryNode, QuadVoxelGometryArgs> {
-    quad: Quad;
-    quadBounds: [Vec3Array, Vec3Array];
-    vertexWeights: [Vec4Array, Vec4Array, Vec4Array, Vec4Array];
-    closestFace: VoxelFaces;
-    lightData: VoxelLightData;
-    init(): void;
-    determineShading(): void;
-    shouldFlip(): boolean;
-    add(args: QuadVoxelGometryArgs): boolean;
-}