@divinevoxel/vlox 0.0.0

package/VoxelModels/Rules/Functions/BuildStateData.js

@@ -0,0 +1,337 @@
+import { StateCompareOperationsMap, StateLogicOperationsMap, } from "../../State/State.types";
+import { StringPalette } from "../../../Interfaces/Data/StringPalette";
+import { VoxelModelManager } from "../VoxelModelManager";
+function bitsNeeded(n) {
+    if (n < 0)
+        throw new Error("Input must be a non-negative integer.");
+    let bits = 0;
+    while (n > 0) {
+        bits++;
+        n >>= 1;
+    }
+    return bits;
+}
+class StateTreeNode {
+    id;
+    children = new Map();
+    result;
+    constructor(id) {
+        this.id = id;
+    }
+    addChild(value, node) {
+        this.children.set(value, node);
+    }
+    getChild(value) {
+        return this.children.get(value);
+    }
+    toJSON() {
+        const childrenObj = {};
+        this.children.forEach((childNode, key) => {
+            childrenObj[key] = childNode.toJSON();
+        });
+        if (this.result != undefined)
+            return this.result;
+        return childrenObj;
+    }
+}
+function generateCombinations(length) {
+    const values = [0, 1];
+    function gen(currentCombination, remainingLength) {
+        if (remainingLength === 0) {
+            return [currentCombination];
+        }
+        let combinations = [];
+        for (let value of values) {
+            combinations.push(...gen([...currentCombination, value], remainingLength - 1));
+        }
+        return combinations;
+    }
+    return gen([], length);
+}
+function generateNestedCombinations(length, values) {
+    let combinationIndex = 0;
+    function createNestedArray(depth) {
+        if (depth === length) {
+            return combinationIndex++;
+        }
+        const nestedArray = [];
+        for (let i = 0; i < values.length; i++) {
+            nestedArray.push(createNestedArray(depth + 1));
+        }
+        return nestedArray;
+    }
+    return createNestedArray(0);
+}
+function addPathToTree(root, path, result) {
+    let currentNode = root;
+    for (let i = 0; i < path.length; i += 2) {
+        const key = path[i];
+        const value = path[i + 1];
+        let childNode = currentNode.getChild(key);
+        if (!childNode) {
+            childNode = new StateTreeNode(key);
+            currentNode.addChild(key, childNode);
+        }
+        let valueNode = childNode.getChild(value);
+        if (!valueNode) {
+            valueNode = new StateTreeNode(value);
+            childNode.addChild(value, valueNode);
+        }
+        currentNode = valueNode;
+    }
+    currentNode.result = result;
+}
+function reMapTree(schemaIdPalette, schemaValuePalette, baseObj, newObj, modelOrVodelId) {
+    for (const key in baseObj) {
+        if (key == "*")
+            continue;
+        const propertyIndex = schemaIdPalette.getNumberId(key);
+        const baseChild = baseObj[key];
+        const reMapedChildren = [];
+        const schemaValueIndex = schemaValuePalette.has(key)
+            ? schemaValuePalette.get(key)
+            : Number(key);
+        if (propertyIndex === undefined) {
+            throw new Error(`Unkown variable in state string ${key} | ${modelOrVodelId}`);
+        }
+        if (schemaValueIndex === undefined)
+            continue;
+        for (const value in baseChild) {
+            const propertyValue = baseChild[value];
+            const valueIndex = typeof value === "string" && typeof schemaValueIndex == "object"
+                ? schemaValueIndex.getNumberId(value)
+                : Number(value);
+            if (typeof propertyValue == "object") {
+                reMapedChildren[valueIndex] = reMapTree(schemaIdPalette, schemaValuePalette, baseChild[value], [], modelOrVodelId);
+                continue;
+            }
+            reMapedChildren[valueIndex] = baseChild[value];
+        }
+        newObj[propertyIndex] = reMapedChildren;
+    }
+    return newObj;
+}
+function buildSchemas(binaryNodes, relationNodes) {
+    const baseSchema = [];
+    const schemaIdPalette = new StringPalette();
+    const schemaValuePalette = new Map();
+    {
+        let bitIndex = 0;
+        for (const schemaNode of binaryNodes) {
+            schemaIdPalette.register(schemaNode.name);
+            const maxBits = bitsNeeded(schemaNode.type == "string"
+                ? Object.keys(schemaNode.values)
+                    .map((_) => Number(_))
+                    .sort((a, b) => a - b)
+                    .pop()
+                : schemaNode.maxValue);
+            const nodeData = {
+                id: schemaNode.name,
+                type: "binary",
+                index: bitIndex,
+                mask: (1 << maxBits) - 1,
+            };
+            bitIndex += maxBits;
+            if (schemaNode.type == "string") {
+                const valuePalette = new StringPalette();
+                for (const vIndex in schemaNode.values) {
+                    const vValue = schemaNode.values[vIndex];
+                    valuePalette.register(vValue);
+                }
+                schemaValuePalette.set(schemaNode.name, valuePalette);
+                nodeData.valuePalette = valuePalette._palette;
+            }
+            baseSchema.push(nodeData);
+        }
+    }
+    {
+        for (const schemaNode of relationNodes) {
+            schemaIdPalette.register(schemaNode.name);
+            baseSchema.push({
+                id: schemaNode.name,
+                type: "relation",
+                conditions: schemaNode.conditions,
+            });
+            const valuePalette = new StringPalette();
+            valuePalette.register("false");
+            valuePalette.register("true");
+            schemaValuePalette.set(schemaNode.name, valuePalette);
+        }
+    }
+    return {
+        baseSchema,
+        schemaIdPalette,
+        schemaValuePalette,
+    };
+}
+export function BuildStateData(model, geoPalette) {
+    const data = model.data;
+    const { baseSchema, schemaIdPalette, schemaValuePalette } = buildSchemas(data.shapeStateSchema, data.relationsSchema);
+    const geometryLinkPalette = new StringPalette();
+    //maps geo link ids to geomtry ids
+    const geometryLinkStateMap = [];
+    const log = model.data.id == "dve_simple_stair";
+    //add geomtry from main shape states
+    for (const key in data.shapeStatesNodes) {
+        const nodeData = data.shapeStatesNodes[key];
+        for (const node of nodeData) {
+            if (geometryLinkPalette.isRegistered(node.id))
+                continue;
+            const linkId = geometryLinkPalette.register(node.id);
+            geometryLinkStateMap[linkId] = geoPalette.getNumberId(VoxelModelManager.getGeometryLinkId(node));
+        }
+    }
+    //add geomtry from condiotnal  shape states
+    for (const key in data.shapeStatesConditonalNodes) {
+        const nodeData = data.shapeStatesConditonalNodes[key];
+        for (const node of nodeData) {
+            if (geometryLinkPalette.isRegistered(node.id))
+                continue;
+            const linkId = geometryLinkPalette.register(node.id);
+            geometryLinkStateMap[linkId] = geoPalette.getNumberId(VoxelModelManager.getGeometryLinkId(node));
+        }
+    }
+    const shapeStateRelativeGeometryMap = [];
+    const relativeGeometryByteIndexMap = [];
+    //build state trees
+    const shapeStateTree = new StateTreeNode("root");
+    const shapeStateGeoLinkPalette = [];
+    const shapeStateGeometryPalette = [];
+    let relativeGeoId = 0;
+    let relativeByteCount = 0;
+    const shapeStateRecord = {};
+    for (const key in data.shapeStatesNodes) {
+        shapeStateGeoLinkPalette.push(data.shapeStatesNodes[key].map((_) => geometryLinkPalette.getNumberId(_.id)));
+        shapeStateGeometryPalette.push(data.shapeStatesNodes[key].map((_) => geoPalette.getNumberId(VoxelModelManager.getGeometryLinkId(_))));
+        shapeStateRecord[key] = shapeStateGeometryPalette.length - 1;
+        shapeStateRelativeGeometryMap[shapeStateRecord[key]] ??= [];
+        const nodeData = data.shapeStatesNodes[key];
+        for (const node of nodeData) {
+            shapeStateRelativeGeometryMap[shapeStateRecord[key]][geoPalette.getNumberId(VoxelModelManager.getGeometryLinkId(node))] = relativeGeoId;
+            relativeGeometryByteIndexMap[relativeGeoId] = relativeByteCount;
+            relativeGeoId++;
+            relativeByteCount += Math.ceil(VoxelModelManager.getGeomtryFromLink(node).faceCount / 8);
+        }
+        addPathToTree(shapeStateTree, key
+            .split(",")
+            .map((pair) => pair.split("="))
+            .flat(), shapeStateGeoLinkPalette.length - 1);
+    }
+    const condiotnalShapeStateRelativeGeometryMap = [];
+    const condiotnalShapeStateNodePalette = [];
+    const condiotnalShapeStateGeometryPalette = [];
+    const condiotnalShapeStateNodeRecord = {};
+    const condiotnalStatements = [];
+    const compareOperations = Object.keys(StateCompareOperationsMap);
+    for (const key in data.shapeStatesConditonalNodes) {
+        condiotnalShapeStateNodePalette.push(data.shapeStatesConditonalNodes[key].map((_) => geometryLinkPalette.getNumberId(_.id)));
+        condiotnalShapeStateGeometryPalette.push(data.shapeStatesConditonalNodes[key].map((_) => geoPalette.getNumberId(VoxelModelManager.getGeometryLinkId(_))));
+        condiotnalShapeStateNodeRecord[key] =
+            condiotnalShapeStateGeometryPalette.length - 1;
+        condiotnalShapeStateRelativeGeometryMap[condiotnalShapeStateNodeRecord[key]] ??= [];
+        const nodeData = data.shapeStatesConditonalNodes[key];
+        for (const node of nodeData) {
+            condiotnalShapeStateRelativeGeometryMap[condiotnalShapeStateNodeRecord[key]][geoPalette.getNumberId(VoxelModelManager.getGeometryLinkId(node))] =
+                relativeGeoId;
+            relativeGeometryByteIndexMap[relativeGeoId] = relativeByteCount;
+            relativeGeoId++;
+            relativeByteCount += Math.ceil(VoxelModelManager.getGeomtryFromLink(node).faceCount / 8);
+        }
+        const statement = [];
+        const nodes = key.split(" ");
+        let mode = "node";
+        for (const node of nodes) {
+            if (!node)
+                continue;
+            if (mode == "node") {
+                mode = "operation";
+                for (const op of compareOperations) {
+                    if (node.includes(op)) {
+                        const [schemaId, value] = node.split(op);
+                        statement.push([
+                            schemaIdPalette.getNumberId(schemaId),
+                            StateCompareOperationsMap[op],
+                            !schemaValuePalette.has(schemaId)
+                                ? schemaValuePalette.get(schemaId).getNumberId(value)
+                                : Number(value),
+                        ]);
+                        break;
+                    }
+                }
+                continue;
+            }
+            if (mode == "operation") {
+                mode = "node";
+                statement.push(StateLogicOperationsMap[node]);
+            }
+        }
+        condiotnalStatements.push(statement);
+    }
+    const condiotnalNodeStateTree = generateNestedCombinations(condiotnalStatements.length, [0, 1]);
+    const allCombinations = generateCombinations(condiotnalStatements.length);
+    const condiotanlStatePalette = [];
+    const condiotanlGeometryStatePalette = [];
+    for (const combo of allCombinations) {
+        const newStateCombo = [];
+        const newGeoCombo = [];
+        for (let i = 0; i < combo.length; i++) {
+            if (combo[i] == 0) {
+                newStateCombo[i] = [];
+                newGeoCombo[i] = [];
+                continue;
+            }
+            newStateCombo[i] = condiotnalShapeStateNodePalette[i];
+            newGeoCombo[i] = condiotnalShapeStateGeometryPalette[i];
+        }
+        condiotanlStatePalette.push(newStateCombo);
+        condiotanlGeometryStatePalette.push(newGeoCombo);
+    }
+    const shapeStateTreeData = shapeStateTree.toJSON();
+    const newShapeStateTree = [];
+    reMapTree(schemaIdPalette, schemaValuePalette, shapeStateTreeData, newShapeStateTree, model.data.id);
+    for (const [voxelId, voxelData] of model.voxels) {
+        const modeStateTree = new StateTreeNode("root");
+        const modStatePalette = [];
+        const modStateRecord = {};
+        const { baseSchema, schemaIdPalette, schemaValuePalette } = buildSchemas(voxelData.modSchema || [], voxelData.modRelationSchema || []);
+        for (const key in voxelData.inputs) {
+            modStatePalette.push(voxelData.inputs[key]);
+            modStateRecord[key] = modStatePalette.length - 1;
+            addPathToTree(modeStateTree, key
+                .split(",")
+                .map((pair) => pair.split("="))
+                .flat(), modStatePalette.length - 1);
+        }
+        const modTreeData = modeStateTree.toJSON();
+        const newModTree = [];
+        reMapTree(schemaIdPalette, schemaValuePalette, modTreeData, newModTree, voxelId);
+        model.voxelModData.set(voxelId, {
+            modSchema: baseSchema,
+            modPalette: modStatePalette,
+            modRecord: modStateRecord,
+            modStateTree: newModTree,
+        });
+    }
+    const finalData = {
+        schema: baseSchema,
+        shapeStateGeometryPalette,
+        condiotnalShapeStateGeometryPalette,
+        shapeStateTree: newShapeStateTree,
+        geometryLinkPalette: geometryLinkPalette._map,
+        geometryLinkStateMap,
+        relativeByteCount,
+        shapeStatePalette: shapeStateGeoLinkPalette,
+        shapeStateRecord,
+        condiotnalNodeStateTree,
+        condiotnalStatements,
+        condiotnalShapeStatePalette: condiotnalShapeStateNodePalette,
+        condiotnalShapeStateRecord: condiotnalShapeStateNodeRecord,
+        condiotanlStatePalette,
+        condiotanlGeometryStatePalette,
+        shapeStateRelativeGeometryMap,
+        relativeGeometryByteIndexMap,
+        condiotnalShapeStateRelativeGeometryMap,
+    };
+    model.stateData = finalData;
+    return finalData;
+}

