@divinevoxel/vlox 0.0.74 → 0.0.76

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: {},

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>;
-    stateSchema: (VoxelStateStringSchemaData | VoxelStateNumberSchemaData)[];
+    stateSchema: VoxelBinaryStateSchemaNode[];
+    /**Define default properties for the voxel. */
+    properties?: Partial<VoxelBaseProperties>;
     effects?: VoxelEffectData[];
-    relationsSchema: VoxelModelRelationsSchemaData[];
+    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,12 @@
 import { StringPalette } from "../../../Util/StringPalette";
-import { BinarySchemaNodeData } from "../State.types";
+import { VoxelBinaryStateSchemaNode } from "../State.types";
 export declare class BinarySchemaNode {
-    id: string;
+    readonly data: VoxelBinaryStateSchemaNode;
+    get 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,18 @@
 import { StringPalette } from "../../../Util/StringPalette";
 export class BinarySchemaNode {
-    id;
+    data;
+    get name() {
+        return this.data.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.data = data;
+        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/Conditions/SameVoxelConditions.js

@@ -9,6 +9,8 @@ export class SameVoxelCondition extends ShapeStateSchemaRelationsCondition {
         const nx = this.schema.position.x + this.data.direction[0];
         const ny = this.schema.position.y + this.data.direction[1];
         const nz = this.schema.position.z + this.data.direction[2];
+        if (!this.schema.dataCursor.inBounds(nx, ny, nz))
+            return false;
         const nVoxel = this.schema.dataCursor.getVoxel(nx, ny, nz);
         if (!nVoxel)
             return false;

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,20 +2,44 @@ 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) {
         if (this.voxelSchemas.has(voxelId))
             return true;
-        if (this.modelStateSchemaData.has(this.voxelModelMap.get(voxelId) || "") &&
-            this.voxelModSchemaData.has(voxelId))
+        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)) {
             return this.voxelSchemas.get(voxelId);
@@ -25,14 +49,14 @@ export class SchemaRegister {
             throw new Error(`Voxel ${voxelId} is not registered`);
         let stateSchema = this.modelStaeSchemas.get(modelId);
         if (!stateSchema) {
-            const schemaData = this.modelStateSchemaData.get(modelId);
+            const schemaData = this.stateSchemaData.get(modelId);
             if (!schemaData)
                 throw new Error(`Model ${modelId} is not registered`);
             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);
@@ -42,23 +66,11 @@ export class SchemaRegister {
         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: 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/Types/PaintVoxelData.d.ts

@@ -0,0 +1,27 @@
+import { RawVoxelData } from "./Voxel.types";
+export declare class PaintVoxelData {
+    id: string;
+    name: string;
+    state: number;
+    stateString: string;
+    mod: number;
+    modString: string;
+    level: number;
+    levelState: number;
+    secondaryVoxelId: string;
+    secondaryName: string;
+    secondaryMod: number;
+    secondaryModString: string;
+    secondaryState: number;
+    secondaryStateString: string;
+    static Create(data?: Partial<PaintVoxelData>): PaintVoxelData;
+    /**Transforms numeric voxel data into a PaintVoxelData object */
+    static FromRaw(data: RawVoxelData, paintData?: PaintVoxelData): PaintVoxelData;
+    /**Transforms the voxel data into numeric voxel data */
+    static ToRaw(data: Partial<PaintVoxelData>, light?: number): RawVoxelData;
+    /**Restores the data to the default state of being dve_air */
+    static Clear(data: PaintVoxelData): PaintVoxelData;
+    /**Clears the target data and then copies properties from source to target. */
+    static Set(target: PaintVoxelData, source: Partial<PaintVoxelData>): PaintVoxelData;
+    private constructor();
+}