@divinevoxel/vlox 0.0.78 → 0.0.80

package/Voxels/Functions/Geometry/BuildGeometryLUT.js

@@ -0,0 +1,395 @@
+import { StringPalette } from "../../../Util/StringPalette";
+import { GeometryLUT } from "../../Data/GeometryLUT";
+import { BuildInputs } from "./Inputs/BuldInputs";
+import { BuildCompiled } from "./Compile/BuildCompiled";
+import { BuildRules } from "./Rules/BuildRules";
+import { VoxelFaceNameArray } from "../../../Math";
+const getGeometryLinkId = (node) => {
+    return `${node.geometryId}${node.cullingProcedure ? JSON.stringify(node.cullingProcedure) : " "}${node.position ? `-p${node.position.toString()}` : ""}${node.rotation ? `-r${node.rotation.toString()}` : ""}${node.scale ? `-s${node.scale.toString()}` : ""}${node.flip ? `-f${node.flip.toString()}` : ""}`.trim();
+};
+const getVoxelModelInputId = (data) => {
+    let baseId = `${data.geoNodeId}-${data.modelId}`;
+    const modelInputKeys = Object.keys(data.modelInputs).sort();
+    for (const key of modelInputKeys) {
+        baseId += `${key}-${JSON.stringify(data.modelInputs[key])}`;
+    }
+    const voxelInputKeys = Object.keys(data.voxelInputs).sort();
+    for (const key of voxelInputKeys) {
+        baseId += `${key}-${JSON.stringify(data.voxelInputs[key])}`;
+    }
+    return baseId;
+};
+export function BuildGeomeetryLUT(voxels, geomtries, models) {
+    const geometryMap = new Map();
+    for (const geometry of geomtries) {
+        geometryMap.set(geometry.id, geometry);
+        const divisor = geometry.divisor;
+        for (const node of geometry.nodes) {
+            if (node.type == "box") {
+                let d = node.divisor ? node.divisor : divisor;
+                if (!d)
+                    continue;
+                node.points[0][0] /= d[0];
+                node.points[0][1] /= d[1];
+                node.points[0][2] /= d[2];
+                node.points[1][0] /= d[0];
+                node.points[1][1] /= d[1];
+                node.points[1][2] /= d[2];
+                for (const faceName of VoxelFaceNameArray) {
+                    const data = node.faces[faceName];
+                    if (Array.isArray(data.uv)) {
+                        data.uv[0] /= d[0];
+                        data.uv[1] /= d[1];
+                        data.uv[2] /= d[0];
+                        data.uv[3] /= d[1];
+                    }
+                }
+                if (node.divisor)
+                    node.divisor = undefined;
+            }
+            if (node.type == "quad") {
+                let d = node.divisor ? node.divisor : divisor;
+                if (!d)
+                    continue;
+                for (let i = 0; i < 4; i++) {
+                    const point = node.points[i];
+                    point[0] /= d[0];
+                    point[1] /= d[1];
+                    point[2] /= d[2];
+                }
+                if (Array.isArray(node.uv)) {
+                    if (Array.isArray(node.uv[0])) {
+                        let uvs = node.uv;
+                        for (let i = 0; i < node.uv.length; i++) {
+                            uvs[i][0] /= d[0];
+                            uvs[i][1] /= d[1];
+                        }
+                    }
+                    else {
+                        let uvs = node.uv;
+                        uvs[0] /= d[0];
+                        uvs[1] /= d[1];
+                        uvs[2] /= d[0];
+                        uvs[3] /= d[1];
+                    }
+                }
+                if (node.divisor)
+                    node.divisor = undefined;
+            }
+            if (node.type == "triangle") {
+                let d = node.divisor ? node.divisor : divisor;
+                if (!d)
+                    continue;
+                for (let i = 0; i < 4; i++) {
+                    const point = node.points[i];
+                    point[0] /= d[0];
+                    point[1] /= d[1];
+                    point[2] /= d[2];
+                }
+                if (Array.isArray(node.uv)) {
+                    if (Array.isArray(node.uv[0])) {
+                        let uvs = node.uv;
+                        for (let i = 0; i < node.uv.length; i++) {
+                            uvs[i][0] /= d[0];
+                            uvs[i][1] /= d[1];
+                        }
+                    }
+                }
+                if (node.divisor)
+                    node.divisor = undefined;
+            }
+            if (geometry.divisor)
+                geometry.divisor = undefined;
+        }
+    }
+    const modelMap = new Map();
+    for (const model of models) {
+        modelMap.set(model.id, model);
+        for (const stateKey in model.stateNodes) {
+            const nodes = model.stateNodes[stateKey];
+            for (const node of nodes) {
+                let d = node.divisor ? node.divisor : model.divisor;
+                if (!d)
+                    continue;
+                if (node.position) {
+                    node.position[0] /= d[0];
+                    node.position[1] /= d[1];
+                    node.position[2] /= d[2];
+                }
+            }
+        }
+        for (const stateKey in model.conditonalNodes) {
+            const nodes = model.conditonalNodes[stateKey];
+            for (const node of nodes) {
+                let d = node.divisor ? node.divisor : model.divisor;
+                if (!d)
+                    continue;
+                if (node.position) {
+                    node.position[0] /= d[0];
+                    node.position[1] /= d[1];
+                    node.position[2] /= d[2];
+                }
+            }
+        }
+    }
+    const modelsProcessed = new Set();
+    const modelStateMap = new Map();
+    const modelConditionalMap = new Map();
+    const geometryLinkRecord = [];
+    const geometryLinkPalette = new StringPalette();
+    const rulelessIndex = [];
+    const inputMap = new Map();
+    const conditionalInputMap = new Map();
+    const cullingProcedures = [
+        {
+            type: "default",
+        },
+        {
+            type: "none",
+        },
+        {
+            type: "transparent",
+        },
+    ];
+    const cullProcedurePalette = new StringPalette();
+    for (const procedure of cullingProcedures) {
+        cullProcedurePalette.register(procedure.type);
+    }
+    GeometryLUT.geometryCullingProcedures = cullingProcedures;
+    for (const voxel of voxels) {
+        const voxelModelData = voxel.properties["dve_model_data"];
+        if (!voxelModelData)
+            continue;
+        const model = modelMap.get(voxelModelData.id);
+        if (!modelsProcessed.has(voxelModelData.id)) {
+            modelsProcessed.add(voxelModelData.id);
+            const stateNodes = {};
+            for (const state in model.stateNodes) {
+                const nodes = model.stateNodes[state];
+                const nodeIds = [];
+                for (const node of nodes) {
+                    const getLinkId = getGeometryLinkId(node);
+                    const getLinkPaletteId = geometryLinkPalette.register(getLinkId);
+                    geometryLinkRecord[getLinkPaletteId] = node;
+                    nodeIds.push(getLinkPaletteId);
+                    const cullingProcedure = node.cullingProcedure
+                        ? node.cullingProcedure
+                        : geometryMap.get(node.geometryId)?.cullingProcedure ||
+                            cullingProcedures[0];
+                    GeometryLUT.geometryCullingProceduresIndex[getLinkPaletteId] =
+                        cullProcedurePalette.getNumberId(cullingProcedure.type);
+                    if (geometryMap.get(node.geometryId)?.doNotBuildRules) {
+                        rulelessIndex[getLinkPaletteId] = true;
+                    }
+                    else {
+                        rulelessIndex[getLinkPaletteId] = false;
+                    }
+                }
+                nodeIds.sort();
+                stateNodes[state] = nodeIds;
+            }
+            modelStateMap.set(model.id, stateNodes);
+            const conditionalStateNodes = {};
+            for (const state in model.conditonalNodes) {
+                const nodes = model.conditonalNodes[state];
+                const nodeIds = [];
+                for (const node of nodes) {
+                    const getLinkId = getGeometryLinkId(node);
+                    const getLinkPaletteId = geometryLinkPalette.register(getLinkId);
+                    geometryLinkRecord[getLinkPaletteId] = node;
+                    nodeIds.push(getLinkPaletteId);
+                    const cullingProcedure = node.cullingProcedure
+                        ? node.cullingProcedure
+                        : geometryMap.get(node.geometryId)?.cullingProcedure ||
+                            cullingProcedures[0];
+                    GeometryLUT.geometryCullingProceduresIndex[getLinkPaletteId] =
+                        cullProcedurePalette.getNumberId(cullingProcedure.type);
+                    if (geometryMap.get(node.geometryId)?.doNotBuildRules) {
+                        rulelessIndex[getLinkPaletteId] = true;
+                    }
+                    else {
+                        rulelessIndex[getLinkPaletteId] = false;
+                    }
+                }
+                nodeIds.sort();
+                conditionalStateNodes[state] = nodeIds;
+            }
+            modelConditionalMap.set(model.id, conditionalStateNodes);
+        }
+        const voxelInputStates = {};
+        const conditonalVoxelInputStates = {};
+        for (const mod in voxelModelData.inputs) {
+            const voxelInputs = voxelModelData.inputs[mod];
+            const voxelStateInputs = {};
+            for (const state in model.stateNodes) {
+                const nodes = model.stateNodes[state];
+                const inputs = [];
+                for (const node of nodes) {
+                    const getLinkId = getGeometryLinkId(node);
+                    const getLinkPaletteId = geometryLinkPalette.getNumberId(getLinkId);
+                    inputs.push({
+                        geoNodeId: getLinkPaletteId,
+                        modelId: model.id,
+                        geometryId: node.geometryId,
+                        voxelInputs: voxelInputs,
+                        modelInputs: node.inputs,
+                    });
+                }
+                voxelStateInputs[state] = inputs;
+            }
+            voxelInputStates[mod] = voxelStateInputs;
+            const conditonalVoxelStateInputs = {};
+            for (const state in model.conditonalNodes) {
+                const nodes = model.conditonalNodes[state];
+                const inputs = [];
+                for (const node of nodes) {
+                    const getLinkId = getGeometryLinkId(node);
+                    const getLinkPaletteId = geometryLinkPalette.getNumberId(getLinkId);
+                    inputs.push({
+                        geoNodeId: getLinkPaletteId,
+                        modelId: model.id,
+                        geometryId: node.geometryId,
+                        voxelInputs: voxelInputs,
+                        modelInputs: node.inputs,
+                    });
+                }
+                conditonalVoxelStateInputs[state] = inputs;
+            }
+            conditonalVoxelInputStates[mod] = conditonalVoxelStateInputs;
+        }
+        inputMap.set(voxel.id, voxelInputStates);
+        conditionalInputMap.set(voxel.id, conditonalVoxelInputStates);
+    }
+    //build final
+    const finalModelStateMap = new Map();
+    const finalModelConditionalMap = new Map();
+    const geometryIndex = [];
+    const finalGeometryPalette = new StringPalette();
+    for (const [model, values] of modelStateMap) {
+        const finalStateMap = {};
+        for (const state in values) {
+            const geoIds = values[state];
+            const geoIdsString = geoIds.toString();
+            const geoFinalId = finalGeometryPalette.register(geoIdsString);
+            geometryIndex[geoFinalId] = geoIds;
+            finalStateMap[state] = geoFinalId;
+        }
+        finalModelStateMap.set(model, finalStateMap);
+    }
+    for (const [model, values] of modelConditionalMap) {
+        const finalStateMap = {};
+        for (const state in values) {
+            const geoIds = values[state];
+            const geoIdsString = geoIds.toString();
+            const geoFinalId = finalGeometryPalette.register(geoIdsString);
+            geometryIndex[geoFinalId] = geoIds;
+            finalStateMap[state] = geoFinalId;
+        }
+        finalModelConditionalMap.set(model, finalStateMap);
+    }
+    //prepare to build final inputs
+    const preFinalVoxelStateInputMap = new Map();
+    const preFinalVoxelConditionalInputMap = new Map();
+    const inputRecord = [];
+    const finalGeometryInputPalette = new StringPalette();
+    for (const [voxel, inputs] of inputMap) {
+        const finalInputs = {};
+        for (const mod in inputs) {
+            finalInputs[mod] = {};
+            const states = inputs[mod];
+            for (const state in states) {
+                const inputs = [];
+                const voxelInputs = states[state];
+                for (const input of voxelInputs) {
+                    const inputId = getVoxelModelInputId(input);
+                    const finalInputId = finalGeometryInputPalette.register(inputId);
+                    inputs.push(finalInputId);
+                    inputRecord[finalInputId] = input;
+                }
+                inputs.sort();
+                finalInputs[mod][state] = inputs;
+            }
+        }
+        preFinalVoxelStateInputMap.set(voxel, finalInputs);
+    }
+    for (const [voxel, inputs] of conditionalInputMap) {
+        const finalInputs = {};
+        for (const mod in inputs) {
+            finalInputs[mod] = {};
+            const states = inputs[mod];
+            for (const state in states) {
+                const inputs = [];
+                const voxelInputs = states[state];
+                for (const input of voxelInputs) {
+                    const inputId = getVoxelModelInputId(input);
+                    const finalInputId = finalGeometryInputPalette.register(inputId);
+                    inputs.push(finalInputId);
+                    inputRecord[finalInputId] = input;
+                }
+                inputs.sort();
+                finalInputs[mod][state] = inputs;
+            }
+        }
+        preFinalVoxelConditionalInputMap.set(voxel, finalInputs);
+    }
+    //build final inputs
+    const finalVoxelStateInputMap = new Map();
+    const finalVoxelConditionalInputMap = new Map();
+    const inputIndex = [];
+    const finalInputPalette = new StringPalette();
+    for (const [voxel, inputs] of preFinalVoxelStateInputMap) {
+        const finalInputs = {};
+        for (const mod in inputs) {
+            finalInputs[mod] = {};
+            const states = inputs[mod];
+            for (const state in states) {
+                const inputIds = inputs[mod][state];
+                const inputsStringId = inputIds.toString();
+                const inputsFinalId = finalInputPalette.register(inputsStringId);
+                finalInputs[mod][state] = inputsFinalId;
+                inputIndex[inputsFinalId] = inputIds;
+            }
+        }
+        finalVoxelStateInputMap.set(voxel, finalInputs);
+    }
+    for (const [voxel, inputs] of preFinalVoxelConditionalInputMap) {
+        const finalInputs = {};
+        for (const mod in inputs) {
+            finalInputs[mod] = {};
+            const states = inputs[mod];
+            for (const state in states) {
+                const inputIds = inputs[mod][state];
+                const inputsStringId = inputIds.toString();
+                const inputsFinalId = finalInputPalette.register(inputsStringId);
+                finalInputs[mod][state] = inputsFinalId;
+                inputIndex[inputsFinalId] = inputIds;
+            }
+        }
+        finalVoxelConditionalInputMap.set(voxel, finalInputs);
+    }
+    GeometryLUT.geometryIndex = geometryIndex;
+    GeometryLUT.geometryInputsIndex = inputIndex;
+    //Build compiled geometry
+    const finalCompiledData = [];
+    for (let i = 0; i < geometryLinkRecord.length; i++) {
+        const geoLinkData = geometryLinkRecord[i];
+        finalCompiledData[i] = BuildCompiled(geoLinkData, geometryMap.get(geoLinkData.geometryId));
+    }
+    GeometryLUT.compiledGeometry = finalCompiledData;
+    //Build geometry inputs
+    const finalInputData = [];
+    for (let i = 0; i < inputRecord.length; i++) {
+        const inputs = inputRecord[i];
+        const geoLinkData = geometryLinkRecord[inputs.geoNodeId];
+        finalInputData[i] = BuildInputs(geoLinkData, inputs, modelMap.get(inputs.modelId), geometryMap.get(inputs.geometryId));
+    }
+    GeometryLUT.geometryInputs = finalInputData;
+    //Build Rules
+    BuildRules();
+    return {
+        finalModelStateMap,
+        finalModelConditionalMap,
+        finalVoxelStateInputMap,
+        finalVoxelConditionalInputMap,
+    };
+}