package/VoxelModels/Rules/Functions/GetOcclusionFaces.d.ts

@@ -0,0 +1,4 @@
+import { OcclusionFaceContainer } from "../Classes/OcclusionFace";
+import { VoxelRuleGeometry } from "../Classes/VoxelRulesGeometry";
+import { PrcoessedVoxelGeometryNodes } from "../../VoxelModelRules.types";
+export declare function GetOcclusionFaces(parentId: string, geometry: VoxelRuleGeometry, data: PrcoessedVoxelGeometryNodes[]): OcclusionFaceContainer;

package/VoxelModels/Rules/Functions/GetOcclusionFaces.js

@@ -0,0 +1,112 @@
+import { Vector3Like } from "@amodx/math";
+import { OcclusionFlatQuadFace, OcclusionFaceContainer, OcclusionQuadFace, } from "../Classes/OcclusionFace";
+import { VoxelFaces } from "../../../Math";
+import { TransformBox, TransformQuad } from "../../Shared/Transform";
+import { Quad } from "@amodx/meshing/Classes/Quad";
+export function GetOcclusionFaces(parentId, geometry, data) {
+    const faceContainer = new OcclusionFaceContainer();
+    let vertexCount = 0;
+    let faceCount = 0;
+    let nodeId = 0;
+    for (const prcoessedNode of data) {
+        if (prcoessedNode.node.type == "box") {
+            const keys = Object.keys(prcoessedNode.tranform);
+            if (!keys.length ||
+                (keys.length == 1 &&
+                    keys[0] == "position" &&
+                    prcoessedNode.tranform.position)) {
+                const [start, end] = prcoessedNode.node.points.map((_) => Vector3Like.Create(...Vector3Like.AddArray(_, prcoessedNode.tranform.position || [0, 0, 0])));
+                faceContainer.addFace(new OcclusionFlatQuadFace(parentId, nodeId, "up", vertexCount + VoxelFaces.Up * 4, VoxelFaces.Up + faceCount, [start.x, end.y, start.z], [end.x, end.y, end.z]));
+                faceContainer.addFace(new OcclusionFlatQuadFace(parentId, nodeId, "down", vertexCount + VoxelFaces.Down * 4, VoxelFaces.Down + faceCount, [start.x, start.y, start.z], [end.x, start.y, end.z]));
+                faceContainer.addFace(new OcclusionFlatQuadFace(parentId, nodeId, "north", vertexCount + VoxelFaces.North * 4, VoxelFaces.North + faceCount, [start.x, start.y, end.z], [end.x, end.y, end.z]));
+                faceContainer.addFace(new OcclusionFlatQuadFace(parentId, nodeId, "south", vertexCount + VoxelFaces.South * 4, VoxelFaces.South + faceCount, [start.x, start.y, start.z], [end.x, end.y, start.z]));
+                faceContainer.addFace(new OcclusionFlatQuadFace(parentId, nodeId, "east", vertexCount + VoxelFaces.East * 4, VoxelFaces.East + faceCount, [end.x, start.y, start.z], [end.x, end.y, end.z]));
+                faceContainer.addFace(new OcclusionFlatQuadFace(parentId, nodeId, "west", vertexCount + VoxelFaces.West * 4, VoxelFaces.West + faceCount, [start.x, start.y, start.z], [start.x, end.y, end.z]));
+            }
+            else {
+                const [start, end] = prcoessedNode.node.points.map((_) => Vector3Like.Create(..._));
+                const quadPoints = [
+                    //top
+                    [
+                        [end.x, end.y, end.z],
+                        [start.x, end.y, end.z],
+                        [start.x, end.y, start.z],
+                        [end.x, end.y, start.z],
+                    ],
+                    //bottom
+                    [
+                        [start.x, start.y, end.z],
+                        [end.x, start.y, end.z],
+                        [end.x, start.y, start.z],
+                        [start.x, start.y, start.z],
+                    ],
+                    //north
+                    [
+                        [start.x, end.y, end.z],
+                        [end.x, end.y, end.z],
+                        [end.x, start.y, end.z],
+                        [start.x, start.y, end.z],
+                    ],
+                    //south
+                    [
+                        [end.x, end.y, start.z],
+                        [start.x, end.y, start.z],
+                        [start.x, start.y, start.z],
+                        [end.x, start.y, start.z],
+                    ],
+                    //east
+                    [
+                        [end.x, end.y, end.z],
+                        [end.x, end.y, start.z],
+                        [end.x, start.y, start.z],
+                        [end.x, start.y, end.z],
+                    ],
+                    //west
+                    [
+                        [start.x, end.y, start.z],
+                        [start.x, end.y, end.z],
+                        [start.x, start.y, end.z],
+                        [start.x, start.y, start.z],
+                    ],
+                ];
+                const tranformed = TransformBox(quadPoints.map((_) => Quad.Create(_)), prcoessedNode.tranform);
+                faceContainer.addFace(new OcclusionQuadFace(parentId, nodeId, vertexCount + VoxelFaces.Up * 4, faceCount + VoxelFaces.Up, tranformed[VoxelFaces.Up].positions
+                    .getAsArray()
+                    .map((_) => Vector3Like.ToArray(_))));
+                faceContainer.addFace(new OcclusionQuadFace(parentId, nodeId, vertexCount + VoxelFaces.Down * 4, faceCount + VoxelFaces.Down, tranformed[VoxelFaces.Down].positions
+                    .getAsArray()
+                    .map((_) => Vector3Like.ToArray(_))));
+                faceContainer.addFace(new OcclusionQuadFace(parentId, nodeId, vertexCount + VoxelFaces.North * 4, faceCount + VoxelFaces.North, tranformed[VoxelFaces.North].positions
+                    .getAsArray()
+                    .map((_) => Vector3Like.ToArray(_))));
+                faceContainer.addFace(new OcclusionQuadFace(parentId, nodeId, vertexCount + VoxelFaces.South * 4, faceCount + VoxelFaces.South, tranformed[VoxelFaces.South].positions
+                    .getAsArray()
+                    .map((_) => Vector3Like.ToArray(_))));
+                faceContainer.addFace(new OcclusionQuadFace(parentId, nodeId, vertexCount + VoxelFaces.East * 4, faceCount + VoxelFaces.East, tranformed[VoxelFaces.East].positions
+                    .getAsArray()
+                    .map((_) => Vector3Like.ToArray(_))));
+                faceContainer.addFace(new OcclusionQuadFace(parentId, nodeId, vertexCount + VoxelFaces.West * 4, faceCount + VoxelFaces.West, tranformed[VoxelFaces.West].positions
+                    .getAsArray()
+                    .map((_) => Vector3Like.ToArray(_))));
+            }
+            faceCount += 6;
+            vertexCount += 6 * 4;
+        }
+        if (prcoessedNode.node.type == "quad") {
+            const quad = TransformQuad(Quad.Create(prcoessedNode.node.points), prcoessedNode.tranform);
+            faceContainer.addFace(new OcclusionQuadFace(parentId, nodeId, vertexCount, faceCount, quad.positions.getAsArray().map((_) => Vector3Like.ToArray(_))));
+            faceCount++;
+            vertexCount += 4;
+        }
+        nodeId++;
+        /*     if (node.type == "plane") {
+          if (node.rotation) continue;
+          const [start, end] = node.points;
+    
+          planes.addPlane(new OcclusionQuad(node.direction, start, end));
+        } */
+    }
+    geometry.vertexCount = vertexCount;
+    geometry.faceCount = faceCount;
+    return faceContainer;
+}

