@divinevoxel/vlox 0.0.78 → 0.0.79

package/Voxels/Functions/BuildStateData.js

@@ -1,327 +0,0 @@
-import { StateCompareOperationsMap, StateLogicOperationsMap, } from "../State/State.types";
-import { StringPalette } from "../../Util/StringPalette";
-import { VoxelModelRuleBuilderRegister } from "../Models/Rules/VoxelModelRuleBuilderRegister";
-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) {
-            console.error(baseObj);
-            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" && !Array.isArray(propertyValue)) {
-                reMapedChildren[valueIndex] = reMapTree(schemaIdPalette, schemaValuePalette, baseChild[value], [], modelOrVodelId);
-                continue;
-            }
-            reMapedChildren[valueIndex] = baseChild[value];
-        }
-        newObj[propertyIndex] = reMapedChildren;
-    }
-    return newObj;
-}
-function buildSchemas(binaryNodes, relationNodes) {
-    const baseSchema = {
-        binary: [],
-        relational: [],
-    };
-    const schemaIdPalette = new StringPalette();
-    const schemaValuePalette = new Map();
-    for (const schemaNode of binaryNodes) {
-        schemaIdPalette.register(schemaNode.name);
-        if (schemaNode.values) {
-            schemaValuePalette.set(schemaNode.name, new StringPalette(schemaNode.values));
-        }
-        baseSchema.binary.push(schemaNode);
-    }
-    for (const schemaNode of relationNodes) {
-        schemaIdPalette.register(schemaNode.name);
-        baseSchema.relational.push(schemaNode);
-        schemaValuePalette.set(schemaNode.name, new StringPalette(["false", "true"]));
-    }
-    return {
-        baseSchema,
-        schemaIdPalette,
-        schemaValuePalette,
-    };
-}
-export function BuildStateData(model, geoPalette) {
-    const data = model.data;
-    const { baseSchema, schemaIdPalette, schemaValuePalette } = buildSchemas(data.stateSchema, data.relationsSchema);
-    //maps geo link ids to geomtry ids
-    const geometryLinkStateMap = {};
-    //add geomtry from main shape states
-    for (const key in data.stateNodes) {
-        const nodeData = data.stateNodes[key];
-        for (let i = 0; i < nodeData.length; i++) {
-            geometryLinkStateMap[key] ??= {};
-            const node = nodeData[i];
-            geometryLinkStateMap[key][i] ??= geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node));
-        }
-    }
-    //add geomtry from condiotnal  shape states
-    for (const key in data.conditonalNodes) {
-        const nodeData = data.conditonalNodes[key];
-        for (let i = 0; i < nodeData.length; i++) {
-            geometryLinkStateMap[key] ??= {};
-            const node = nodeData[i];
-            geometryLinkStateMap[key][i] ??= geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node));
-        }
-    }
-    const stateRelativeGeometryMap = [];
-    const relativeGeometryByteIndexMap = [];
-    //build state trees
-    const stateTree = new StateTreeNode("root");
-    const stateGeoLinkPalette = [];
-    const stateGeometryPalette = [];
-    let relativeGeoId = 0;
-    let relativeByteCount = 0;
-    const stateRecord = {};
-    for (const key in data.stateNodes) {
-        stateGeoLinkPalette.push(data.stateNodes[key].map((_, index) => geometryLinkStateMap[key][index]));
-        stateGeometryPalette.push(data.stateNodes[key].map((_) => geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(_))));
-        stateRecord[key] = stateGeometryPalette.length - 1;
-        stateRelativeGeometryMap[stateRecord[key]] ??= [];
-        const nodeData = data.stateNodes[key];
-        for (const node of nodeData) {
-            stateRelativeGeometryMap[stateRecord[key]][geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node))] = relativeGeoId;
-            relativeGeometryByteIndexMap[relativeGeoId] = relativeByteCount;
-            relativeGeoId++;
-        }
-        addPathToTree(stateTree, key
-            .split(",")
-            .map((pair) => pair.split("="))
-            .flat(), stateGeoLinkPalette.length - 1);
-    }
-    const condiotnalShapeStateRelativeGeometryMap = [];
-    const condiotnalShapeStateNodePalette = [];
-    const condiotnalShapeStateGeometryPalette = [];
-    const condiotnalShapeStateNodeRecord = {};
-    const condiotnalStatements = [];
-    const compareOperations = Object.keys(StateCompareOperationsMap);
-    for (const key in data.conditonalNodes) {
-        condiotnalShapeStateNodePalette.push(data.conditonalNodes[key].map((_, index) => geometryLinkStateMap[key][index]));
-        condiotnalShapeStateGeometryPalette.push(data.conditonalNodes[key].map((_) => geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(_))));
-        condiotnalShapeStateNodeRecord[key] =
-            condiotnalShapeStateGeometryPalette.length - 1;
-        condiotnalShapeStateRelativeGeometryMap[condiotnalShapeStateNodeRecord[key]] ??= [];
-        const nodeData = data.conditonalNodes[key];
-        for (const node of nodeData) {
-            condiotnalShapeStateRelativeGeometryMap[condiotnalShapeStateNodeRecord[key]][geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node))] = relativeGeoId;
-            relativeGeometryByteIndexMap[relativeGeoId] = relativeByteCount;
-            relativeGeoId++;
-        }
-        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 stateTreeData = stateTree.toJSON();
-    const newShapeStateTree = [];
-    reMapTree(schemaIdPalette, schemaValuePalette, stateTreeData, newShapeStateTree, model.data.id);
-    const modelEffects = [];
-    const tagEffects = [];
-    if (model.data.effects) {
-        for (const effect of model.data.effects) {
-            const tagStateTree = new StateTreeNode("root");
-            const treePalette = [];
-            for (const key in effect.values) {
-                const nodeData = effect.values[key];
-                treePalette.push(nodeData);
-                addPathToTree(tagStateTree, key
-                    .split(",")
-                    .map((pair) => pair.split("="))
-                    .flat(), treePalette.length - 1);
-            }
-            const tagStateTreeData = tagStateTree.toJSON();
-            const newTagStateTree = [];
-            reMapTree(schemaIdPalette, schemaValuePalette, tagStateTreeData, newTagStateTree, model.data.id);
-            if (effect.type == "tag") {
-                tagEffects.push({
-                    type: "tag",
-                    tagId: effect.tagId,
-                    tree: newTagStateTree,
-                    treePalette,
-                });
-            }
-            if (effect.type == "fx-points") {
-                modelEffects.push({
-                    type: "fx-points",
-                    effectId: effect.effectId,
-                    tree: newTagStateTree,
-                    treePalette,
-                });
-            }
-        }
-    }
-    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,
-        effects: modelEffects,
-        stateGeometryPalette: stateGeometryPalette,
-        condiotnalShapeStateGeometryPalette,
-        stateTree: newShapeStateTree,
-        geometryLinkStateMap,
-        statePalette: stateGeoLinkPalette,
-        stateRecord: stateRecord,
-        condiotnalNodeStateTree,
-        condiotnalStatements,
-        condiotnalStatePalette: condiotnalShapeStateNodePalette,
-        condiotnalShapeStateRecord: condiotnalShapeStateNodeRecord,
-        condiotanlStatePalette,
-        condiotanlGeometryStatePalette,
-        stateRelativeGeometryMap: stateRelativeGeometryMap,
-        relativeGeometryByteIndexMap,
-        condiotnalShapeStateRelativeGeometryMap,
-    };
-    model.stateData = finalData;
-    return finalData;
-}

