@divinevoxel/vlox 0.0.0

package/VoxelModels/Shared/Transform.js

@@ -0,0 +1,264 @@
+import { Quad } from "@amodx/meshing/Classes/Quad";
+import { QuadVerticies } from "@amodx/meshing/Geometry.types";
+import { Vector3Like } from "@amodx/math";
+// Utility function to convert degrees to radians
+function degreesToRadians(degrees) {
+    return (degrees * Math.PI) / 180;
+}
+export function TransformQuad(quad, transform) {
+    const p1 = { ...quad.positions.vertices[QuadVerticies.TopRight] };
+    const p2 = { ...quad.positions.vertices[QuadVerticies.TopLeft] };
+    const p3 = { ...quad.positions.vertices[QuadVerticies.BottomLeft] };
+    const p4 = { ...quad.positions.vertices[QuadVerticies.BottomRight] };
+    // Create an array of vertices
+    const vertices = [p1, p2, p3, p4];
+    // Compute the centroid of the quad
+    const centroid = {
+        x: (p1.x + p2.x + p3.x + p4.x) / 4,
+        y: (p1.y + p2.y + p3.y + p4.y) / 4,
+        z: (p1.z + p2.z + p3.z + p4.z) / 4,
+    };
+    // Initialize effective scales
+    let effectiveScaleX = 1;
+    let effectiveScaleY = 1;
+    let effectiveScaleZ = 1;
+    // Apply scale if specified
+    if (transform.scale) {
+        const [scaleX, scaleY, scaleZ] = transform.scale;
+        effectiveScaleX = scaleX;
+        effectiveScaleY = scaleY;
+        effectiveScaleZ = scaleZ;
+    }
+    // Apply flips by negating effective scales
+    if (transform.flip) {
+        const [flipX, flipY, flipZ] = transform.flip;
+        if (flipX)
+            effectiveScaleX *= -1;
+        if (flipY)
+            effectiveScaleY *= -1;
+        if (flipZ)
+            effectiveScaleZ *= -1;
+    }
+    // Compute determinant
+    const determinant = effectiveScaleX * effectiveScaleY * effectiveScaleZ;
+    // Apply scaling and flips
+    for (const vertex of vertices) {
+        vertex.x = centroid.x + (vertex.x - centroid.x) * effectiveScaleX;
+        vertex.y = centroid.y + (vertex.y - centroid.y) * effectiveScaleY;
+        vertex.z = centroid.z + (vertex.z - centroid.z) * effectiveScaleZ;
+    }
+    // Rotate vertices around the pivot point if rotation is specified
+    if (transform.rotation) {
+        const [rotXDeg, rotYDeg, rotZDeg] = transform.rotation;
+        const rotX = degreesToRadians(rotXDeg);
+        const rotY = degreesToRadians(rotYDeg);
+        const rotZ = degreesToRadians(rotZDeg);
+        const pivot = transform.rotationPivot
+            ? {
+                x: transform.rotationPivot[0],
+                y: transform.rotationPivot[1],
+                z: transform.rotationPivot[2],
+            }
+            : centroid;
+        for (const vertex of vertices) {
+            // Translate vertex to pivot point
+            let x = vertex.x - pivot.x;
+            let y = vertex.y - pivot.y;
+            let z = vertex.z - pivot.z;
+            // Rotation around X-axis
+            if (rotX) {
+                const cosX = Math.cos(rotX);
+                const sinX = Math.sin(rotX);
+                const y1 = y * cosX - z * sinX;
+                const z1 = y * sinX + z * cosX;
+                y = y1;
+                z = z1;
+            }
+            // Rotation around Y-axis
+            if (rotY) {
+                const cosY = Math.cos(rotY);
+                const sinY = Math.sin(rotY);
+                const x1 = x * cosY + z * sinY;
+                const z1 = -x * sinY + z * cosY;
+                x = x1;
+                z = z1;
+            }
+            // Rotation around Z-axis
+            if (rotZ) {
+                const cosZ = Math.cos(rotZ);
+                const sinZ = Math.sin(rotZ);
+                const x1 = x * cosZ - y * sinZ;
+                const y1 = x * sinZ + y * cosZ;
+                x = x1;
+                y = y1;
+            }
+            // Translate vertex back from pivot point
+            vertex.x = x + pivot.x;
+            vertex.y = y + pivot.y;
+            vertex.z = z + pivot.z;
+        }
+    }
+    // Translate vertices if position is specified
+    if (transform.position) {
+        const [dx, dy, dz] = transform.position;
+        for (const vertex of vertices) {
+            vertex.x += dx;
+            vertex.y += dy;
+            vertex.z += dz;
+        }
+    }
+    // If determinant is negative, reverse vertex order
+    if (determinant < 0) {
+        vertices.reverse();
+    }
+    // Create a new quad with the transformed vertices
+    const transformedQuad = Quad.Create(vertices.map((vertex) => Vector3Like.ToArray(vertex)));
+    return transformedQuad;
+}
+export function TransformBox(quads, transform) {
+    // Collect all unique vertices from the quads
+    const vertexMap = new Map();
+    for (const quad of quads) {
+        const vertices = [
+            quad.positions.vertices[QuadVerticies.TopRight],
+            quad.positions.vertices[QuadVerticies.TopLeft],
+            quad.positions.vertices[QuadVerticies.BottomLeft],
+            quad.positions.vertices[QuadVerticies.BottomRight],
+        ];
+        for (const vertex of vertices) {
+            const key = `${vertex.x},${vertex.y},${vertex.z}`;
+            if (!vertexMap.has(key)) {
+                vertexMap.set(key, { ...vertex });
+            }
+        }
+    }
+    const uniqueVertices = Array.from(vertexMap.values());
+    // Compute the centroid of the box
+    const centroid = { x: 0, y: 0, z: 0 };
+    for (const vertex of uniqueVertices) {
+        centroid.x += vertex.x;
+        centroid.y += vertex.y;
+        centroid.z += vertex.z;
+    }
+    centroid.x /= uniqueVertices.length;
+    centroid.y /= uniqueVertices.length;
+    centroid.z /= uniqueVertices.length;
+    let scaled = false;
+    // Initialize effective scales
+    let effectiveScaleX = 1;
+    let effectiveScaleY = 1;
+    let effectiveScaleZ = 1;
+    // Apply scale if specified
+    if (transform.scale) {
+        const [scaleX, scaleY, scaleZ] = transform.scale;
+        effectiveScaleX = scaleX;
+        effectiveScaleY = scaleY;
+        effectiveScaleZ = scaleZ;
+        scaled = true;
+    }
+    // Apply flips by negating effective scales
+    if (transform.flip) {
+        const [flipX, flipY, flipZ] = transform.flip;
+        if (flipX)
+            effectiveScaleX *= -1;
+        if (flipY)
+            effectiveScaleY *= -1;
+        if (flipZ)
+            effectiveScaleZ *= -1;
+        scaled = true;
+    }
+    // Compute determinant
+    const determinant = effectiveScaleX * effectiveScaleY * effectiveScaleZ;
+    if (scaled) {
+        // Apply scaling and flips to each unique vertex
+        for (const vertex of uniqueVertices) {
+            vertex.x = centroid.x + (vertex.x - centroid.x) * effectiveScaleX;
+            vertex.y = centroid.y + (vertex.y - centroid.y) * effectiveScaleY;
+            vertex.z = centroid.z + (vertex.z - centroid.z) * effectiveScaleZ;
+        }
+    }
+    // Rotate around a pivot point if specified
+    if (transform.rotation) {
+        const [rotXDeg, rotYDeg, rotZDeg] = transform.rotation;
+        const rotX = degreesToRadians(rotXDeg);
+        const rotY = degreesToRadians(rotYDeg);
+        const rotZ = degreesToRadians(rotZDeg);
+        const pivot = transform.rotationPivot
+            ? {
+                x: transform.rotationPivot[0],
+                y: transform.rotationPivot[1],
+                z: transform.rotationPivot[2],
+            }
+            : centroid;
+        if (transform.rotationPivot) {
+            console.warn(pivot, transform.rotationPivot);
+        }
+        for (const vertex of uniqueVertices) {
+            // Translate vertex to pivot point
+            let x = vertex.x - pivot.x;
+            let y = vertex.y - pivot.y;
+            let z = vertex.z - pivot.z;
+            // Rotation around X-axis
+            if (rotX) {
+                const cosX = Math.cos(rotX);
+                const sinX = Math.sin(rotX);
+                const y1 = y * cosX - z * sinX;
+                const z1 = y * sinX + z * cosX;
+                y = y1;
+                z = z1;
+            }
+            // Rotation around Y-axis
+            if (rotY) {
+                const cosY = Math.cos(rotY);
+                const sinY = Math.sin(rotY);
+                const x1 = x * cosY + z * sinY;
+                const z1 = -x * sinY + z * cosY;
+                x = x1;
+                z = z1;
+            }
+            // Rotation around Z-axis
+            if (rotZ) {
+                const cosZ = Math.cos(rotZ);
+                const sinZ = Math.sin(rotZ);
+                const x1 = x * cosZ - y * sinZ;
+                const y1 = x * sinZ + y * cosZ;
+                x = x1;
+                y = y1;
+            }
+            // Translate vertex back from pivot point
+            vertex.x = x + pivot.x;
+            vertex.y = y + pivot.y;
+            vertex.z = z + pivot.z;
+        }
+    }
+    // Translate vertices if position is specified
+    if (transform.position) {
+        const [dx, dy, dz] = transform.position;
+        for (const vertex of uniqueVertices) {
+            vertex.x += dx;
+            vertex.y += dy;
+            vertex.z += dz;
+        }
+    }
+    // Update the quads with transformed vertices
+    const transformedQuads = [];
+    for (const quad of quads) {
+        const originalVertices = [
+            quad.positions.vertices[QuadVerticies.TopRight],
+            quad.positions.vertices[QuadVerticies.TopLeft],
+            quad.positions.vertices[QuadVerticies.BottomLeft],
+            quad.positions.vertices[QuadVerticies.BottomRight],
+        ];
+        const transformedVertices = originalVertices.map((vertex) => {
+            const key = `${vertex.x},${vertex.y},${vertex.z}`;
+            return vertexMap.get(key);
+        });
+        // If determinant is negative, reverse the vertex order
+        if (determinant < 0) {
+            transformedVertices.reverse();
+        }
+        const newQuad = Quad.Create(transformedVertices.map((v) => Vector3Like.ToArray(v)));
+        transformedQuads.push(newQuad);
+    }
+    return transformedQuads;
+}