package/VoxelModels/Rules/VoxelModelManager.d.ts

@@ -0,0 +1,18 @@
+import { StringPalette } from "../../Interfaces/Data/StringPalette";
+import { VoxelGeometryData, VoxelGeometryLinkData, VoxelModelConstructorData, VoxelModelData } from "../VoxelModel.types";
+import { VoxelRuleGeometry } from "./Classes/VoxelRulesGeometry";
+import { VoxelRulesModoel } from "./Classes/VoxelRulesModel";
+export declare class VoxelModelManager {
+    static geometryPalette: StringPalette;
+    static getGeometryLinkId: (node: VoxelGeometryLinkData) => string;
+    static voxels: Map<string, {
+        id: string;
+        data: VoxelModelConstructorData;
+    }[]>;
+    static geometry: Map<string, VoxelRuleGeometry>;
+    static models: Map<string, VoxelRulesModoel>;
+    static registerGeometry(...geometry: VoxelGeometryData[]): void;
+    static getGeomtryFromLink(link: VoxelGeometryLinkData): VoxelRuleGeometry | undefined;
+    static registerModels(...models: VoxelModelData[]): void;
+    static registerVoxel(id: string, data: VoxelModelConstructorData): void;
+}

package/VoxelModels/Rules/VoxelModelManager.js