package/Voxels/Models/CompiledVoxelModel.types.d.ts

@@ -1,46 +0,0 @@
-import { AOOcclusionFaceIndexData } from "../Models/Indexing/AOOcclusionFaceIndex";
-import { CulledOcclusionFaceIndexData } from "../Models/Indexing/CulledOcclusionFaceIndex";
-import { VoxelStateSchemaData, StateLogicStatement } from "../State/State.types";
-import { CullingProcedureData } from "../Models/VoxelModel.types";
-import { VoxelEffectSyncData } from "../Effects/VoxelEffects.types";
-import { CompiledGeomtryNodes } from "../../Mesher/Voxels/Models/Nodes/Types/GeomtryNode.types";
-export type CompiledVoxelGeometrySyncData = {
-    id: string;
-    cullingProcedure: CullingProcedureData;
-    nodes: CompiledGeomtryNodes[];
-};
-export interface CompiledVoxelModelData {
-    id: string;
-    schema: VoxelStateSchemaData;
-    effects: VoxelEffectSyncData[];
-    stateTree: any[];
-    stateMap: number[][];
-    stateGeometryMap: number[][];
-    stateRelativeGeometryMap: number[][];
-    relativeGeometryByteIndexMap: number[];
-    condiotnalStatements: StateLogicStatement[];
-    condiotnalStateMap: number[][];
-    condiotnalShapeStateMap: number[][][];
-    condiotanlGeometryStatePalette: number[][][];
-    condiotnalShapeStateRelativeGeometryMap: number[][];
-    condiotnalStateTree: any[];
-}
-export interface CompiledVoxelModelInputData {
-    id: string;
-    materialId: string;
-    modelId: string;
-    modSchema: VoxelStateSchemaData;
-    modStateTree: any[];
-    baseGeometryInputMap: any[][];
-    condiotnalGeometryInputMap: any[][];
-}
-export interface FinalCompiledVoxelModelData {
-    geometryPalette: string[];
-    geometry: CompiledVoxelGeometrySyncData[];
-    aoIndex: AOOcclusionFaceIndexData;
-    faceCullIndex: CulledOcclusionFaceIndexData;
-    vertexHitMap: number[][][];
-    faceCullMap: number[][];
-    models: CompiledVoxelModelData[];
-    voxels: CompiledVoxelModelInputData[];
-}

