@divinevoxel/vlox 0.0.77 → 0.0.79

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

@@ -1,87 +0,0 @@
-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);
-        voxel.inputs;
-        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 arg = geo.input.arguments[geoArg];
-                        const keys = [];
-                        let proxyValue = null;
-                        if (arg.type === "arg-list") {
-                            keys.push(...arg.arguments);
-                            proxyValue = node.inputs[geoArg];
-                        }
-                        else {
-                            keys.push(geoArg);
-                        }
-                        geo.input.currentModel = voxel;
-                        geo.input.currentModelState = state;
-                        for (const key of keys) {
-                            const constructorArg = proxyValue ?? node.inputs[key];
-                            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}. ${key} does not exist`);
-                                    continue;
-                                }
-                                geo.input.proxy[key] = modVoxelInput[arg];
-                                continue;
-                            }
-                            geo.input.proxy[key] = 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

@@ -1,7 +0,0 @@
-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[][][];
-};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/Voxels/Models/Rules/VoxelModelRuleBuilderRegister.d.ts

@@ -1,18 +0,0 @@
-import { StringPalette } from "../../../Util/StringPalette";
-import { VoxelGeometryData, VoxelGeometryLinkData, VoxelModelConstructorData, VoxelModelData } from "../VoxelModel.types";
-import { VoxelRuleGeometry } from "./Classes/VoxelRulesGeometry";
-import { VoxelRulesModoel } from "./Classes/VoxelRulesModel";
-export declare class VoxelModelRuleBuilderRegister {
-    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/Voxels/Models/Rules/VoxelModelRuleBuilderRegister.js

@@ -1,202 +0,0 @@
-import { VoxelFaceNameArray } from "../../../Math";
-import { StringPalette } from "../../../Util/StringPalette";
-import { VoxelRuleGeometry } from "./Classes/VoxelRulesGeometry";
-import { VoxelRulesModoel } from "./Classes/VoxelRulesModel";
-const addGeo = (model, stateId, nodes) => {
-    const registred = [];
-    for (const geoLinkNode of nodes) {
-        const geo = VoxelModelRuleBuilderRegister.geometry.get(geoLinkNode.geometryId);
-        if (!geo)
-            throw new Error(`Geometry ${geoLinkNode.geometryId} is not registered.`);
-        const newId = getGeometryLinkId(geoLinkNode);
-        if (VoxelModelRuleBuilderRegister.geometry.has(newId))
-            continue;
-        registred.push([stateId, newId]);
-        if (!VoxelModelRuleBuilderRegister.geometryPalette.isRegistered(newId))
-            VoxelModelRuleBuilderRegister.geometryPalette.register(newId);
-        const newData = structuredClone(geo.data);
-        newData.cullingProcedure = geoLinkNode?.cullingProcedure
-            ? geoLinkNode?.cullingProcedure
-            : newData.cullingProcedure;
-        for (const node of newData.nodes) {
-            node.tranform = {
-                ...(geoLinkNode.position ? { position: geoLinkNode.position } : {}),
-                ...(geoLinkNode.scale ? { scale: geoLinkNode.scale } : {}),
-                ...(geoLinkNode.rotation ? { rotation: geoLinkNode.rotation } : {}),
-                ...(geoLinkNode.rotationPivot
-                    ? { rotationPivot: geoLinkNode.rotationPivot }
-                    : {}),
-                ...(geoLinkNode.flip ? { flip: geoLinkNode.flip } : {}),
-            };
-        }
-        VoxelModelRuleBuilderRegister.geometry.set(newId, new VoxelRuleGeometry(newId, newData));
-        continue;
-    }
-    return registred;
-};
-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()}` : ""}`.trim();
-};
-export class VoxelModelRuleBuilderRegister {
-    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);
-            const divisor = geo.divisor ? geo.divisor : false;
-            if (divisor) {
-                for (const node of geo.nodes) {
-                    if (node.type == "box") {
-                        let d = node.divisor ? node.divisor : divisor;
-                        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.type == "quad") {
-                        let d = node.divisor ? node.divisor : divisor;
-                        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.type == "triangle") {
-                        let d = node.divisor ? node.divisor : divisor;
-                        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];
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            this.geometry.set(geo.id, new VoxelRuleGeometry(geo.id, {
-                ogData: geo,
-                id: geo.id,
-                cullingProcedure: geo.cullingProcedure
-                    ? geo.cullingProcedure
-                    : { type: "default" },
-                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);
-            const divisor = model.divisor ? model.divisor : null;
-            if (divisor) {
-                for (const stateId in model.stateNodes) {
-                    const nodes = model.stateNodes[stateId];
-                    for (const node of nodes) {
-                        const d = "divisor" in node ? node.divisor : divisor;
-                        if (node.position) {
-                            node.position[0] /= d[0];
-                            node.position[1] /= d[1];
-                            node.position[2] /= d[2];
-                        }
-                        if (node.rotationPivot) {
-                            node.rotationPivot[0] /= d[0];
-                            node.rotationPivot[1] /= d[1];
-                            node.rotationPivot[2] /= d[2];
-                        }
-                    }
-                }
-                for (const stateId in model.conditonalNodes) {
-                    const nodes = model.conditonalNodes[stateId];
-                    for (const node of nodes) {
-                        const d = "divisor" in node ? node.divisor : divisor;
-                        if (node.position) {
-                            node.position[0] /= d[0];
-                            node.position[1] /= d[1];
-                            node.position[2] /= d[2];
-                        }
-                        if (node.rotationPivot) {
-                            node.rotationPivot[0] /= d[0];
-                            node.rotationPivot[1] /= d[1];
-                            node.rotationPivot[2] /= d[2];
-                        }
-                    }
-                }
-                if (model.effects) {
-                    for (const effect of model.effects) {
-                        if (effect.type == "fx-points") {
-                            for (const state in effect.values) {
-                                for (const point of effect.values[state]) {
-                                    point[0] /= divisor[0];
-                                    point[1] /= divisor[1];
-                                    point[2] /= divisor[2];
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            for (const stateId in model.stateNodes) {
-                const nodes = model.stateNodes[stateId];
-                addGeo(model, stateId, nodes).forEach((_) => rulesModel.registerShapeState(..._));
-            }
-            for (const stateId in model.conditonalNodes) {
-                const nodes = model.conditonalNodes[stateId];
-                addGeo(model, 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/Voxels/State/CondiotnalTreeReader.d.ts

@@ -1,10 +0,0 @@
-import { LogicStatementReader } from "./LogicStatementReader";
-import { StateSchema } from "./Schema/StateSchema";
-import { StateLogicStatement } from "./State.types";
-export declare class CondtionalTreeReader {
-    schema: StateSchema;
-    tree: any[];
-    statements: LogicStatementReader[];
-    constructor(schema: StateSchema, statements: StateLogicStatement[], tree: any[]);
-    getState(): number;
-}

package/Voxels/State/CondiotnalTreeReader.js

@@ -1,23 +0,0 @@
-import { LogicStatementReader } from "./LogicStatementReader";
-export class CondtionalTreeReader {
-    schema;
-    tree;
-    statements = [];
-    constructor(schema, statements, tree) {
-        this.schema = schema;
-        this.tree = tree;
-        for (const statement of statements) {
-            this.statements.push(new LogicStatementReader(schema, statement));
-        }
-    }
-    getState() {
-        if (!this.tree.length)
-            return -1;
-        let curretNode = this.tree;
-        for (let i = 0; i < this.statements.length; i++) {
-            const value = this.statements[i].getValue(this);
-            curretNode = curretNode[value ? 1 : 0];
-        }
-        return curretNode;
-    }
-}

package/Voxels/State/LogicStatementReader.d.ts

@@ -1,9 +0,0 @@
-import { CondtionalTreeReader } from "./CondiotnalTreeReader";
-import { StateSchema } from "./Schema/StateSchema";
-import { StateLogicStatement } from "./State.types";
-export declare class LogicStatementReader {
-    schema: StateSchema;
-    statement: StateLogicStatement;
-    constructor(schema: StateSchema, statement: StateLogicStatement);
-    getValue(treeReader: CondtionalTreeReader): boolean;
-}