@divinevoxel/vlox 0.0.74 → 0.0.76

package/Voxels/Models/Indexing/AOOcclusionFaceIndex.d.ts

@@ -0,0 +1,12 @@
+export type AOOcclusionFaceIndexData = {
+    buffer: ArrayBufferLike;
+    totalFaces: number;
+};
+export declare class AOOcclusionFaceIndex {
+    view: Uint8Array;
+    readonly totalFaces: number;
+    constructor(data: AOOcclusionFaceIndexData);
+    getValue(geomtryId: number, directionIndex: number, faceIndex: number, vertexIndex: number): number;
+    setValue(geomtryId: number, directionIndex: number, faceIndex: number, vertexIndex: number, value?: number): void;
+    toJSON(): AOOcclusionFaceIndexData;
+}

package/Voxels/Models/Indexing/AOOcclusionFaceIndex.js

@@ -0,0 +1,28 @@
+import { getBitArrayIndex, setBitArrayIndex, } from "../../../Util/Binary/BinaryArrays";
+import { VoxelRelativeCubeIndex } from "./VoxelRelativeCubeIndex";
+const flatIndexSize = VoxelRelativeCubeIndex.flatIndex.size;
+function getIndex(geomtryId, directionIndex, faceIndex, totalFaces, vertexIndex) {
+    const start = totalFaces * 4 * flatIndexSize * geomtryId +
+        directionIndex * (totalFaces * 4);
+    return start + faceIndex * 4 + vertexIndex;
+}
+export class AOOcclusionFaceIndex {
+    view;
+    totalFaces;
+    constructor(data) {
+        this.view = new Uint8Array(data.buffer);
+        this.totalFaces = data.totalFaces;
+    }
+    getValue(geomtryId, directionIndex, faceIndex, vertexIndex) {
+        return getBitArrayIndex(this.view, getIndex(geomtryId, directionIndex, faceIndex, this.totalFaces, vertexIndex));
+    }
+    setValue(geomtryId, directionIndex, faceIndex, vertexIndex, value = 0) {
+        return setBitArrayIndex(this.view, getIndex(geomtryId, directionIndex, faceIndex, this.totalFaces, vertexIndex), value);
+    }
+    toJSON() {
+        return {
+            buffer: this.view.buffer,
+            totalFaces: this.totalFaces,
+        };
+    }
+}

package/Voxels/Models/Indexing/CulledOcclusionFaceIndex.d.ts

@@ -0,0 +1,12 @@
+export type CulledOcclusionFaceIndexData = {
+    buffer: ArrayBufferLike;
+    totalFaces: number;
+};
+export declare class CulledOcclusionFaceIndex {
+    view: Uint8Array;
+    readonly totalFaces: number;
+    constructor(data: CulledOcclusionFaceIndexData);
+    getValue(geomtryId: number, directionIndex: number, faceIndex: number): number;
+    setValue(geomtryId: number, directionIndex: number, faceIndex: number, value?: number): void;
+    toJSON(): CulledOcclusionFaceIndexData;
+}

package/Voxels/Models/Indexing/CulledOcclusionFaceIndex.js

@@ -0,0 +1,27 @@
+import { getBitArrayIndex, setBitArrayIndex } from "../../../Util/Binary/BinaryArrays";
+import { VoxelRelativeCubeIndex } from "./VoxelRelativeCubeIndex";
+const flatIndexSize = VoxelRelativeCubeIndex.flatIndex.size;
+function getIndex(geomtryId, directionIndex, faceIndex, totalFaces) {
+    const start = totalFaces * flatIndexSize * geomtryId + directionIndex * totalFaces;
+    return start + faceIndex;
+}
+export class CulledOcclusionFaceIndex {
+    view;
+    totalFaces;
+    constructor(data) {
+        this.view = new Uint8Array(data.buffer);
+        this.totalFaces = data.totalFaces;
+    }
+    getValue(geomtryId, directionIndex, faceIndex) {
+        return getBitArrayIndex(this.view, getIndex(geomtryId, directionIndex, faceIndex, this.totalFaces));
+    }
+    setValue(geomtryId, directionIndex, faceIndex, value = 0) {
+        return setBitArrayIndex(this.view, getIndex(geomtryId, directionIndex, faceIndex, this.totalFaces), value);
+    }
+    toJSON() {
+        return {
+            buffer: this.view.buffer,
+            totalFaces: this.totalFaces,
+        };
+    }
+}