package/Voxels/{Models/Rules/Functions/Compile/Nodes → Functions/Geometry}/CalcFunctions.d.ts

@@ -1,6 +1,6 @@
-import { VoxelFaces } from "../../../../../../Math";
-import { Quad } from "../../../../../../Mesher/Geomtry";
-import { QuadUVData, VoxelGeometryTransform } from "../../../../../../Mesher/Geomtry/Geometry.types";
+import { VoxelFaces } from "../../../Math";
+import { Quad } from "../../../Mesher/Geometry";
+import { QuadUVData, VoxelGeometryTransform } from "../../../Mesher/Geometry/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];

package/Voxels/{Models/Rules/Functions/Compile/Nodes → Functions/Geometry}/CalcFunctions.js

@@ -1,5 +1,5 @@
-import { VoxelFaces } from "../../../../../../Math";
-import { QuadVerticiesArray, } from "../../../../../../Mesher/Geomtry/Geometry.types";
+import { VoxelFaces } from "../../../Math";
+import { QuadVerticiesArray, } from "../../../Mesher/Geometry/Geometry.types";
 import { Matrix2x2Like, Vec2ArrayLike, AMath, } from "@amodx/math";
 function getInterpolationWeights(x, y, flip = false) {
     x = Math.max(0, Math.min(1, x));

package/Voxels/Functions/Geometry/Compile/BuildCompiled.d.ts

@@ -0,0 +1,4 @@
+import { VoxelGeometryLinkData } from "../../../Models/VoxelModel.types";
+import { VoxelGeometryData } from "../../../Geometry/VoxelGeometry.types";
+import { CompiledGeometryNodes } from "../../../../Mesher/Voxels/Models/Nodes/Types/GeometryNode.types";
+export declare function BuildCompiled(geoLink: VoxelGeometryLinkData, geometry: VoxelGeometryData): CompiledGeometryNodes[];

package/Voxels/Functions/Geometry/Compile/BuildCompiled.js

@@ -0,0 +1,25 @@
+import { BuildCompiledBox } from "./BuildCompiledBox";
+import { BuildCompiledQuad } from "./BuildCompiledQuad";
+import { BuildCompiledTri } from "./BuildCompiledTri";
+export function BuildCompiled(geoLink, geometry) {
+    const buildRules = geometry.doNotBuildRules !== true;
+    const compiled = [];
+    for (const node of geometry.nodes) {
+        if (node.type == "box") {
+            compiled.push(...BuildCompiledBox(buildRules, node, geoLink));
+        }
+        if (node.type == "quad") {
+            compiled.push(BuildCompiledQuad(buildRules, node.points, geoLink));
+        }
+        if (node.type == "triangle") {
+            compiled.push(BuildCompiledTri(buildRules, node.points, geoLink));
+        }
+        if (node.type == "custom") {
+            compiled.push({
+                type: "custom",
+                id: node.id,
+            });
+        }
+    }
+    return compiled;
+}

package/Voxels/Functions/Geometry/Compile/BuildCompiledBox.d.ts

@@ -0,0 +1,4 @@
+import { VoxelGeometryTransform } from "../../../../Mesher/Geometry/Geometry.types";
+import { CompiledQuadVoxelGeometryNode } from "Mesher/Voxels/Models/Nodes/Types/QuadVoxelGometryNodeTypes";
+import { VoxelBoxGeometryNode } from "../../../Geometry/VoxelGeometry.types";
+export declare function BuildCompiledBox(buildRules: boolean, data: VoxelBoxGeometryNode, transform: VoxelGeometryTransform): CompiledQuadVoxelGeometryNode[];

package/Voxels/Functions/Geometry/Compile/BuildCompiledBox.js

@@ -0,0 +1,13 @@
+import { TransformBox } from "../../../../Mesher/Geometry/Transform/TransformBox";
+import { BuildCompiledQuad } from "./BuildCompiledQuad";
+import { Box } from "../../../../Mesher/Geometry/Shapes/Box";
+export function BuildCompiledBox(buildRules, data, transform) {
+    const box = Box.Create(data.points);
+    TransformBox(box, transform);
+    const blankTransform = {};
+    const compiled = [];
+    for (let i = 0; i < 6; i++) {
+        compiled.push(BuildCompiledQuad(buildRules, box.quads[i].positions.toVec3Array(), blankTransform));
+    }
+    return compiled;
+}

package/Voxels/Functions/Geometry/Compile/BuildCompiledQuad.d.ts

@@ -0,0 +1,4 @@
+import { Vec3Array } from "@amodx/math";
+import { VoxelGeometryTransform } from "../../../../Mesher/Geometry/Geometry.types";
+import { CompiledQuadVoxelGeometryNode } from "../../../../Mesher/Voxels/Models/Nodes/Types/QuadVoxelGometryNodeTypes";
+export declare function BuildCompiledQuad(buildRules: boolean, points: [Vec3Array, Vec3Array, Vec3Array, Vec3Array], transform?: VoxelGeometryTransform): CompiledQuadVoxelGeometryNode;

package/Voxels/Functions/Geometry/Compile/BuildCompiledQuad.js

@@ -0,0 +1,41 @@
+import { Quad } from "../../../../Mesher/Geometry/Primitives/Quad";
+import { getQuadWeights } from "../CalcFunctions";
+import { TransformQuad } from "../../../../Mesher/Geometry/Transform/TransformQuad";
+import { OcclusionFaceRegister } from "../Rules/OcclusionFaceRegister";
+import { closestVoxelFace } from "../../../../Math/UtilFunctions";
+export function BuildCompiledQuad(buildRules, points, 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();
+    return {
+        type: "quad",
+        positions,
+        weights,
+        closestFace,
+        trueFaceIndex: buildRules
+            ? OcclusionFaceRegister.getQuadId(quad)
+            : undefined,
+    };
+}

package/Voxels/Functions/Geometry/Compile/BuildCompiledTri.d.ts

@@ -0,0 +1,4 @@
+import { Vec3Array } from "@amodx/math";
+import { VoxelGeometryTransform } from "../../../../Mesher/Geometry/Geometry.types";
+import { CompiledTriangleVoxelGeometryNode } from "../../../../Mesher/Voxels/Models/Nodes/Types/TriangleVoxelGometryNodeTypes";
+export declare function BuildCompiledTri(buildRules: boolean, points: [Vec3Array, Vec3Array, Vec3Array], transform: VoxelGeometryTransform): CompiledTriangleVoxelGeometryNode;

package/Voxels/Functions/Geometry/Compile/BuildCompiledTri.js

@@ -0,0 +1,44 @@
+import { Triangle } from "../../../../Mesher/Geometry/Primitives/Triangle";
+import { getVertexWeights } from "../CalcFunctions";
+import { TransformTriangle } from "../../../../Mesher/Geometry/Transform/TransformTriangle";
+import { OcclusionFaceRegister } from "../Rules/OcclusionFaceRegister";
+import { closestVoxelFace } from "../../../../Math/UtilFunctions";
+export function BuildCompiledTri(buildRules, points, 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]);
+    }
+    return {
+        type: "triangle",
+        positions,
+        weights,
+        closestFace,
+        trueFaceIndex: buildRules
+            ? OcclusionFaceRegister.getTriangleId(triangle)
+            : undefined,
+    };
+}