package/VoxelModels/State/CondiotnalTreeReader.d.ts

@@ -0,0 +1,10 @@
+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(shapeState: number): number;
+}

package/VoxelModels/State/CondiotnalTreeReader.js

@@ -0,0 +1,22 @@
+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(shapeState) {
+        if (!this.tree.length)
+            return -1;
+        let curretNode = this.tree;
+        for (let i = 0; i < this.statements.length; i++) {
+            curretNode = curretNode[this.statements[i].getValue(shapeState) ? 1 : 0];
+        }
+        return curretNode;
+    }
+}

package/VoxelModels/State/LogicStatementReader.d.ts

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

package/VoxelModels/State/LogicStatementReader.js

@@ -0,0 +1,50 @@
+import { StateCompareOperations, StateLogiceOperations, } from "./State.types";
+export class LogicStatementReader {
+    schema;
+    statement;
+    constructor(schema, statement) {
+        this.schema = schema;
+        this.statement = statement;
+    }
+    getValue(shapeState) {
+        let currentOperation = -1;
+        let returnVaue = false;
+        let currentValue = false;
+        for (let i = 0; i < this.statement.length; i++) {
+            const node = this.statement[i];
+            if (node == StateLogiceOperations.And ||
+                node == StateLogiceOperations.Or) {
+                currentOperation = node;
+                continue;
+            }
+            const value = this.schema.nodes[node[0]].getValue(shapeState);
+            switch (node[1]) {
+                case StateCompareOperations.Equals:
+                    currentValue = value == node[2];
+                    break;
+                case StateCompareOperations.NotEquals:
+                    currentValue = value != node[2];
+                    break;
+                case StateCompareOperations.GreaterThan:
+                    currentValue = value >= node[2];
+                    break;
+                case StateCompareOperations.LessThan:
+                    currentValue = value <= node[2];
+                    break;
+            }
+            if (currentOperation == -1) {
+                returnVaue = currentValue;
+                continue;
+            }
+            switch (currentOperation) {
+                case StateLogiceOperations.And:
+                    returnVaue = returnVaue && currentValue;
+                    break;
+                case StateLogiceOperations.Or:
+                    returnVaue = returnVaue || currentValue;
+                    break;
+            }
+        }
+        return returnVaue;
+    }
+}