package/Voxels/Models/Rules/Classes/GeomtryInput.d.ts

@@ -0,0 +1,13 @@
+import { VoxelGeometryData } from "../../VoxelModel.types";
+export declare class GeomtryInput {
+    geomtry: VoxelGeometryData;
+    inputObservers: Map<string, ((data: any) => void)[]>;
+    orginalArgs: any[];
+    args: any[];
+    proxy: Record<string, any>;
+    isArgString(data: any): boolean;
+    cloneArgs(): any[];
+    resetDefaults(): void;
+    constructor(geomtry: VoxelGeometryData);
+    onInput(id: string, subscribe: (data: any) => any): number;
+}

package/Voxels/Models/Rules/Classes/GeomtryInput.js

@@ -0,0 +1,64 @@
+import { TextureManager } from "../../../../Textures/TextureManager";
+export class GeomtryInput {
+    geomtry;
+    inputObservers = new Map();
+    orginalArgs = [];
+    args = [];
+    proxy = {};
+    isArgString(data) {
+        if (typeof data !== "string")
+            return false;
+        return data[0] == "@";
+    }
+    cloneArgs() {
+        return structuredClone(this.args);
+    }
+    resetDefaults() {
+        this.args = structuredClone(this.orginalArgs);
+    }
+    constructor(geomtry) {
+        this.geomtry = geomtry;
+        for (const arg in geomtry.arguments) {
+            if (this.inputObservers.has(arg))
+                continue;
+            const obs = [];
+            this.inputObservers.set(arg, obs);
+            const data = geomtry.arguments[arg];
+            Object.defineProperty(this.proxy, arg, {
+                set(value) {
+                    if (data.type == "texture") {
+                        const textureId = value;
+                        if (!Array.isArray(textureId) && typeof textureId == "object") {
+                            const procedureData = {
+                                ...textureId,
+                            };
+                            if (procedureData.texture) {
+                                procedureData.texture = TextureManager.getTexture("dve_voxel")?.getTextureIndex(procedureData.texture);
+                            }
+                            if (procedureData.textureRecrod) {
+                                for (const key in procedureData.textureRecrod) {
+                                    procedureData.textureRecrod[key] = TextureManager.getTexture("dve_voxel")?.getTextureIndex(procedureData.textureRecrod[key]);
+                                }
+                            }
+                            value = { ...procedureData };
+                        }
+                        else {
+                            value =
+                                TextureManager.getTexture("dve_voxel")?.getTextureIndex(textureId);
+                        }
+                    }
+                    for (const func of obs) {
+                        func(value);
+                    }
+                },
+            });
+        }
+    }
+    onInput(id, subscribe) {
+        id = id.replace("@", "");
+        const obs = this.inputObservers.get(id);
+        if (!obs)
+            throw new Error(`Input [${id}] does not exist on ${this.geomtry.id}`);
+        return obs.push(subscribe);
+    }
+}

package/Voxels/Models/Rules/Classes/OcclusionFace.d.ts

@@ -0,0 +1,10 @@
+import { Vec3Array } from "@amodx/math";
+export declare abstract class IOcclusionFace {
+    points: Vec3Array[];
+    normal: Vec3Array;
+    offset: Vec3Array;
+    abstract setOffset(x: number, y: number, z: number): void;
+    abstract updatePoints(): void;
+    abstract isPointInBounds(point: Vec3Array): boolean;
+    abstract doesCoverFace(face: IOcclusionFace): boolean;
+}

package/Voxels/Models/Rules/Classes/OcclusionFace.js

@@ -0,0 +1,5 @@
+export class IOcclusionFace {
+    points;
+    normal;
+    offset = [0, 0, 0];
+}

package/Voxels/Models/Rules/Classes/OcclusionFaceRegister.d.ts

