@divinevoxel/vlox 0.0.73 → 0.0.75

package/Voxels/Models/Rules/Functions/BuildRules.js

@@ -0,0 +1,217 @@
+import { VoxelRelativeCubeIndex } from "../../Indexing/VoxelRelativeCubeIndex";
+import { Vec3ArrayLike } from "@amodx/math";
+import { VoxelModelRuleBuilderRegister } from "../VoxelModelRuleBuilderRegister";
+import { OcclusionFaceRegister } from "../Classes/OcclusionFaceRegister";
+import { AOOcclusionFaceIndex } from "../../Indexing/AOOcclusionFaceIndex";
+import { CulledOcclusionFaceIndex } from "../../Indexing/CulledOcclusionFaceIndex";
+import { OcclusionQuadFace } from "../Classes/OcclusionQuadFace";
+import { OcclusionTriangleFace } from "../Classes/OcclusionTriangleFace";
+import { EngineSettings } from "../../../../Settings/EngineSettings";
+import { EngineStats } from "../../../../Stats/EngineStats";
+class OcculsionBox {
+    p1;
+    p2;
+    p3;
+    p4;
+    constructor(p1 = [0, 0, 0], p2 = [0, 0, 0], p3 = [0, 0, 0], p4 = [0, 0, 0]) {
+        this.p1 = p1;
+        this.p2 = p2;
+        this.p3 = p3;
+        this.p4 = p4;
+    }
+}
+const mainBox = new OcculsionBox();
+const size = 0.01;
+// Calculate half the size of the box
+const halfSize = size / 2;
+// Create a small offset to move the box forward
+const offset = 0.01;
+const boxNormals = [
+    [1, 0, 0],
+    [0, 1, 0],
+    [0, 0, 1],
+];
+const boxPoints = [mainBox.p1, mainBox.p2, mainBox.p3, mainBox.p4];
+const offsetPoint = [0, 0, 0];
+const tangent = [0, 0, 0];
+const bitangent = [0, 0, 0];
+function updateOcculsionBox(point, normal) {
+    offsetPoint[0] = point[0] + normal[0] * offset;
+    offsetPoint[1] = point[1] + normal[1] * offset;
+    offsetPoint[2] = point[2] + normal[2] * offset;
+    if (Math.abs(normal[0]) > Math.abs(normal[2])) {
+        tangent[0] = -normal[1];
+        tangent[1] = normal[0];
+        tangent[2] = 0;
+    }
+    else {
+        tangent[0] = 0;
+        tangent[1] = -normal[2];
+        tangent[2] = normal[1];
+    }
+    const tangentLength = Math.sqrt(tangent[0] ** 2 + tangent[1] ** 2 + tangent[2] ** 2);
+    tangent[0] = tangent[0] / tangentLength;
+    tangent[1] = tangent[1] / tangentLength;
+    tangent[2] = tangent[2] / tangentLength;
+    bitangent[0] = normal[1] * tangent[2] - normal[2] * tangent[1];
+    bitangent[1] = normal[2] * tangent[0] - normal[0] * tangent[2];
+    bitangent[2] = normal[0] * tangent[1] - normal[1] * tangent[0];
+    mainBox.p1[0] =
+        offsetPoint[0] - tangent[0] * halfSize - bitangent[0] * halfSize;
+    mainBox.p1[1] =
+        offsetPoint[1] - tangent[1] * halfSize - bitangent[1] * halfSize;
+    mainBox.p1[2] =
+        offsetPoint[2] - tangent[2] * halfSize - bitangent[2] * halfSize;
+    mainBox.p2[0] =
+        offsetPoint[0] + tangent[0] * halfSize - bitangent[0] * halfSize;
+    mainBox.p2[1] =
+        offsetPoint[1] + tangent[1] * halfSize - bitangent[1] * halfSize;
+    mainBox.p2[2] =
+        offsetPoint[2] + tangent[2] * halfSize - bitangent[2] * halfSize;
+    mainBox.p3[0] =
+        offsetPoint[0] + tangent[0] * halfSize + bitangent[0] * halfSize;
+    mainBox.p3[1] =
+        offsetPoint[1] + tangent[1] * halfSize + bitangent[1] * halfSize;
+    mainBox.p3[2] =
+        offsetPoint[2] + tangent[2] * halfSize + bitangent[2] * halfSize;
+    mainBox.p4[0] =
+        offsetPoint[0] - tangent[0] * halfSize + bitangent[0] * halfSize;
+    mainBox.p4[1] =
+        offsetPoint[1] - tangent[1] * halfSize + bitangent[1] * halfSize;
+    mainBox.p4[2] =
+        offsetPoint[2] - tangent[2] * halfSize + bitangent[2] * halfSize;
+    return mainBox;
+}
+function projectPointOntoAxis(point, axis) {
+    return point[0] * axis[0] + point[1] * axis[1] + point[2] * axis[2];
+}
+function projectionsOverlap(axis, shape1Points, shape2Points) {
+    let min1 = Infinity;
+    let max1 = -Infinity;
+    let min2 = Infinity;
+    let max2 = -Infinity;
+    for (const point of shape1Points) {
+        const projection = projectPointOntoAxis(point, axis);
+        min1 = Math.min(min1, projection);
+        max1 = Math.max(max1, projection);
+    }
+    for (const point of shape2Points) {
+        const projection = projectPointOntoAxis(point, axis);
+        min2 = Math.min(min2, projection);
+        max2 = Math.max(max2, projection);
+    }
+    return !(max1 < min2 || max2 < min1);
+}
+function doesBoxIntersectFace(quad) {
+    const quadPoints = quad.points;
+    const quadNormal = quad.normal;
+    if (!projectionsOverlap(quadNormal, quadPoints, boxPoints)) {
+        return false;
+    }
+    for (const boxNormal of boxNormals) {
+        if (!projectionsOverlap(boxNormal, quadPoints, boxPoints)) {
+            return false;
+        }
+    }
+    return true;
+}
+export function BuildRules(geoPalette) {
+    const faceCullMap = [];
+    const vertexHitMap = [];
+    const cubeIndexSize = VoxelRelativeCubeIndex.flatIndex.size;
+    const totalFaces = OcclusionFaceRegister.faces.size;
+    const totalAOReusltsSize = totalFaces * 4 * cubeIndexSize * geoPalette.size;
+    const aoIndexBufferSize = Math.ceil(totalAOReusltsSize / 8);
+    const aoIndex = new AOOcclusionFaceIndex({
+        buffer: EngineSettings.settings.memoryAndCPU.useSharedMemory
+            ? new SharedArrayBuffer(aoIndexBufferSize)
+            : new ArrayBuffer(aoIndexBufferSize),
+        totalFaces,
+    });
+    const cullIndexResultsSize = totalFaces * cubeIndexSize * geoPalette.size;
+    const cullIndexBufferSize = Math.ceil(cullIndexResultsSize / 8);
+    const cullIndex = new CulledOcclusionFaceIndex({
+        buffer: EngineSettings.settings.memoryAndCPU.useSharedMemory
+            ? new SharedArrayBuffer(cullIndexBufferSize)
+            : new ArrayBuffer(cullIndexBufferSize),
+        totalFaces,
+    });
+    const faces = OcclusionFaceRegister.faces._palette;
+    const currentQuadFace = new OcclusionQuadFace();
+    const currentTriangleFace = new OcclusionTriangleFace();
+    const otherQuadFace = new OcclusionQuadFace();
+    const otherTriangleFace = new OcclusionTriangleFace();
+    EngineStats.geomtry.faces = faces.length;
+    for (let faceIndex = 0; faceIndex < faces.length; faceIndex++) {
+        const faceData = OcclusionFaceRegister.faceIndex[faceIndex];
+        let currentFace;
+        if (faceData[0] == 0) {
+            currentQuadFace.setPoints(faceData[1]);
+            currentFace = currentQuadFace;
+        }
+        else {
+            otherTriangleFace.setPoints(faceData[1]);
+            currentFace = otherTriangleFace;
+        }
+        faceCullMap[faceIndex] = [];
+        vertexHitMap[faceIndex] = [];
+        const facePoints = currentFace.points;
+        const faceNormal = currentFace.normal;
+        for (let gometryId = 0; gometryId < geoPalette.size; gometryId++) {
+            let geomtry = VoxelModelRuleBuilderRegister.geometry.get(geoPalette._palette[gometryId]);
+            if (geomtry.data.ogData.doNotBuildRules !== undefined)
+                continue;
+            for (const otherGeo of geomtry.compiled) {
+                if (otherGeo.type == "custom" || otherGeo.trueFaceIndex === undefined)
+                    continue;
+                const otherFaceData = OcclusionFaceRegister.faceIndex[otherGeo.trueFaceIndex];
+                let otherFace;
+                if (otherFaceData[0] == 0) {
+                    otherQuadFace.setPoints(otherFaceData[1]);
+                    otherFace = otherQuadFace;
+                }
+                else {
+                    currentTriangleFace.setPoints(otherFaceData[1]);
+                    otherFace = currentTriangleFace;
+                }
+                for (let y = -1; y < 2; y++) {
+                    for (let x = -1; x < 2; x++) {
+                        for (let z = -1; z < 2; z++) {
+                            if (faceIndex == otherGeo.trueFaceIndex &&
+                                x == 0 &&
+                                y == 0 &&
+                                z == 0)
+                                continue;
+                            const directionIndex = VoxelRelativeCubeIndex.getIndex(x, y, z);
+                            otherQuadFace.setOffset(x, y, z);
+                            if (otherFace.doesCoverFace(currentFace)) {
+                                cullIndex.setValue(gometryId, directionIndex, faceIndex, 1);
+                                if (!faceCullMap[faceIndex].includes(directionIndex)) {
+                                    faceCullMap[faceIndex].push(directionIndex);
+                                }
+                            }
+                            if (Vec3ArrayLike.Equals(otherFace.normal, faceNormal))
+                                continue;
+                            for (let v = 0; v < facePoints.length; v++) {
+                                updateOcculsionBox(facePoints[v], faceNormal);
+                                vertexHitMap[faceIndex][v] ??= [];
+                                if (doesBoxIntersectFace(otherFace)) {
+                                    aoIndex.setValue(gometryId, directionIndex, faceIndex, v, 1);
+                                    if (!vertexHitMap[faceIndex][v].includes(directionIndex)) {
+                                        vertexHitMap[faceIndex][v].push(directionIndex);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return {
+        aoIndex: aoIndex.toJSON(),
+        faceCullIndex: cullIndex.toJSON(),
+        faceCullMap,
+        vertexHitMap,
+    };
+}

package/Voxels/Models/Rules/Functions/Compile/CompileGeomtryNodes.d.ts

@@ -0,0 +1,4 @@
+import { CompiledGeomtryNodes } from "../../../../../Mesher/Models/Nodes/Types/GeomtryNode.types";
+import { VoxelRuleGeometryData } from "../../Classes/VoxelRulesGeometry";
+import { GeomtryInput } from "../../Classes/GeomtryInput";
+export declare function CompileGeomtryNodes(buildRules: boolean, input: GeomtryInput, data: VoxelRuleGeometryData["nodes"]): CompiledGeomtryNodes[];

package/Voxels/Models/Rules/Functions/Compile/CompileGeomtryNodes.js

@@ -0,0 +1,39 @@
+import { CompileBoxGeometryNode } from "./Nodes/CompileBoxGeometryNode";
+import { CompileQuadGeometryNode } from "./Nodes/CompileQuadGeometryNode";
+import { CompileTriangleGeometryNode } from "./Nodes/CompileTriangleGeometryNode";
+export function CompileGeomtryNodes(buildRules, input, data) {
+    const compiled = [];
+    for (const { node, tranform } of data) {
+        if (node.type == "custom") {
+            compiled.push({
+                type: "custom",
+                id: node.id,
+            });
+            input.args.push({});
+            const argsIndex = input.args.length - 1;
+            for (const inputArg in node.inputs) {
+                const value = node.inputs[inputArg];
+                if (input.isArgString(value)) {
+                    input.args[argsIndex][inputArg] = null;
+                    input.onInput(value, (value) => {
+                        input.args[argsIndex][inputArg] = value;
+                    });
+                }
+                else {
+                    input.args[argsIndex][inputArg] = value;
+                }
+            }
+        }
+        if (node.type == "box") {
+            compiled.push(...CompileBoxGeometryNode(buildRules, input, node, tranform));
+        }
+        if (node.type == "quad") {
+            compiled.push(CompileQuadGeometryNode(buildRules, input, node.points, node, tranform));
+        }
+        if (node.type == "triangle") {
+            compiled.push(CompileTriangleGeometryNode(buildRules, input, node.points, node, tranform));
+        }
+    }
+    input.orginalArgs = structuredClone(input.args);
+    return compiled;
+}

package/Voxels/Models/Rules/Functions/Compile/Nodes/CalcFunctions.d.ts

@@ -0,0 +1,8 @@
+import { VoxelFaces } from "../../../../../../Math";
+import { Quad } from "../../../../../../Mesher/Geomtry";
+import { QuadUVData, VoxelGeometryTransform } from "../../../../../../Mesher/Geomtry/Geometry.types";
+import { Vec4Array } from "@amodx/math";
+export declare function getVertexWeights(face: VoxelFaces, x: number, y: number, z: number): Vec4Array;
+export type QuadVertexWeights = [Vec4Array, Vec4Array, Vec4Array, Vec4Array];
+export declare const getQuadWeights: (quad: Quad, direction: VoxelFaces) => QuadVertexWeights;
+export declare const mapQuadUvs: (uvs: Vec4Array, rotation: number | undefined, transform: VoxelGeometryTransform) => QuadUVData;

package/Voxels/Models/Rules/Functions/Compile/Nodes/CalcFunctions.js

@@ -0,0 +1,106 @@
+import { VoxelFaces } from "../../../../../../Math";
+import { QuadVerticiesArray, } from "../../../../../../Mesher/Geomtry/Geometry.types";
+import { Matrix2x2Like, Vec2ArrayLike, AMath, } from "@amodx/math";
+function getInterpolationWeights(x, y, flip = false) {
+    x = Math.max(0, Math.min(1, x));
+    y = Math.max(0, Math.min(1, y));
+    let w1 = (1 - x) * (1 - y); // Weight for v1 = (0, 0)
+    let w2 = x * (1 - y); // Weight for v2 = (1, 0)
+    let w3 = x * y; // Weight for v3 = (1, 1)
+    let w4 = (1 - x) * y; // Weight for v4 = (0, 1)
+    return flip ? [w4, w3, w2, w1] : [w3, w4, w1, w2];
+}
+export function getVertexWeights(face, x, y, z) {
+    let flip = false;
+    let u, v;
+    switch (face) {
+        case VoxelFaces.Up:
+            u = x;
+            v = z;
+            break;
+        case VoxelFaces.Down:
+            u = x;
+            v = z;
+            flip = true;
+            break;
+        case VoxelFaces.North:
+            u = x;
+            v = y;
+            flip = true;
+            break;
+        case VoxelFaces.South:
+            u = x;
+            v = y;
+            break;
+        case VoxelFaces.East:
+            u = z;
+            v = y;
+            break;
+        case VoxelFaces.West:
+            u = z;
+            v = y;
+            flip = true;
+            break;
+    }
+    return getInterpolationWeights(u, v, flip);
+}
+export const getQuadWeights = (quad, direction) => {
+    const returnArray = [];
+    for (const vertex of QuadVerticiesArray) {
+        const { x, y, z } = quad.positions.vertices[vertex];
+        returnArray[vertex] = getVertexWeights(direction, x, y, z);
+    }
+    return returnArray;
+};
+const rotationMatrix = new Map();
+export const mapQuadUvs = (uvs, rotation = 0, transform) => {
+    if (transform.lockUVs == true) {
+        let rotM = rotationMatrix.get(rotation);
+        if (!rotM) {
+            rotM = Matrix2x2Like.Rotation(AMath.DegreesToRadians(rotation));
+            rotationMatrix.set(rotation, rotM);
+        }
+        return [
+            Vec2ArrayLike.ApplyMatrix(rotM, [uvs[2], uvs[3]]),
+            Vec2ArrayLike.ApplyMatrix(rotM, [uvs[0], uvs[3]]),
+            Vec2ArrayLike.ApplyMatrix(rotM, [uvs[0], uvs[1]]),
+            Vec2ArrayLike.ApplyMatrix(rotM, [uvs[2], uvs[1]]),
+        ];
+    }
+    let u0 = uvs[0];
+    let v0 = uvs[1];
+    let u1 = uvs[2];
+    let v1 = uvs[3];
+    if (transform.flip) {
+        if (transform.flip[0] === 1) {
+            [u0, u1] = [u1, u0];
+        }
+        if (transform.flip[1] === 1) {
+            [v0, v1] = [v1, v0];
+        }
+    }
+    let quadUVs = [
+        [u1, v1],
+        [u0, v1],
+        [u0, v0],
+        [u1, v0],
+    ];
+    if (rotation !== 0) {
+        let rotM = rotationMatrix.get(rotation);
+        if (!rotM) {
+            rotM = Matrix2x2Like.Rotation(AMath.DegreesToRadians(rotation));
+            rotationMatrix.set(rotation, rotM);
+        }
+        const centerU = (u0 + u1) / 2;
+        const centerV = (v0 + v1) / 2;
+        quadUVs = quadUVs.map(([u, v]) => {
+            let x = u - centerU;
+            let y = v - centerV;
+            [x, y] = Vec2ArrayLike.ApplyMatrix(rotM, [x, y]);
+            x += centerU;
+            y += centerV;
+            return [x, y];
+        });
+    }
+    return quadUVs;
+};

package/Voxels/Models/Rules/Functions/Compile/Nodes/CompileBoxGeometryNode.d.ts

@@ -0,0 +1,5 @@
+import { VoxelGeometryTransform } from "../../../../../../Mesher/Geomtry/Geometry.types";
+import { CompiledQuadVoxelGeomtryNode } from "Mesher/Models/Nodes/Types/QuadVoxelGometryNodeTypes";
+import { GeomtryInput } from "../../../../../../Voxels/Models/Rules/Classes/GeomtryInput";
+import { VoxelBoxGeometryNode } from "Voxels/Models/VoxelModel.types";
+export declare function CompileBoxGeometryNode(buildRules: boolean, input: GeomtryInput, data: VoxelBoxGeometryNode, transform: VoxelGeometryTransform): CompiledQuadVoxelGeomtryNode[];

package/Voxels/Models/Rules/Functions/Compile/Nodes/CompileBoxGeometryNode.js

@@ -0,0 +1,14 @@
+import { VoxelFaceNameMap } from "../../../../../../Math";
+import { TransformBox } from "../../../../../../Mesher/Geomtry/Transform/TransformBox";
+import { CompileQuadGeometryNode } from "./CompileQuadGeometryNode";
+import { Box } from "../../../../../../Mesher/Geomtry/Shapes/Box";
+export function CompileBoxGeometryNode(buildRules, input, data, transform) {
+    // const quads: Quad[] = [];
+    const box = Box.Create(data.points);
+    TransformBox(box, transform);
+    const compiled = [];
+    for (let i = 0; i < 6; i++) {
+        compiled.push(CompileQuadGeometryNode(buildRules, input, box.quads[i].positions.toVec3Array(), data.faces[VoxelFaceNameMap[i]]));
+    }
+    return compiled;
+}

package/Voxels/Models/Rules/Functions/Compile/Nodes/CompileQuadGeometryNode.d.ts

@@ -0,0 +1,6 @@
+import { Vec3Array } from "@amodx/math";
+import { VoxelGeometryTransform } from "../../../../../../Mesher/Geomtry/Geometry.types";
+import { CompiledQuadVoxelGeomtryNode } from "../../../../../../Mesher/Models/Nodes/Types/QuadVoxelGometryNodeTypes";
+import { GeomtryInput } from "Voxels/Models/Rules/Classes/GeomtryInput";
+import { BaseVoxelQuadData } from "Voxels/Models/VoxelModel.types";
+export declare function CompileQuadGeometryNode(buildRules: boolean, input: GeomtryInput, points: [Vec3Array, Vec3Array, Vec3Array, Vec3Array], node: BaseVoxelQuadData, transform?: VoxelGeometryTransform): CompiledQuadVoxelGeomtryNode;

package/Voxels/Models/Rules/Functions/Compile/Nodes/CompileQuadGeometryNode.js

@@ -0,0 +1,92 @@
+import { Quad } from "../../../../../../Mesher/Geomtry/Primitives/Quad";
+import { getQuadWeights, mapQuadUvs } from "./CalcFunctions";
+import { TransformQuad } from "../../../../../../Mesher/Geomtry/Transform/TransformQuad";
+import { QuadVoxelGometryInputs, } from "../../../../../../Mesher/Models/Nodes/Types/QuadVoxelGometryNodeTypes";
+import { OcclusionFaceRegister } from "../../../Classes/OcclusionFaceRegister";
+import { closestVoxelFace } from "../../../../../../Math/UtilFunctions";
+export function CompileQuadGeometryNode(buildRules, input, points, node, transform = {}) {
+    const quad = transform
+        ? TransformQuad(Quad.Create(points), transform)
+        : Quad.Create(points);
+    const normals = quad.normals.toArray();
+    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 closestFace = closestVoxelFace(averageNormal);
+    const weights = getQuadWeights(quad, closestFace);
+    const positions = quad.positions.toVec3Array();
+    input.args.push(QuadVoxelGometryInputs.CreateArgs());
+    const argsIndex = input.args.length - 1;
+    let defaultUvs = [0, 0, 1, 1];
+    if (input.isArgString(node.enabled)) {
+        input.onInput(String(node.enabled), (value) => (input.args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.Enabled] =
+            value));
+    }
+    else {
+        node.enabled !== undefined &&
+            (input.args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.Enabled] =
+                node.enabled);
+    }
+    if (input.isArgString(node.doubleSided)) {
+        input.onInput(String(node.doubleSided), (value) => (input.args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.DoubleSided] =
+            value));
+    }
+    else {
+        node.doubleSided !== undefined &&
+            (input.args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.DoubleSided] =
+                node.doubleSided);
+    }
+    if (input.isArgString(node.rotation)) {
+        input.onInput(String(node.rotation), (value) => {
+            input.args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.Rotation] = value;
+            input.args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.UVs] = mapQuadUvs(defaultUvs, value, transform);
+        });
+    }
+    else {
+        node.rotation &&
+            (input.args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.Rotation] =
+                node.rotation);
+    }
+    if (input.isArgString(node.uv)) {
+        const defaultInput = input.geomtry.arguments[node.uv.substring(1)];
+        if (defaultInput.type == "box-uv" && defaultInput.default) {
+            input.args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.UVs] = mapQuadUvs(defaultInput.default, input.args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.Rotation], transform);
+            defaultUvs = defaultInput.default;
+        }
+        input.onInput(String(node.uv), (value) => {
+            input.args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.UVs] = mapQuadUvs(value, input.args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.Rotation], transform);
+        });
+    }
+    else {
+        input.args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.UVs] = mapQuadUvs(node.uv, input.args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.Rotation], transform);
+        defaultUvs = node.uv;
+    }
+    if (input.isArgString(node.texture)) {
+        input.onInput(String(node.texture), (value) => (input.args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.Texture] =
+            value));
+    }
+    return {
+        type: "quad",
+        positions,
+        weights,
+        closestFace,
+        trueFaceIndex: buildRules
+            ? OcclusionFaceRegister.getQuadId(quad)
+            : undefined,
+    };
+}

