@divinevoxel/vlox 0.0.73 → 0.0.75

package/{Models → Voxels/Models}/Rules/VoxelModelRuleBuilderRegister.js

@@ -1,5 +1,5 @@
-import { VoxelFaceNameArray } from "../../Math";
-import { StringPalette } from "../../Util/StringPalette";
+import { VoxelFaceNameArray } from "../../../Math";
+import { StringPalette } from "../../../Util/StringPalette";
 import { VoxelRuleGeometry } from "./Classes/VoxelRulesGeometry";
 import { VoxelRulesModoel } from "./Classes/VoxelRulesModel";
 const addGeo = (model, stateId, nodes) => {
@@ -15,6 +15,9 @@ const addGeo = (model, stateId, nodes) => {
         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 } : {}),
@@ -32,7 +35,7 @@ const addGeo = (model, stateId, nodes) => {
     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();
+    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();
@@ -90,11 +93,32 @@ export class VoxelModelRuleBuilderRegister {
                             }
                         }
                     }
+                    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: {},
@@ -111,8 +135,8 @@ export class VoxelModelRuleBuilderRegister {
             this.models.set(model.id, rulesModel);
             const divisor = model.divisor ? model.divisor : null;
             if (divisor) {
-                for (const stateId in model.shapeStatesNodes) {
-                    const nodes = model.shapeStatesNodes[stateId];
+                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) {
@@ -127,8 +151,8 @@ export class VoxelModelRuleBuilderRegister {
                         }
                     }
                 }
-                for (const stateId in model.shapeStatesConditonalNodes) {
-                    const nodes = model.shapeStatesConditonalNodes[stateId];
+                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) {
@@ -157,12 +181,12 @@ export class VoxelModelRuleBuilderRegister {
                     }
                 }
             }