@@ -0,0 +1,18 @@
+import { Vec3Array } from "@amodx/math";
+import { Quad } from "../../../../Mesher/Geomtry/Primitives/Quad";
+import { StringPalette } from "../../../../Util/StringPalette";
+import { Triangle } from "../../../../Mesher/Geomtry/Primitives/Triangle";
+export declare class OcclusionFaceRegister {
+    static faces: StringPalette;
+    static faceIndex: ([
+        type: 0,
+        positions: [Vec3Array, Vec3Array, Vec3Array, Vec3Array],
+        normals: [Vec3Array, Vec3Array, Vec3Array, Vec3Array]
+    ] | [
+        type: 1,
+        positions: [Vec3Array, Vec3Array, Vec3Array],
+        normals: [Vec3Array, Vec3Array, Vec3Array]
+    ])[];
+    static getQuadId(quad: Quad): number;
+    static getTriangleId(triangle: Triangle): number;
+}

package/Voxels/Models/Rules/Classes/OcclusionFaceRegister.js

@@ -0,0 +1,33 @@
+import { StringPalette } from "../../../../Util/StringPalette";
+export class OcclusionFaceRegister {
+    static faces = new StringPalette();
+    static faceIndex = [];
+    static getQuadId(quad) {
+        const [p1, p2, p3, p4] = quad.positions.toVec3Array();
+        const [n1, n2, n3, n4] = quad.normals.toVec3Array();
+        const quadId = `p1=${p1.join(",")},n1=${n1.join(",")},p2=${p2.join(",")},n2=${n2.join(",")},p3=${p3.join(",")},n4=${n3.join(",")},p4=${p4.join(",")},n4=${n4.join(",")}`;
+        let id;
+        if (!this.faces.isRegistered(quadId)) {
+            id = this.faces.register(quadId);
+            this.faceIndex.push([0, [p1, p2, p3, p4], [n1, n2, n3, n4]]);
+        }
+        else {
+            id = this.faces.getNumberId(quadId);
+        }
+        return id;
+    }
+    static getTriangleId(triangle) {
+        const [p1, p2, p3] = triangle.positions.toVec3Array();
+        const [n1, n2, n3] = triangle.normals.toVec3Array();
+        const quadId = `p1=${p1.join(",")},n1=${n1.join(",")},p2=${p2.join(",")},n2=${n2.join(",")},p3=${p3.join(",")},n4=${n3.join(",")}`;
+        let id;
+        if (!this.faces.isRegistered(quadId)) {
+            id = this.faces.register(quadId);
+            this.faceIndex.push([1, [p1, p2, p3], [n1, n2, n3]]);
+        }
+        else {
+            id = this.faces.getNumberId(quadId);
+        }
+        return id;
+    }
+}

package/Voxels/Models/Rules/Classes/OcclusionQuadFace.d.ts

@@ -0,0 +1,14 @@
+import { Vec3Array } from "@amodx/math";
+import { IOcclusionFace } from "./OcclusionFace";
+export declare class OcclusionQuadFace extends IOcclusionFace {
+    normals: Vec3Array[];
+    points: [Vec3Array, Vec3Array, Vec3Array, Vec3Array];
+    private _points;
+    setPoints(points: [Vec3Array, Vec3Array, Vec3Array, Vec3Array]): void;
+    setOffset(x: number, y: number, z: number): void;
+    updatePoints(): void;
+    private isPointInTriangle;
+    isPointInBounds(point: Vec3Array): boolean;
+    isPointOnFace(x: number, y: number, z: number): boolean;
+    doesCoverFace(face: IOcclusionFace): boolean;
+}

package/Voxels/Models/Rules/Classes/OcclusionQuadFace.js