package/Voxels/Functions/Geometry/GeometryLUT.types.d.ts

@@ -0,0 +1,7 @@
+export type VoxelModelInputs = {
+    geoNodeId: number;
+    geometryId: string;
+    modelId: string;
+    voxelInputs: Record<string, any>;
+    modelInputs: Record<string, any>;
+};

package/Voxels/Functions/Geometry/Inputs/BaseFunctions.d.ts

@@ -0,0 +1,4 @@
+import { BaseVoxelGeometryTextureProcedureData } from "../../../../Mesher/Voxels/Models/Procedures/TextureProcedure";
+export declare function isArgString(data: any): boolean;
+export declare function cleanArgString(data: string): string;
+export declare function processTexture(data: string | BaseVoxelGeometryTextureProcedureData): number | BaseVoxelGeometryTextureProcedureData;

package/Voxels/Functions/Geometry/Inputs/BaseFunctions.js

@@ -0,0 +1,28 @@
+import { TextureManager } from "../../../../Textures/TextureManager";
+export function isArgString(data) {
+    if (typeof data !== "string")
+        return false;
+    return data[0] == "@";
+}
+export function cleanArgString(data) {
+    return data.replace("@", "");
+}
+export function processTexture(data) {
+    if (typeof data == "string")
+        return TextureManager.getTexture("dve_voxel").getTextureIndex(data);
+    if (!data)
+        throw new Error(`Bad data passed into processTexture`);
+    if (typeof data.texture == "string") {
+        data.texture = TextureManager.getTexture("dve_voxel").getTextureIndex(data.texture);
+    }
+    if (data.textureRecrod) {
+        for (const key in data.textureRecrod) {
+            const value = data.textureRecrod[key];
+            if (typeof value == "string") {
+                data.textureRecrod[key] =
+                    TextureManager.getTexture("dve_voxel").getTextureIndex(value);
+            }
+        }
+    }
+    return data;
+}