package/Voxels/Models/Indexing/AOOcclusionFaceIndex.js

@@ -1,28 +0,0 @@
-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.js

@@ -1,27 +0,0 @@
-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

@@ -1,16 +0,0 @@
-import { VoxelGeometryData, VoxelModelConstructorData } from "../../VoxelModel.types";
-export declare class GeomtryInput {
-    geomtry: VoxelGeometryData;
-    inputObservers: Map<string, ((data: any) => void)[]>;
-    orginalArgs: any[];
-    args: any[];
-    get arguments(): Record<string, import("../../VoxelModel.types").VoxelGeometryTextureArgument | import("../../VoxelModel.types").VoxelGeometryArgumentAliasList | import("../../VoxelModel.types").VoxelGeometryBooleanArgument | import("../../VoxelModel.types").VoxelGeometryIntArgument | import("../../VoxelModel.types").VoxelGeometryFloatArgument | import("../../VoxelModel.types").VoxelGeometryBoxUVArgument | import("../../VoxelModel.types").VoxelGeometryUVArgument | import("../../VoxelModel.types").VoxelGeometryVector3Argument>;
-    proxy: Record<string, any>;
-    isArgString(data: any): boolean;
-    cloneArgs(): any[];
-    resetDefaults(): void;
-    currentModelState: string;
-    currentModel: VoxelModelConstructorData;
-    constructor(geomtry: VoxelGeometryData);
-    onInput(id: string, subscribe: (data: any) => any): number;
-}

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