@@ -0,0 +1,80 @@
+import { StringPalette } from "../../Interfaces/Data/StringPalette";
+import { VoxelRuleGeometry } from "./Classes/VoxelRulesGeometry";
+import { VoxelRulesModoel } from "./Classes/VoxelRulesModel";
+const addGeo = (modelId, stateId, nodes) => {
+    const registred = [];
+    for (const geoLinkNode of nodes) {
+        const geo = VoxelModelManager.geometry.get(geoLinkNode.geometryId);
+        if (!geo)
+            throw new Error(`Geometry ${geoLinkNode.geometryId} is not registered.`);
+        const newId = getGeometryLinkId(geoLinkNode);
+        if (VoxelModelManager.geometry.has(newId))
+            continue;
+        registred.push([stateId, newId]);
+        if (!VoxelModelManager.geometryPalette.isRegistered(newId))
+            VoxelModelManager.geometryPalette.register(newId);
+        const newData = structuredClone(geo.data);
+        newData.nodes = newData.nodes.map((_) => ({
+            ..._,
+            tranform: {
+                position: geoLinkNode.position,
+                scale: geoLinkNode.scale,
+                rotation: geoLinkNode.rotation,
+                rotationPivot: geoLinkNode.rotationPivot,
+                flip: geoLinkNode.flip,
+            },
+        }));
+        VoxelModelManager.geometry.set(newId, new VoxelRuleGeometry(newId, newData, structuredClone(geoLinkNode.position), structuredClone(geoLinkNode.scale), structuredClone(geoLinkNode.rotation)));
+        continue;
+    }
+    return registred;
+};
+const getGeometryLinkId = (node) => {
+    return `${node.geometryId}${node.position ? `-p${node.position.toString()}` : ""}${node.rotation ? `-r${node.rotation.toString()}` : ""}${node.scale ? `-s${node.scale.toString()}` : ""}`.trim();
+};
+export class VoxelModelManager {
+    static geometryPalette = new StringPalette();
+    static getGeometryLinkId = getGeometryLinkId;
+    static voxels = new Map();
+    static geometry = new Map();
+    static models = new Map();
+    static registerGeometry(...geometry) {
+        for (const geo of geometry) {
+            if (!this.geometryPalette.isRegistered(geo.id))
+                this.geometryPalette.register(geo.id);
+            this.geometry.set(geo.id, new VoxelRuleGeometry(geo.id, {
+                ogData: geo,
+                id: geo.id,
+                nodes: geo.nodes.map((node) => ({
+                    node,
+                    tranform: {},
+                })),
+            }));
+        }
+    }
+    static getGeomtryFromLink(link) {
+        return this.geometry.get(getGeometryLinkId(link));
+    }
+    static registerModels(...models) {
+        for (const model of models) {
+            const rulesModel = new VoxelRulesModoel(model);
+            this.models.set(model.id, rulesModel);
+            for (const stateId in model.shapeStatesNodes) {
+                const nodes = model.shapeStatesNodes[stateId];
+                addGeo(model.id, stateId, nodes).forEach((_) => rulesModel.registerShapeState(..._));
+            }
+            for (const stateId in model.shapeStatesConditonalNodes) {
+                const nodes = model.shapeStatesConditonalNodes[stateId];
+                addGeo(model.id, stateId, nodes).forEach((_) => rulesModel.registerCondiotnalNode(..._));
+            }
+        }
+    }
+    static registerVoxel(id, data) {
+        let voxelModels = this.voxels.get(data.id);
+        if (!voxelModels) {
+            voxelModels = [];
+            this.voxels.set(data.id, voxelModels);
+        }
+        voxelModels.push({ id, data });
+    }
+}

package/VoxelModels/Shared/Transform.d.ts

@@ -0,0 +1,4 @@
+import { Quad } from "@amodx/meshing/Classes/Quad";
+import { VoxelGeometryTransform } from "../VoxelModelRules.types";
+export declare function TransformQuad(quad: Quad, transform: VoxelGeometryTransform): Quad;
+export declare function TransformBox(quads: [Quad, Quad, Quad, Quad, Quad, Quad], transform: VoxelGeometryTransform): [Quad, Quad, Quad, Quad, Quad, Quad];