package/Voxels/Functions/Geometry/Inputs/BuildBoxInputs.d.ts

@@ -0,0 +1,5 @@
+import { VoxelModelData } from "../../../Models/VoxelModel.types";
+import { VoxelModelInputs } from "../GeometryLUT.types";
+import { VoxelBoxGeometryNode, VoxelGeometryData } from "../../../Geometry/VoxelGeometry.types";
+import { VoxelGeometryTransform } from "../../../../Mesher/Geometry/Geometry.types";
+export declare function BuildBoxInputs(args: any[], transform: VoxelGeometryTransform, data: VoxelModelInputs, box: VoxelBoxGeometryNode, model: VoxelModelData, geometry: VoxelGeometryData): void;

package/Voxels/Functions/Geometry/Inputs/BuildBoxInputs.js

@@ -0,0 +1,8 @@
+import { VoxelFaceNameArray } from "../../../../Math";
+import { BuildQuadInputs } from "./BuildQuadInputs";
+export function BuildBoxInputs(args, transform, data, box, model, geometry) {
+    for (const quadFace of VoxelFaceNameArray) {
+        const quad = box.faces[quadFace];
+        BuildQuadInputs(args, transform, data, quad, model, geometry);
+    }
+}

package/Voxels/Functions/Geometry/Inputs/BuildCustomInputs.d.ts

@@ -0,0 +1,5 @@
+import { VoxelModelData } from "../../../Models/VoxelModel.types";
+import { VoxelModelInputs } from "../GeometryLUT.types";
+import { VoxelCustomGeometryNode, VoxelGeometryData } from "../../../Geometry/VoxelGeometry.types";
+import { VoxelGeometryTransform } from "../../../../Mesher/Geometry/Geometry.types";
+export declare function BuildCustomInputs(args: any[], transform: VoxelGeometryTransform, data: VoxelModelInputs, custom: VoxelCustomGeometryNode, model: VoxelModelData, geometry: VoxelGeometryData): void;