package/Voxels/Models/Rules/Functions/Compile/Nodes/CompileTriangleGeometryNode.d.ts

@@ -0,0 +1,6 @@
+import { Vec3Array } from "@amodx/math";
+import { VoxelGeometryTransform } from "../../../../../../Mesher/Geomtry/Geometry.types";
+import { CompiledTriangleVoxelGeomtryNode } from "../../../../../../Mesher/Models/Nodes/Types/TriangleVoxelGometryNodeTypes";
+import { GeomtryInput } from "../../../Classes/GeomtryInput";
+import { BaseVoxelTriangleData } from "../../../../VoxelModel.types";
+export declare function CompileTriangleGeometryNode(buildRules: boolean, input: GeomtryInput, points: [Vec3Array, Vec3Array, Vec3Array], node: BaseVoxelTriangleData, transform?: VoxelGeometryTransform): CompiledTriangleVoxelGeomtryNode;

package/Voxels/Models/Rules/Functions/Compile/Nodes/CompileTriangleGeometryNode.js

@@ -0,0 +1,115 @@
+import { Triangle } from "../../../../../../Mesher/Geomtry/Primitives/Triangle";
+import { getVertexWeights } from "./CalcFunctions";
+import { TransformTriangle } from "../../../../../../Mesher/Geomtry/Transform/TransformTriangle";
+import { TriangleVoxelGometryInputs, } from "../../../../../../Mesher/Models/Nodes/Types/TriangleVoxelGometryNodeTypes";
+import { OcclusionFaceRegister } from "../../../Classes/OcclusionFaceRegister";
+import { closestVoxelFace } from "../../../../../../Math/UtilFunctions";
+export function CompileTriangleGeometryNode(buildRules, input, points, node, transform) {
+    const triangle = transform
+        ? TransformTriangle(Triangle.Create(points), transform)
+        : Triangle.Create(points);
+    const normals = triangle.normals.toArray();
+    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 closestFace = closestVoxelFace(averageNormal);
+    const weights = [];
+    const positions = triangle.positions.toVec3Array();
+    for (let i = 0; i < positions.length; i++) {
+        weights[i] = getVertexWeights(closestFace, ...positions[i]);
+    }
+    input.args.push(TriangleVoxelGometryInputs.CreateArgs());
+    const argsIndex = input.args.length - 1;
+    let defaultUvs = [
+        [0, 0],
+        [0, 0],
+        [0, 0],
+    ];
+    if (input.isArgString(node.doubleSided)) {
+        input.onInput(String(node.doubleSided), (value) => {
+            input.args[argsIndex][TriangleVoxelGometryInputs.ArgIndexes.DoubleSided] =
+                value;
+        });
+    }
+    else {
+        input.args[argsIndex][TriangleVoxelGometryInputs.ArgIndexes.DoubleSided] =
+            Boolean(node.doubleSided);
+    }
+    if (input.isArgString(node.rotation)) {
+        input.onInput(String(node.rotation), (value) => {
+            input.args[argsIndex][TriangleVoxelGometryInputs.ArgIndexes.Rotation] =
+                value;
+            /*          args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.UVs] = mapQuadUvs(
+                    defaultUvs,
+                    value,
+                    tranform
+                  ); */
+            input.args[argsIndex][TriangleVoxelGometryInputs.ArgIndexes.UVs] =
+                defaultUvs;
+        });
+    }
+    else {
+        node.rotation &&
+            (input.args[argsIndex][TriangleVoxelGometryInputs.ArgIndexes.Rotation] =
+                node.rotation);
+    }
+    if (input.isArgString(node.uv)) {
+        const defaultInput = input.geomtry.arguments[node.uv.substring(1)];
+        if (defaultInput.type == "uv" && defaultInput.default) {
+            /*        args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.UVs] = mapQuadUvs(
+                  defaultInput.default,
+                  args[argsIndex][QuadVoxelGometryInputs.ArgIndexes.Rotation],
+                  tranform
+                ); */
+            input.args[argsIndex][TriangleVoxelGometryInputs.ArgIndexes.UVs] =
+                defaultInput.default;
+            defaultInput.default = defaultUvs;
+        }
+        input.onInput(String(node.uv), (value) => {
+            /*     args[argsIndex][TriangleVoxelGometryInputs.ArgIndexes.UVs] = mapQuadUvs(
+              value,
+              args[argsIndex][TriangleVoxelGometryInputs.ArgIndexes.Rotation],
+              transform
+            );
+       */
+            input.args[argsIndex][TriangleVoxelGometryInputs.ArgIndexes.UVs] = value;
+        });
+    }
+    else {
+        /*        args[argsIndex][TriangleVoxelGometryInputs.ArgIndexes.UVs] = mapQuadUvs(
+              node.uv as Vec4Array,
+              args[argsIndex][TriangleVoxelGometryInputs.ArgIndexes.Rotation],
+              tranform
+            ); */
+        input.args[argsIndex][TriangleVoxelGometryInputs.ArgIndexes.UVs] = node.uv;
+        defaultUvs = node.uv;
+    }
+    if (input.isArgString(node.texture)) {
+        input.onInput(String(node.texture), (value) => (input.args[argsIndex][TriangleVoxelGometryInputs.ArgIndexes.Texture] =
+            value));
+    }
+    return {
+        type: "triangle",
+        positions,
+        weights,
+        closestFace,
+        trueFaceIndex: buildRules
+            ? OcclusionFaceRegister.getTriangleId(triangle)
+            : undefined,
+    };
+}

package/{Models → Voxels/Models}/Rules/VoxelModelRuleBuilderRegister.d.ts

@@ -1,4 +1,4 @@
-import { StringPalette } from "../../Util/StringPalette";
+import { StringPalette } from "../../../Util/StringPalette";
 import { VoxelGeometryData, VoxelGeometryLinkData, VoxelModelConstructorData, VoxelModelData } from "../VoxelModel.types";
 import { VoxelRuleGeometry } from "./Classes/VoxelRulesGeometry";
 import { VoxelRulesModoel } from "./Classes/VoxelRulesModel";