@@ -0,0 +1,118 @@
+import { Vec3ArrayLike } from "@amodx/math";
+import { Quad } from "../../../../Mesher/Geomtry/Primitives/Quad";
+import { IOcclusionFace } from "./OcclusionFace";
+export class OcclusionQuadFace extends IOcclusionFace {
+    normals;
+    points = [
+        [0, 0, 0],
+        [0, 0, 0],
+        [0, 0, 0],
+        [0, 0, 0],
+    ];
+    _points;
+    setPoints(points) {
+        this._points = points;
+        this.normals = Quad.GetNormalLeftHanded(points[0], points[1], points[2], points[3]);
+        const averageNormal = [0, 0, 0];
+        for (let i = 0; i < this.normals.length; i++) {
+            averageNormal[0] += this.normals[i][0];
+            averageNormal[1] += this.normals[i][1];
+            averageNormal[2] += this.normals[i][2];
+        }
+        averageNormal[0] /= this.normals.length;
+        averageNormal[1] /= this.normals.length;
+        averageNormal[2] /= this.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;
+        }
+        this.normal = averageNormal;
+        this.updatePoints();
+    }
+    setOffset(x, y, z) {
+        this.offset[0] = x;
+        this.offset[1] = y;
+        this.offset[2] = z;
+        this.updatePoints();
+    }
+    updatePoints() {
+        for (let i = 0; i < 4; i++) {
+            this.points[i][0] = this._points[i][0] + this.offset[0];
+            this.points[i][1] = this._points[i][1] + this.offset[1];
+            this.points[i][2] = this._points[i][2] + this.offset[2];
+        }
+    }
+    isPointInTriangle(p, a, b, c) {
+        // Compute vectors
+        const v0 = [c[0] - a[0], c[1] - a[1], c[2] - a[2]];
+        const v1 = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
+        const v2 = [p[0] - a[0], p[1] - a[1], p[2] - a[2]];
+        // Compute dot products
+        const dot00 = Vec3ArrayLike.Dot(v0, v0);
+        const dot01 = Vec3ArrayLike.Dot(v0, v1);
+        const dot02 = Vec3ArrayLike.Dot(v0, v2);
+        const dot11 = Vec3ArrayLike.Dot(v1, v1);
+        const dot12 = Vec3ArrayLike.Dot(v1, v2);
+        // Compute barycentric coordinates
+        const denom = dot00 * dot11 - dot01 * dot01;
+        if (denom === 0) {
+            return false; // Degenerate triangle
+        }
+        const u = (dot11 * dot02 - dot01 * dot12) / denom;
+        const v = (dot00 * dot12 - dot01 * dot02) / denom;
+        // Check if point is in triangle
+        return u >= 0 && v >= 0 && u + v <= 1;
+    }
+    isPointInBounds(point) {
+        return (this.isPointInTriangle(point, this.points[0], this.points[1], this.points[2]) ||
+            this.isPointInTriangle(point, this.points[0], this.points[2], this.points[3]));
+    }
+    isPointOnFace(x, y, z) {
+        // First, check if point is on the plane
+        const p0 = this.points[0];
+        const v = [x - p0[0], y - p0[1], z - p0[2]];
+        const d = Vec3ArrayLike.Dot(this.normal, v);
+        const epsilon = 1e-6;
+        if (Math.abs(d) > epsilon) {
+            return false;
+        }
+        // Point is on plane, now check if it's inside the face
+        const p = [x, y, z];
+        return this.isPointInBounds(p);
+    }
+    doesCoverFace(face) {
+        // Normalize normals
+        const n1Norm = this.normal;
+        const n2Norm = face.normal;
+        // Compute dot product of normals
+        const dotNormals = Vec3ArrayLike.Dot(n1Norm, n2Norm);
+        if (Math.abs(Math.abs(dotNormals) - 1) > Number.EPSILON) {
+            // Normals are not parallel
+            return false;
+        }
+        // Check if a point from face lies on the plane of this face
+        const p0 = this.points[0];
+        const v = [
+            face.points[0][0] - p0[0],
+            face.points[0][1] - p0[1],
+            face.points[0][2] - p0[2],
+        ];
+        const d = Vec3ArrayLike.Dot(this.normal, v);
+        if (Math.abs(d) > Number.EPSILON) {
+            // Faces are not coplanar
+            return false;
+        }
+        // Check if all points of face are within this face
+        for (const point of face.points) {
+            if (!this.isPointInBounds(point)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

package/Voxels/Models/Rules/Classes/OcclusionTriangleFace.d.ts

@@ -0,0 +1,14 @@
+import { Vec3Array } from "@amodx/math";
+import { IOcclusionFace } from "./OcclusionFace";
+export declare class OcclusionTriangleFace extends IOcclusionFace {
+    normals: Vec3Array[];
+    points: [Vec3Array, Vec3Array, Vec3Array];
+    private _points;
+    setPoints(points: [Vec3Array, Vec3Array, Vec3Array]): void;
+    setOffset(x: number, y: number, z: number): void;
+    updatePoints(): void;
+    private isPointInTriangle;
+    isPointInBounds(point: Vec3Array): boolean;
+    isPointOnFace(x: number, y: number, z: number): boolean;
+    doesCoverFace(face: IOcclusionFace): boolean;
+}

package/Voxels/Models/Rules/Classes/OcclusionTriangleFace.js

@@ -0,0 +1,114 @@
+import { Vec3ArrayLike } from "@amodx/math";
+import { Triangle } from "../../../../Mesher/Geomtry/Primitives/Triangle";
+import { IOcclusionFace } from "./OcclusionFace";
+export class OcclusionTriangleFace extends IOcclusionFace {
+    normals;
+    points = [
+        [0, 0, 0],
+        [0, 0, 0],
+        [0, 0, 0],
+    ];
+    _points;
+    setPoints(points) {
+        this._points = points;
+        this.normals = Triangle.GetNormalLeftHanded(points[0], points[1], points[2]);
+        const averageNormal = [0, 0, 0];
+        for (let i = 0; i < this.normals.length; i++) {
+            averageNormal[0] += this.normals[i][0];
+            averageNormal[1] += this.normals[i][1];
+            averageNormal[2] += this.normals[i][2];
+        }
+        averageNormal[0] /= this.normals.length;
+        averageNormal[1] /= this.normals.length;
+        averageNormal[2] /= this.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;
+        }
+        this.normal = averageNormal;
+        this.updatePoints();
+    }
+    setOffset(x, y, z) {
+        this.offset[0] = x;
+        this.offset[1] = y;
+        this.offset[2] = z;
+        this.updatePoints();
+    }
+    updatePoints() {
+        for (let i = 0; i < 4; i++) {
+            this.points[i][0] = this._points[i][0] + this.offset[0];
+            this.points[i][1] = this._points[i][1] + this.offset[1];
+            this.points[i][2] = this._points[i][2] + this.offset[2];
+        }
+    }
+    isPointInTriangle(p, a, b, c) {
+        // Compute vectors
+        const v0 = [c[0] - a[0], c[1] - a[1], c[2] - a[2]];
+        const v1 = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
+        const v2 = [p[0] - a[0], p[1] - a[1], p[2] - a[2]];
+        // Compute dot products
+        const dot00 = Vec3ArrayLike.Dot(v0, v0);
+        const dot01 = Vec3ArrayLike.Dot(v0, v1);
+        const dot02 = Vec3ArrayLike.Dot(v0, v2);
+        const dot11 = Vec3ArrayLike.Dot(v1, v1);
+        const dot12 = Vec3ArrayLike.Dot(v1, v2);
+        // Compute barycentric coordinates
+        const denom = dot00 * dot11 - dot01 * dot01;
+        if (denom === 0) {
+            return false; // Degenerate triangle
+        }
+        const u = (dot11 * dot02 - dot01 * dot12) / denom;
+        const v = (dot00 * dot12 - dot01 * dot02) / denom;
+        // Check if point is in triangle
+        return u >= 0 && v >= 0 && u + v <= 1;
+    }
+    isPointInBounds(point) {
+        return this.isPointInTriangle(point, this.points[0], this.points[1], this.points[2]);
+    }
+    isPointOnFace(x, y, z) {
+        // First, check if point is on the plane
+        const p0 = this.points[0];
+        const v = [x - p0[0], y - p0[1], z - p0[2]];
+        const d = Vec3ArrayLike.Dot(this.normal, v);
+        const epsilon = 1e-6;
+        if (Math.abs(d) > epsilon) {
+            return false;
+        }
+        // Point is on plane, now check if it's inside the face
+        const p = [x, y, z];
+        return this.isPointInBounds(p);
+    }
+    doesCoverFace(face) {
+        const n1Norm = this.normal;
+        const n2Norm = face.normal;
+        const dotNormals = Vec3ArrayLike.Dot(n1Norm, n2Norm);
+        if (Math.abs(Math.abs(dotNormals) - 1) > Number.EPSILON) {
+            // Normals are not parallel
+            return false;
+        }
+        // Check if a point from face lies on the plane of this face
+        const p0 = this.points[0];
+        const v = [
+            face.points[0][0] - p0[0],
+            face.points[0][1] - p0[1],
+            face.points[0][2] - p0[2],
+        ];
+        const d = Vec3ArrayLike.Dot(this.normal, v);
+        if (Math.abs(d) > Number.EPSILON) {
+            // Faces are not coplanar
+            return false;
+        }
+        // Check if all points of face are within this face
+        for (const point of face.points) {
+            if (!this.isPointInBounds(point)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

package/Voxels/Models/Rules/Classes/VoxelRulesGeometry.d.ts

@@ -0,0 +1,22 @@
+import { BuildStateData } from "../../../../Voxels/Functions/BuildStateData";
+import { CullingProcedureData, VoxelGeometryData, VoxelGeometryNodes } from "../../../../Voxels/Models/VoxelModel.types";
+import { CompiledGeomtryNodes } from "../../../../Mesher/Models/Nodes/Types/GeomtryNode.types";
+import { GeomtryInput } from "./GeomtryInput";
+import { VoxelGeometryTransform } from "Mesher/Geomtry/Geometry.types";
+export interface VoxelRuleGeometryData {
+    id: string;
+    cullingProcedure: CullingProcedureData;
+    ogData: VoxelGeometryData;
+    nodes: {
+        node: VoxelGeometryNodes;
+        tranform: VoxelGeometryTransform;
+    }[];
+}
+export declare class VoxelRuleGeometry {
+    id: string;
+    data: VoxelRuleGeometryData;
+    state: ReturnType<typeof BuildStateData>;
+    input: GeomtryInput;
+    compiled: CompiledGeomtryNodes[];
+    constructor(id: string, data: VoxelRuleGeometryData);
+}

package/Voxels/Models/Rules/Classes/VoxelRulesGeometry.js

@@ -0,0 +1,15 @@
+import { CompileGeomtryNodes } from "../Functions/Compile/CompileGeomtryNodes";
+import { GeomtryInput } from "./GeomtryInput";
+export class VoxelRuleGeometry {
+    id;
+    data;
+    state;
+    input;
+    compiled;
+    constructor(id, data) {
+        this.id = id;
+        this.data = data;
+        this.input = new GeomtryInput(data.ogData);
+        this.compiled = CompileGeomtryNodes(data.ogData.doNotBuildRules !== true, this.input, data.nodes);
+    }
+}

package/{Models → Voxels/Models}/Rules/Classes/VoxelRulesModel.d.ts

@@ -1,5 +1,6 @@
 import { VoxelModelConstructorData, VoxelModelData } from "../../VoxelModel.types";
-import { BuildStateData } from "../../../Voxels/Functions/BuildStateData";
+import { BuildStateData } from "../../../../Voxels/Functions/BuildStateData";
+import { VoxelStateSchemaData } from "../../../../Voxels/State/State.types";
 export declare class VoxelRulesModoel {
     data: VoxelModelData;
     states: Map<string, string[]>;
@@ -7,7 +8,7 @@ export declare class VoxelRulesModoel {
     stateData: ReturnType<typeof BuildStateData>;
     voxels: Map<string, VoxelModelConstructorData>;
     voxelModData: Map<string, {
-        modSchema: any[];
+        modSchema: VoxelStateSchemaData;
         modStateTree: any[];
         modPalette: any[];
         modRecord: Record<string, any>;

package/{Models → Voxels/Models}/Rules/Functions/BuildFinalInputs.d.ts

@@ -1,7 +1,5 @@
-import { VoxelFaceTransparentResultsIndex } from "../../Indexing/VoxelFaceTransparentResultsIndex";
 import { VoxelRulesModoel } from "../Classes/VoxelRulesModel";
 export declare function BuildFinalInputs(model: VoxelRulesModoel): {
     stateVoxelInputs: Record<string, any[]>;
-    transparentVoxelFaceIndexes: Record<string, VoxelFaceTransparentResultsIndex>;
     conditionalShapeStateVoxelInputs: Record<string, any[]>;
 };

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

@@ -0,0 +1,72 @@
+import { VoxelModelRuleBuilderRegister } from "../VoxelModelRuleBuilderRegister";
+export function BuildFinalInputs(model) {
+    const stateVoxelInputs = {};
+    const conditionalShapeStateVoxelInputs = {};
+    for (const [voxelId, voxel] of model.voxels) {
+        const voxelModData = model.voxelModData.get(voxelId);
+        for (const modVoxelInputKey in voxel.inputs) {
+            const modVoxelInput = voxel.inputs[modVoxelInputKey];
+            const baseStates = [];
+            for (const state in model.data.stateNodes) {
+                const geoNodes = [];
+                const stateNodes = model.data.stateNodes[state];
+                for (let n = 0; n < stateNodes.length; n++) {
+                    const node = stateNodes[n];
+                    const geo = VoxelModelRuleBuilderRegister.getGeomtryFromLink(node);
+                    if (!geo)
+                        throw new Error(`Geometry does not exist`);
+                    geo.input.resetDefaults();
+                    for (const geoArg in node.inputs) {
+                        const constructorArg = node.inputs[geoArg];
+                        if (geo.input.isArgString(constructorArg)) {
+                            const arg = constructorArg.replace("@", "");
+                            if (!Object.hasOwn(modVoxelInput, arg)) {
+                                console.warn(`Could not input for voxel ${voxelId} and geo ${geo.data.id}. ${geoArg} does not exist`);
+                                continue;
+                            }
+                            geo.input.proxy[geoArg] = modVoxelInput[arg];
+                            continue;
+                        }
+                        geo.input.proxy[geoArg] = constructorArg;
+                    }
+                    geoNodes[model.stateData.geometryLinkStateMap[state][n]] =
+                        geo.input.cloneArgs();
+                }
+                baseStates[model.stateData.stateRecord[state]] = geoNodes;
+            }
+            stateVoxelInputs[voxelId] ??= [];
+            stateVoxelInputs[voxelId][voxelModData.modRecord[modVoxelInputKey]] =
+                baseStates;
+            const condiotnalStates = [];
+            for (const state in model.data.conditonalNodes) {
+                const geoNodes = [];
+                const stateNodes = model.data.conditonalNodes[state];
+                for (let i = 0; i < stateNodes.length; i++) {
+                    const node = stateNodes[i];
+                    const geo = VoxelModelRuleBuilderRegister.getGeomtryFromLink(node);
+                    if (!geo)
+                        throw new Error(`Geometry does not exist`);
+                    geo.input.resetDefaults();
+                    for (const geoArg in node.inputs) {
+                        const constructorArg = node.inputs[geoArg];
+                        if (geo.input.isArgString(constructorArg)) {
+                            geo.input.proxy[geoArg] =
+                                modVoxelInput[constructorArg.replace("@", "")];
+                            continue;
+                        }
+                        geo.input.proxy[geoArg] = constructorArg;
+                    }
+                    geoNodes[i] = geo.input.cloneArgs();
+                }
+                condiotnalStates[model.stateData.condiotnalShapeStateRecord[state]] =
+                    geoNodes;
+            }
+            conditionalShapeStateVoxelInputs[voxelId] ??= [];
+            conditionalShapeStateVoxelInputs[voxelId][voxelModData.modRecord[modVoxelInputKey]] = condiotnalStates;
+        }
+    }
+    return {
+        stateVoxelInputs,
+        conditionalShapeStateVoxelInputs,
+    };
+}

package/Voxels/Models/Rules/Functions/BuildRules.d.ts

@@ -0,0 +1,7 @@
+import { StringPalette } from "../../../../Util/StringPalette";
+export declare function BuildRules(geoPalette: StringPalette): {
+    aoIndex: import("../../Indexing/AOOcclusionFaceIndex").AOOcclusionFaceIndexData;
+    faceCullIndex: import("../../Indexing/CulledOcclusionFaceIndex").CulledOcclusionFaceIndexData;
+    faceCullMap: number[][];
+    vertexHitMap: number[][][];
+};