package/VoxelModels/State/Schema/BinarySchema.d.ts

@@ -0,0 +1,14 @@
+import { BinarySchemaNode } from "./BinarySchemaNode";
+import { BinarySchemaNodeData } from "../State.types";
+export declare class BinarySchema {
+    nodeMap: Map<string, BinarySchemaNode>;
+    nodes: BinarySchemaNode[];
+    constructor(schema: BinarySchemaNodeData[]);
+    private _value;
+    startEncoding(): this;
+    getNmber(id: string): number;
+    getValue(id: string): string;
+    setNumber(id: string, value: number): this;
+    setValue(id: string, value: string): this;
+    getEncoded(): number;
+}

package/VoxelModels/State/Schema/BinarySchema.js

@@ -0,0 +1,52 @@
+import { BinarySchemaNode } from "./BinarySchemaNode";
+export class BinarySchema {
+    nodeMap = new Map();
+    nodes = [];
+    constructor(schema) {
+        for (const node of schema) {
+            if (node.type == "binary") {
+                const newNode = new BinarySchemaNode(node);
+                this.nodes.push(newNode);
+                this.nodeMap.set(node.id, newNode);
+            }
+        }
+    }
+    _value = 0;
+    startEncoding() {
+        this._value = 0;
+        return this;
+    }
+    getNmber(id) {
+        const node = this.nodeMap.get(id);
+        if (!node)
+            throw new Error(`Node with ${id} does not exist.`);
+        return node.getValue(this._value);
+    }
+    getValue(id) {
+        const node = this.nodeMap.get(id);
+        if (!node)
+            throw new Error(`Node with ${id} does not exist.`);
+        if (!node.valuePalette)
+            throw new Error(`Node with ${id} does not have a value palette.`);
+        return node.valuePalette.getStringId(node.getValue(this._value));
+    }
+    setNumber(id, value) {
+        const node = this.nodeMap.get(id);
+        if (!node)
+            throw new Error(`Node with ${id} does not exist.`);
+        this._value = node.setValue(this._value, value);
+        return this;
+    }
+    setValue(id, value) {
+        const node = this.nodeMap.get(id);
+        if (!node)
+            throw new Error(`Node with ${id} does not exist.`);
+        if (!node.valuePalette)
+            throw new Error(`Node with ${id} does not have a value palette.`);
+        this._value = node.setValue(this._value, node.valuePalette.getNumberId(value));
+        return this;
+    }
+    getEncoded() {
+        return this._value;
+    }
+}