@@ -1,85 +0,0 @@
-import { TextureManager } from "../../../../Textures/TextureManager";
-export class GeomtryInput {
-    geomtry;
-    inputObservers = new Map();
-    orginalArgs = [];
-    args = [];
-    get arguments() {
-        return this.geomtry.arguments;
-    }
-    proxy = {};
-    isArgString(data) {
-        if (typeof data !== "string")
-            return false;
-        return data[0] == "@";
-    }
-    cloneArgs() {
-        return structuredClone(this.args);
-    }
-    resetDefaults() {
-        this.args = structuredClone(this.orginalArgs);
-    }
-    currentModelState;
-    currentModel;
-    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 = structuredClone({
-                                ...textureId,
-                            });
-                            if (procedureData.texture) {
-                                let texture = procedureData.texture;
-                                if (typeof texture == "string" && texture[0] === "@") {
-                                    const input = texture.replace("@", "");
-                                    texture =
-                                        this.currentModel.inputs["*"]?.[input] ??
-                                            this.currentModel.inputs[this.currentModelState][input];
-                                }
-                                procedureData.texture =
-                                    TextureManager.getTexture("dve_voxel")?.getTextureIndex(texture);
-                            }
-                            if (procedureData.textureRecrod) {
-                                for (const key in procedureData.textureRecrod) {
-                                    let texture = procedureData.textureRecrod[key];
-                                    if (typeof texture == "string" && texture[0] === "@") {
-                                        const input = texture.replace("@", "");
-                                        texture =
-                                            this.currentModel.inputs["*"]?.[input] ??
-                                                this.currentModel.inputs[this.currentModelState][input];
-                                    }
-                                    procedureData.textureRecrod[key] =
-                                        TextureManager.getTexture("dve_voxel")?.getTextureIndex(texture);
-                                }
-                            }
-                            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/VoxelRulesGeometry.d.ts

@@ -1,22 +0,0 @@
-import { BuildStateData } from "../../../../Voxels/Functions/BuildStateData";
-import { CullingProcedureData, VoxelGeometryData, VoxelGeometryNodes } from "../../../../Voxels/Models/VoxelModel.types";
-import { CompiledGeomtryNodes } from "../../../../Mesher/Voxels/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

@@ -1,15 +0,0 @@
-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/Voxels/Models/Rules/Classes/VoxelRulesModel.d.ts

@@ -1,19 +0,0 @@
-import { VoxelModelConstructorData, VoxelModelData } from "../../VoxelModel.types";
-import { BuildStateData } from "../../../../Voxels/Functions/BuildStateData";
-import { VoxelStateSchemaData } from "../../../../Voxels/State/State.types";
-export declare class VoxelRulesModoel {
-    data: VoxelModelData;
-    states: Map<string, string[]>;
-    conditionalNodes: Map<string, string[]>;
-    stateData: ReturnType<typeof BuildStateData>;
-    voxels: Map<string, VoxelModelConstructorData>;
-    voxelModData: Map<string, {
-        modSchema: VoxelStateSchemaData;
-        modStateTree: any[];
-        modPalette: any[];
-        modRecord: Record<string, any>;
-    }>;
-    constructor(data: VoxelModelData);
-    registerShapeState(id: string, geomtryId: string): void;
-    registerCondiotnalNode(id: string, geomtryId: string): void;
-}

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

@@ -1,29 +0,0 @@
-export class VoxelRulesModoel {
-    data;
-    states = new Map();
-    conditionalNodes = new Map();
-    stateData;
-    voxels = new Map();
-    voxelModData = new Map();
-    constructor(data) {
-        this.data = data;
-    }
-    registerShapeState(id, geomtryId) {
-        let stateArray = this.states.get(id);
-        if (!stateArray) {
-            stateArray = [];
-            this.states.set(id, stateArray);
-        }
-        if (!stateArray.find((_) => _ == geomtryId))
-            stateArray.push(geomtryId);
-    }
-    registerCondiotnalNode(id, geomtryId) {
-        let stateArray = this.conditionalNodes.get(id);
-        if (!stateArray) {
-            stateArray = [];
-            this.conditionalNodes.set(id, stateArray);
-        }
-        if (!stateArray.find((_) => _ == geomtryId))
-            stateArray.push(geomtryId);
-    }
-}

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

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