-            for (const stateId in model.shapeStatesNodes) {
-                const nodes = model.shapeStatesNodes[stateId];
+            for (const stateId in model.stateNodes) {
+                const nodes = model.stateNodes[stateId];
                 addGeo(model, stateId, nodes).forEach((_) => rulesModel.registerShapeState(..._));
             }
-            for (const stateId in model.shapeStatesConditonalNodes) {
-                const nodes = model.shapeStatesConditonalNodes[stateId];
+            for (const stateId in model.conditonalNodes) {
+                const nodes = model.conditonalNodes[stateId];
                 addGeo(model, stateId, nodes).forEach((_) => rulesModel.registerCondiotnalNode(..._));
             }
         }

package/{Models → Voxels/Models}/VoxelModel.types.d.ts

@@ -1,19 +1,8 @@
 import { Vec2Array, Vec3Array } from "@amodx/math";
-import { QuadUVData } from "../Mesher/Geomtry/Geometry.types";
-import { VoxelFaceNames } from "../Math";
-import { VoxelStateStringSchemaData, VoxelModelRelationsSchemaData, VoxelStateNumberSchemaData } from "../Voxels/State/State.types";
-import { VoxelEffectData } from "../Voxels/Effects/VoxelEffects.types";
-/**The model data assoicated with the actual voxel. */
-export interface VoxelModelConstructorData {
-    id: string;
-    modRelationSchema?: VoxelModelRelationsSchemaData[];
-    modSchema?: VoxelStateStringSchemaData[];
-    inputs: Record<string, Record<string, any>>;
-    tagOverrides?: {
-        isLightSource?: Record<string, boolean>;
-        lightValue?: Record<string, Vec3Array>;
-    };
-}
+import { VoxelFaceNames } from "../../Math";
+import { VoxelModelRelationsSchemaNodes, VoxelBinaryStateSchemaNode } from "../../Voxels/State/State.types";
+import { VoxelEffectData } from "../../Voxels/Effects/VoxelEffects.types";
+import { VoxelBaseProperties } from "../Types/Voxel.types";
 /**Define a custom geomtry node */
 export interface VoxelCustomGeomtryNode {
     type: "custom";
@@ -24,49 +13,40 @@ export interface VoxelBoxGeometryNode {
     type: "box";
     /**Divisor used for transform of this specific node.*/
     divisor?: Vec3Array;
-    noShade?: boolean;
     points: [start: Vec3Array, end: Vec3Array];
     rotation?: Vec3Array;
-    faces: Record<VoxelFaceNames, VoxelBoxFaceData>;
+    faces: Record<VoxelFaceNames, BaseVoxelQuadData>;
 }
-export interface VoxelBoxFaceData {
+export interface BaseVoxelQuadData {
+    doubleSided?: boolean | string;
     enabled?: boolean;
-    flip?: boolean;
+    /**Id for an input arg for the texture */
     texture: string;
-    transparent?: boolean | string;
+    /**UV for the face or id for an input arg. */
     uv: [x1: number, y1: number, x2: number, y2: number] | string;
+    /**UV rotation or id for an input arg */
     rotation?: number | string;
 }
-export interface VoxelQuadGeometryNode {
+export interface VoxelQuadGeometryNode extends BaseVoxelQuadData {
     type: "quad";
     /**Divisor used for transform of this specific node.*/
     divisor?: Vec3Array;
-    doubleSided?: boolean | string;
     points: [p1: Vec3Array, p2: Vec3Array, p3: Vec3Array, p4: Vec3Array];
-    transparent?: boolean | string;
+}
+export interface BaseVoxelTriangleData {
+    doubleSided?: boolean;
+    /**Id for the input arg for the texture */
     texture: string;
-    uv: [x1: number, y1: number, x2: number, y2: number] | QuadUVData | string;
-    textureRotation?: number | string;
+    /**UV for the triangle or id for the input arg. */
+    uv: [v1: Vec2Array, v2: Vec2Array, v3: Vec2Array] | string;
+    /**UV rotation or id for an input arg */
+    rotation?: number | string;
 }
-export interface VoxelTriangleGeometryNode {
+export interface VoxelTriangleGeometryNode extends BaseVoxelTriangleData {
     type: "triangle";
     /**Divisor used for transform of this specific node.*/
     divisor?: Vec3Array;
-    orientation?: 0 | 1;
-    doubleSided?: boolean;
     points: [p1: Vec3Array, p2: Vec3Array, p3: Vec3Array];
-    transparent?: boolean | string;
-    texture: string;
-    uv: [v1: Vec2Array, v2: Vec2Array, v3: Vec2Array] | string;
-    textureRotation?: number | string;
-}
-export interface VoxelRawGeometryGeometryNode {
-    type: "raw-geometry";
-    positions: number[];
-    normals: number[];
-    indices: number[];
-    uvs: number[];
-    texture: string;
 }
 export interface VoxelGeometryTextureArgument {
     type: "texture";
@@ -87,13 +67,28 @@ export interface VoxelGeometryBoxUVArgument {
     type: "box-uv";
     default: [x1: number, y1: number, x2: number, y2: number];
 }
+export interface VoxelGeometryUVArgument {
+    type: "uv";
+    default: Vec2Array[];
+}
 export interface VoxelGeometryVector3Argument {
     type: "vector3";
     default?: Vec3Array;
     min?: Vec3Array;
     max?: Vec3Array;
 }
-export type VoxelGeometryNodes = VoxelCustomGeomtryNode | VoxelBoxGeometryNode | VoxelTriangleGeometryNode | VoxelQuadGeometryNode | VoxelRawGeometryGeometryNode;
+export type VoxelGeometryNodes = VoxelCustomGeomtryNode | VoxelBoxGeometryNode | VoxelTriangleGeometryNode | VoxelQuadGeometryNode;
+export type CullingProcedureData = {
+    type: "default";
+} | {
+    type: "none";
+} | {
+    type: "transparent";
+} | {
+    type: "custom";
+    id: string;
+    data: any;
+};
 export interface VoxelGeometryData {
     id: string;
     nodes: VoxelGeometryNodes[];
@@ -104,11 +99,18 @@ export interface VoxelGeometryData {
      * Ideal for advanced or non cubic models.
      * */
     doNotBuildRules?: true;
-    arguments: Record<string, VoxelGeometryTextureArgument | VoxelGeometryBoxUVArgument | VoxelGeometryVector3Argument | VoxelGeometryIntArgument | VoxelGeometryBooleanArgument | VoxelGeometryFloatArgument>;
+    /**
+     * Define the culling procedure for faces
+     */
+    cullingProcedure?: CullingProcedureData;
+    arguments: Record<string, VoxelGeometryTextureArgument | VoxelGeometryBoxUVArgument | VoxelGeometryUVArgument | VoxelGeometryVector3Argument | VoxelGeometryIntArgument | VoxelGeometryBooleanArgument | VoxelGeometryFloatArgument>;
 }
 export interface VoxelGeometryLinkData {
-    id: string;
     geometryId: string;
+    /**
+     * Overrride the culling procedure for faces
+     */
+    cullingProcedure?: CullingProcedureData;
     /**Divisor used for transform of this specific node.*/
     divisor?: Vec3Array;
     inputs: Record<string, any>;
@@ -123,9 +125,18 @@ export interface VoxelModelData {
     /**Divisor used all transforms of geometry nodes. */
     divisor?: Vec3Array;
     arguments: Record<string, VoxelGeometryTextureArgument | VoxelGeometryBoxUVArgument | VoxelGeometryVector3Argument | VoxelGeometryIntArgument | VoxelGeometryBooleanArgument | VoxelGeometryFloatArgument>;
-    shapeStateSchema: (VoxelStateStringSchemaData | VoxelStateNumberSchemaData)[];
+    stateSchema: VoxelBinaryStateSchemaNode[];
+    /**Define default properties for the voxel. */
+    properties?: Partial<VoxelBaseProperties>;
     effects?: VoxelEffectData[];
-    relationsSchema: VoxelModelRelationsSchemaData[];
-    shapeStatesNodes: Record<string, VoxelGeometryLinkData[]>;
-    shapeStatesConditonalNodes: Record<string, VoxelGeometryLinkData[]>;
+    relationsSchema: VoxelModelRelationsSchemaNodes[];
+    stateNodes: Record<string, VoxelGeometryLinkData[]>;
+    conditonalNodes: Record<string, VoxelGeometryLinkData[]>;
+}
+/**The model data assoicated with the actual voxel. */
+export interface VoxelModelConstructorData {
+    id: string;
+    modRelationSchema?: VoxelModelRelationsSchemaNodes[];
+    modSchema?: VoxelBinaryStateSchemaNode[];
+    inputs: Record<string, Record<string, any>>;
 }

package/Voxels/Models/VoxelModel.types.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,17 +1,19 @@
 import { BinarySchemaNode } from "./BinarySchemaNode";
-import { BinarySchemaNodeData } from "../State.types";
+import { VoxelBinaryStateSchemaNode } from "../State.types";
 type StateObject = (string | number)[];
 export declare class BinarySchema {
     nodeMap: Map<string, BinarySchemaNode>;
     nodes: BinarySchemaNode[];
-    constructor(schema: BinarySchemaNodeData[]);
+    constructor(schema: VoxelBinaryStateSchemaNode[]);
     private _value;
+    toStateString(): string;
     readString(stateString: string): number;
     fromStateObject(stateObject: StateObject): number;
     getStateObject(stateValue: number): StateObject;
     compareString(stateString: string, ecnoded: number): boolean;
     startEncoding(value?: number): this;
-    getNmber(id: string): number;
+    get(id: string): string | number;
+    getNumber(id: string): number;
     getValue(id: string): string;
     setNumber(id: string, value: number): this;
     setValue(id: string, value: string): this;

package/Voxels/State/Schema/BinarySchema.js

@@ -4,14 +4,21 @@ export class BinarySchema {
     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);
-            }
+            const newNode = new BinarySchemaNode(node);
+            this.nodes.push(newNode);
+            this.nodeMap.set(node.name, newNode);
         }
     }
     _value = 0;
+    toStateString() {
+        if (!this.nodes.length)
+            return "*";
+        let stateString = [];
+        for (let i = 0; i < this.nodes.length; i++) {
+            stateString.push(`${this.nodes[i].name}=${String(this.get(this.nodes[i].name))}`);
+        }
+        return stateString.join(",");
+    }
     readString(stateString) {
         if (stateString == "*")
             return 0;
@@ -60,10 +67,10 @@ export class BinarySchema {
         const stateArray = [];
         for (const node of this.nodes) {
             if (node.valuePalette) {
-                stateArray.push(node.id, node.valuePalette.getStringId(node.getValue(stateValue)));
+                stateArray.push(node.name, node.valuePalette.getStringId(node.getValue(stateValue)));
                 continue;
             }
-            stateArray.push(node.id, node.getValue(stateValue));
+            stateArray.push(node.name, node.getValue(stateValue));
         }
         return stateArray;
     }
@@ -98,7 +105,15 @@ export class BinarySchema {
         this._value = value;
         return this;
     }
-    getNmber(id) {
+    get(id) {
+        const node = this.nodeMap.get(id);
+        if (!node)
+            throw new Error(`Node with ${id} does not exist.`);
+        if (node.valuePalette)
+            return node.valuePalette.getStringId(node.getValue(this._value));
+        return node.getValue(this._value);
+    }
+    getNumber(id) {
         const node = this.nodeMap.get(id);
         if (!node)
             throw new Error(`Node with ${id} does not exist.`);

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

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

package/Voxels/State/Schema/BinarySchemaNode.js

@@ -1,15 +1,15 @@
 import { StringPalette } from "../../../Util/StringPalette";
 export class BinarySchemaNode {
-    id;
+    name;
     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);
+        this.name = data.name;
+        this.bitIndex = data.bitIndex;
+        this.bitMask = (1 << data.bitSize) - 1;
+        if (data.values)
+            this.valuePalette = new StringPalette(data.values);
     }
     getValue(data) {
         return (data & (this.bitMask << this.bitIndex)) >> this.bitIndex;

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

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

package/Voxels/State/Schema/ShapeStateRelationsNode.js

@@ -1,11 +1,11 @@
 import { SameVoxelCondition } from "./Conditions/SameVoxelConditions";
 export class ShapeStateRelationsNode {
     schema;
-    id;
+    name;
     conditions = [];
     constructor(schema, data) {
         this.schema = schema;
-        this.id = data.id;
+        this.name = data.name;
         for (const cond of data.conditions) {
             if (cond.type == "same-voxel") {
                 this.conditions.push(new SameVoxelCondition(schema, cond));

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

@@ -1,13 +1,13 @@
 import { ShapeStateRelationsNode } from "./ShapeStateRelationsNode";
 import { BinarySchemaNode } from "./BinarySchemaNode";
-import { VoxelModelStateSchemaData } from "../State.types";
 import { DataCursorInterface } from "../../Cursor/DataCursor.interface";
 import { Vector3Like } from "@amodx/math";
 import { VoxelCursorInterface } from "../../Cursor/VoxelCursor.interface";
+import { VoxelStateSchemaData } from "../State.types";
 export declare class StateSchema {
     nodes: (BinarySchemaNode | ShapeStateRelationsNode)[];
     position: Vector3Like;
     voxel: VoxelCursorInterface;
     dataCursor: DataCursorInterface;
-    constructor(schema: VoxelModelStateSchemaData[]);
+    constructor(schema: VoxelStateSchemaData);
 }

package/Voxels/State/Schema/StateSchema.js

@@ -7,13 +7,11 @@ export class StateSchema {
     voxel;
     dataCursor;
     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));
-            }
+        for (const binary of schema.binary) {
+            this.nodes.push(new BinarySchemaNode(binary));
+        }
+        for (const relational of schema.relational) {
+            this.nodes.push(new ShapeStateRelationsNode(this, relational));
         }
     }
 }

package/Voxels/State/SchemaRegister.d.ts

@@ -1,16 +1,18 @@
 import { BinarySchema } from "./Schema/BinarySchema";
 import { VoxelSchema } from "./Schema/VoxelSchema";
-import { BinarySchemaNodeData, VoxelModelStateSchemaData } from "./State.types";
+import { VoxelStateSchemaData, VoxelBinaryStateSchemaNode } from "./State.types";
 export declare class SchemaRegister {
-    static modelStaeBaseSchemaData: Map<string, VoxelModelStateSchemaData[]>;
-    static modelStateSchemaData: Map<string, BinarySchemaNodeData[]>;
-    static voxelModSchemaData: Map<string, BinarySchemaNodeData[]>;
+    static modelStaeBaseSchemaData: Map<string, VoxelStateSchemaData>;
+    static stateSchemaData: Map<string, VoxelBinaryStateSchemaNode[]>;
+    static modSchemaData: Map<string, VoxelBinaryStateSchemaNode[]>;
     static modelStaeSchemas: Map<string, BinarySchema>;
     static voxelModSchemas: Map<string, BinarySchema>;
     static voxelModelMap: Map<string, string>;
     static voxelSchemas: Map<string, VoxelSchema>;
     static hasVoxelSchema(voxelId: string): boolean;
+    static getModelSchema(modelId: string): BinarySchema;
+    static getVoxelModSchema(voxelId: string): BinarySchema;
     static getVoxelSchemas(voxelId: string): VoxelSchema;
-    static registerModel(id: string, data: VoxelModelStateSchemaData[]): void;
-    static registerVoxel(id: string, modelId: string, data: VoxelModelStateSchemaData[]): void;
+    static registerModel(id: string, data: VoxelStateSchemaData): void;
+    static registerVoxel(id: string, modelId: string, data: VoxelStateSchemaData): void;
 }

package/Voxels/State/SchemaRegister.js

@@ -2,14 +2,43 @@ import { BinarySchema } from "./Schema/BinarySchema";
 import { VoxelSchema } from "./Schema/VoxelSchema";
 export class SchemaRegister {
     static modelStaeBaseSchemaData = new Map();
-    static modelStateSchemaData = new Map();
-    static voxelModSchemaData = new Map();
+    static stateSchemaData = new Map([
+        ["dve_air", []],
+    ]);
+    static modSchemaData = new Map([
+        ["dve_air", []],
+    ]);
     static modelStaeSchemas = new Map();
     static voxelModSchemas = new Map();
-    static voxelModelMap = new Map();
+    static voxelModelMap = new Map([["dve_air", "dve_air"]]);
     static voxelSchemas = new Map();
     static hasVoxelSchema(voxelId) {
-        return this.voxelSchemas.has(voxelId);
+        if (this.voxelSchemas.has(voxelId))
+            return true;
+        if (this.stateSchemaData.has(this.voxelModelMap.get(voxelId) || "") &&
+            this.modSchemaData.has(voxelId))
+            return true;
+        return false;
+    }
+    static getModelSchema(modelId) {
+        let stateSchema = this.modelStaeSchemas.get(modelId);
+        if (!stateSchema) {
+            const schemaData = this.stateSchemaData.get(modelId);
+            if (!schemaData)
+                throw new Error(`Model ${modelId} is not registered`);
+            stateSchema = new BinarySchema(schemaData);
+        }
+        return stateSchema;
+    }
+    static getVoxelModSchema(voxelId) {
+        let modSchema = this.voxelModSchemas.get(voxelId);
+        if (!modSchema) {
+            const schemaData = this.modSchemaData.get(voxelId);
+            if (!schemaData)
+                throw new Error(`Voxel mod sceham [${voxelId}] is not registered`);
+            modSchema = new BinarySchema(schemaData);
+        }
+        return modSchema;
     }
     static getVoxelSchemas(voxelId) {
         if (this.voxelSchemas.has(voxelId)) {
@@ -18,42 +47,30 @@ export class SchemaRegister {
         const modelId = this.voxelModelMap.get(voxelId);
         if (!modelId)
             throw new Error(`Voxel ${voxelId} is not registered`);
-        let shapeStateSchema = this.modelStaeSchemas.get(modelId);
-        if (!shapeStateSchema) {
-            const schemaData = this.modelStateSchemaData.get(modelId);
+        let stateSchema = this.modelStaeSchemas.get(modelId);
+        if (!stateSchema) {
+            const schemaData = this.stateSchemaData.get(modelId);
             if (!schemaData)
                 throw new Error(`Model ${modelId} is not registered`);
-            shapeStateSchema = new BinarySchema(schemaData);
+            stateSchema = new BinarySchema(schemaData);
         }
         let modSchema = this.voxelModSchemas.get(voxelId);
         if (!modSchema) {
-            const schemaData = this.voxelModSchemaData.get(voxelId);
+            const schemaData = this.modSchemaData.get(voxelId);
             if (!schemaData)
                 throw new Error(`Voxel ${voxelId} is not registered`);
             modSchema = new BinarySchema(schemaData);
         }
-        const voxelSchema = new VoxelSchema(voxelId, shapeStateSchema, modSchema);
+        const voxelSchema = new VoxelSchema(voxelId, stateSchema, modSchema);
         this.voxelSchemas.set(voxelId, voxelSchema);
         return voxelSchema;
     }
     static registerModel(id, data) {
-        const binaryData = [];
         this.modelStaeBaseSchemaData.set(id, data);
-        for (const node of data) {
-            if (node.type == "binary") {
-                binaryData.push(node);
-            }
-        }
-        this.modelStateSchemaData.set(id, binaryData);
+        this.stateSchemaData.set(id, data.binary);
     }
     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);
+        this.modSchemaData.set(id, data.binary);
     }
 }

package/Voxels/State/State.types.d.ts

@@ -1,14 +1,16 @@
 import { Vec3Array } from "@amodx/math";
-export interface VoxelStateStringSchemaData {
+/**
+ * Binary State
+ */
+export type VoxelBinaryStateSchemaNode = {
     name: string;
-    type: "string";
-    values: Record<number, string>;
-}
-export interface VoxelStateNumberSchemaData {
-    name: string;
-    type: "number";
-    maxValue: number;
-}
+    bitIndex: number;
+    bitSize: number;
+    values?: string[];
+};
+/**
+ * Relational
+ */
 export interface SameVoxelRelationsConditionData {
     type: "same-voxel";
     direction: Vec3Array;
@@ -18,23 +20,10 @@ export interface AnyVoxelRelationsConditionData {
     direction: Vec3Array;
 }
 export type VoxelStateRelationsConditionData = SameVoxelRelationsConditionData | AnyVoxelRelationsConditionData;
-export interface VoxelModelRelationsSchemaData {
+export interface VoxelModelRelationsSchemaNodes {
     name: string;
     conditions: VoxelStateRelationsConditionData[];
 }
-export type BinarySchemaNodeData = {
-    id: string;
-    type: "binary";
-    valuePalette?: string[];
-    index: number;
-    mask: number;
-};
-export type VoxelRelationsScehmaNodeData = {
-    id: string;
-    type: "relation";
-    conditions: VoxelStateRelationsConditionData[];
-};
-export type VoxelModelStateSchemaData = BinarySchemaNodeData | VoxelRelationsScehmaNodeData;
 export declare enum StateCompareOperations {
     Equals = 0,
     NotEquals = 1,
@@ -53,3 +42,10 @@ export type StateLogicNode = [
     value: number
 ];
 export type StateLogicStatement = (StateLogicNode | StateLogiceOperations)[];
+/**
+ * Voxel State
+ */
+export type VoxelStateSchemaData = {
+    binary: VoxelBinaryStateSchemaNode[];
+    relational: VoxelModelRelationsSchemaNodes[];
+};

package/Voxels/State/StateTreeReader.d.ts

@@ -5,5 +5,5 @@ export declare class StateTreeReader {
     tree: any[];
     startingIndex: number;
     constructor(schema: StateSchema, defaultValue: number | undefined, tree: any[]);
-    getState(shapeState: number): number;
+    getState(state: number): number;
 }

package/Voxels/State/StateTreeReader.js

@@ -8,15 +8,14 @@ export class StateTreeReader {
         this.defaultValue = defaultValue;
         this.tree = tree;
     }
-    getState(shapeState) {
+    getState(state) {
         if (!this.tree.length)
             return this.defaultValue;
         let found = -1;
         let index = this.startingIndex;
         let curretNode = this.tree;
         while (found == -1) {
-            curretNode =
-                curretNode[index][this.schema.nodes[index].getValue(shapeState)];
+            curretNode = curretNode[index][this.schema.nodes[index].getValue(state)];
             if (typeof curretNode == "number") {
                 return curretNode;
             }