package/VoxelModels/State/Schema/BinarySchemaNode.d.ts

@@ -0,0 +1,11 @@
+import { StringPalette } from "../../../Interfaces/Data/StringPalette";
+import { BinarySchemaNodeData } from "../State.types";
+export declare class BinarySchemaNode {
+    id: string;
+    valuePalette?: StringPalette;
+    bitIndex: number;
+    bitMask: number;
+    constructor(data: BinarySchemaNodeData);
+    getValue(data: number): number;
+    setValue(data: number, value: number): number;
+}

package/VoxelModels/State/Schema/BinarySchemaNode.js

@@ -0,0 +1,21 @@
+import { StringPalette } from "../../../Interfaces/Data/StringPalette";
+export class BinarySchemaNode {
+    id;
+    valuePalette;
+    bitIndex = 0;
+    bitMask = 0;
+    constructor(data) {
+        this.id = data.id;
+        this.bitIndex = data.index;
+        this.bitMask = data.mask;
+        if (data.valuePalette)
+            this.valuePalette = new StringPalette(data.valuePalette);
+    }
+    getValue(data) {
+        return (data & (this.bitMask << this.bitIndex)) >> this.bitIndex;
+    }
+    setValue(data, value) {
+        return ((data & ~(this.bitMask << this.bitIndex)) |
+            ((value & this.bitMask) << this.bitIndex));
+    }
+}

package/VoxelModels/State/Schema/Conditions/SameVoxelConditions.d.ts

@@ -0,0 +1,8 @@
+import { SameVoxelRelationsConditionData } from "../../../VoxelModel.types";
+import { ShapeStateSchemaRelationsCondition } from "./ShapeStateSchemaRelationsCondition";
+import { StateSchema } from "../StateSchema";
+export declare class SameVoxelCondition extends ShapeStateSchemaRelationsCondition {
+    data: SameVoxelRelationsConditionData;
+    constructor(schema: StateSchema, data: SameVoxelRelationsConditionData);
+    evulate(): boolean;
+}

package/VoxelModels/State/Schema/Conditions/SameVoxelConditions.js

@@ -0,0 +1,13 @@
+import { ShapeStateSchemaRelationsCondition } from "./ShapeStateSchemaRelationsCondition";
+export class SameVoxelCondition extends ShapeStateSchemaRelationsCondition {
+    data;
+    constructor(schema, data) {
+        super(schema);
+        this.data = data;
+    }
+    evulate() {
+        if (!this.schema.nVoxel.loadInAt(this.schema.voxel.x + this.data.direction[0], this.schema.voxel.y + this.data.direction[1], this.schema.voxel.z + this.data.direction[2]))
+            return false;
+        return this.schema.voxel.getId() == this.schema.nVoxel.getId();
+    }
+}

package/VoxelModels/State/Schema/Conditions/ShapeStateSchemaRelationsCondition.d.ts

@@ -0,0 +1,6 @@
+import { StateSchema } from "../StateSchema";
+export declare abstract class ShapeStateSchemaRelationsCondition {
+    schema: StateSchema;
+    constructor(schema: StateSchema);
+    abstract evulate(): boolean;
+}

package/VoxelModels/State/Schema/Conditions/ShapeStateSchemaRelationsCondition.js

@@ -0,0 +1,6 @@
+export class ShapeStateSchemaRelationsCondition {
+    schema;
+    constructor(schema) {
+        this.schema = schema;
+    }
+}

package/VoxelModels/State/Schema/ShapeStateRelationsNode.d.ts

@@ -0,0 +1,10 @@
+import { VoxelRelationsScehmaNodeData } from "../State.types";
+import { ShapeStateSchemaRelationsCondition } from "./Conditions/ShapeStateSchemaRelationsCondition";
+import { StateSchema } from "./StateSchema";
+export declare class ShapeStateRelationsNode {
+    schema: StateSchema;
+    id: string;
+    conditions: ShapeStateSchemaRelationsCondition[];
+    constructor(schema: StateSchema, data: VoxelRelationsScehmaNodeData);
+    getValue(): number;
+}

package/VoxelModels/State/Schema/ShapeStateRelationsNode.js

@@ -0,0 +1,26 @@
+import { SameVoxelCondition } from "./Conditions/SameVoxelConditions";
+export class ShapeStateRelationsNode {
+    schema;
+    id;
+    conditions = [];
+    constructor(schema, data) {
+        this.schema = schema;
+        this.id = data.id;
+        for (const cond of data.conditions) {
+            if (cond.type == "same-voxel") {
+                this.conditions.push(new SameVoxelCondition(schema, cond));
+            }
+        }
+    }
+    getValue() {
+        let value = 1;
+        const conditionsLength = this.conditions.length;
+        for (let i = 0; i < conditionsLength; i++) {
+            if (!this.conditions[i].evulate()) {
+                value = 0;
+                break;
+            }
+        }
+        return value;
+    }
+}

package/VoxelModels/State/Schema/StateSchema.d.ts

@@ -0,0 +1,10 @@
+import { ShapeStateRelationsNode } from "./ShapeStateRelationsNode";
+import { BinarySchemaNode } from "./BinarySchemaNode";
+import { VoxelModelStateSchemaData } from "../State.types";
+import { DataTool } from "../../../Tools/Data/DataTool";
+export declare class StateSchema {
+    voxel: DataTool;
+    nVoxel: DataTool;
+    nodes: (BinarySchemaNode | ShapeStateRelationsNode)[];
+    constructor(schema: VoxelModelStateSchemaData[]);
+}

package/VoxelModels/State/Schema/StateSchema.js

@@ -0,0 +1,18 @@
+import { ShapeStateRelationsNode } from "./ShapeStateRelationsNode";
+import { BinarySchemaNode } from "./BinarySchemaNode";
+import { DataTool } from "../../../Tools/Data/DataTool";
+export class StateSchema {
+    voxel = new DataTool();
+    nVoxel = new DataTool();
+    nodes = [];
+    constructor(schema) {
+        for (const node of schema) {
+            if (node.type == "binary") {
+                this.nodes.push(new BinarySchemaNode(node));
+            }
+            if (node.type == "relation") {
+                this.nodes.push(new ShapeStateRelationsNode(this, node));
+            }
+        }
+    }
+}

package/VoxelModels/State/SchemaRegister.d.ts

@@ -0,0 +1,15 @@
+import { BinarySchema } from "./Schema/BinarySchema";
+import { BinarySchemaNodeData, VoxelModelStateSchemaData } from "./State.types";
+export declare class SchemaRegister {
+    static modelStaeSchemaData: Map<string, BinarySchemaNodeData[]>;
+    static voxelModSchemaData: Map<string, BinarySchemaNodeData[]>;
+    static modelStaeSchemas: Map<string, BinarySchema>;
+    static voxelModSchemas: Map<string, BinarySchema>;
+    static voxelModelMap: Map<string, string>;
+    static getVoxelSchemas(id: string): {
+        modelSchema: BinarySchema;
+        voxelSchema: BinarySchema;
+    };
+    static registerModel(id: string, data: VoxelModelStateSchemaData[]): void;
+    static registerVoxel(id: string, modelId: string, data: VoxelModelStateSchemaData[]): void;
+}

package/VoxelModels/State/SchemaRegister.js

@@ -0,0 +1,50 @@
+import { BinarySchema } from "./Schema/BinarySchema";
+export class SchemaRegister {
+    static modelStaeSchemaData = new Map();
+    static voxelModSchemaData = new Map();
+    static modelStaeSchemas = new Map();
+    static voxelModSchemas = new Map();
+    static voxelModelMap = new Map();
+    static getVoxelSchemas(id) {
+        const modelId = this.voxelModelMap.get(id);
+        if (!modelId)
+            throw new Error(`Voxel with ${id} is not registered`);
+        let modelSchema = this.modelStaeSchemas.get(modelId);
+        if (!modelSchema) {
+            const schemaData = this.modelStaeSchemaData.get(modelId);
+            if (!schemaData)
+                throw new Error(`Model with ${modelId} is not registered`);
+            modelSchema = new BinarySchema(schemaData);
+        }
+        let voxelSchema = this.voxelModSchemas.get(modelId);
+        if (!voxelSchema) {
+            const schemaData = this.voxelModSchemaData.get(id);
+            if (!schemaData)
+                throw new Error(`Voxel with ${id} is not registered`);
+            voxelSchema = new BinarySchema(schemaData);
+        }
+        return {
+            modelSchema,
+            voxelSchema,
+        };
+    }
+    static registerModel(id, data) {
+        const binaryData = [];
+        for (const node of data) {
+            if (node.type == "binary") {
+                binaryData.push(node);
+            }
+        }
+        this.modelStaeSchemaData.set(id, binaryData);
+    }
+    static registerVoxel(id, modelId, data) {
+        this.voxelModelMap.set(id, modelId);
+        const binaryData = [];
+        for (const node of data) {
+            if (node.type == "binary") {
+                binaryData.push(node);
+            }
+        }
+        this.voxelModSchemaData.set(id, binaryData);
+    }
+}

package/VoxelModels/State/State.types.d.ts

@@ -0,0 +1,32 @@
+import { VoxelModelRelationsConditionData } from "../VoxelModel.types";
+export type BinarySchemaNodeData = {
+    id: string;
+    type: "binary";
+    valuePalette?: string[];
+    index: number;
+    mask: number;
+};
+export type VoxelRelationsScehmaNodeData = {
+    id: string;
+    type: "relation";
+    conditions: VoxelModelRelationsConditionData[];
+};
+export type VoxelModelStateSchemaData = BinarySchemaNodeData | VoxelRelationsScehmaNodeData;
+export declare enum StateCompareOperations {
+    Equals = 0,
+    NotEquals = 1,
+    GreaterThan = 2,
+    LessThan = 3
+}
+export declare enum StateLogiceOperations {
+    And = 0,
+    Or = 1
+}
+export declare const StateCompareOperationsMap: Record<string, StateCompareOperations>;
+export declare const StateLogicOperationsMap: Record<string, StateLogiceOperations>;
+export type StateLogicNode = [
+    schemaId: number,
+    operation: StateCompareOperations,
+    value: number
+];
+export type StateLogicStatement = (StateLogicNode | StateLogiceOperations)[];