@divinevoxel/vlox 0.0.2 → 0.0.3

package/Voxels/State/Schema/BinarySchema.js

@@ -0,0 +1,103 @@
+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;
+    readString(stateString) {
+        if (stateString == "*")
+            return 0;
+        const split = stateString.split(",");
+        let ecnoded = 0;
+        for (const pair of split) {
+            const [key, v] = pair.split("=");
+            if (v == "*")
+                continue;
+            const node = this.nodeMap.get(key);
+            if (!node)
+                continue;
+            if (node.valuePalette) {
+                const value = node.valuePalette.getNumberId(v);
+                if (value === undefined)
+                    throw new Error(`Binary schema string node value  with id ${v} does not exist.`);
+                ecnoded = node.setValue(ecnoded, value);
+            }
+            else {
+                ecnoded = node.setValue(ecnoded, Number(v));
+            }
+        }
+        return ecnoded;
+    }
+    compareString(stateString, ecnoded) {
+        if (stateString == "*")
+            return true;
+        const split = stateString.split(",");
+        for (const pair of split) {
+            const [key, v] = pair.split("=");
+            if (v == "*")
+                continue;
+            const node = this.nodeMap.get(key);
+            if (!node)
+                continue;
+            if (node.valuePalette) {
+                const value = node.valuePalette.getNumberId(v);
+                if (value === undefined)
+                    throw new Error(`Binary schema string node value  with id ${key} does not exist.`);
+                if (node.getValue(ecnoded) !== value) {
+                    return false;
+                }
+            }
+            else {
+                if (node.getValue(ecnoded) !== Number(v)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    startEncoding(value = 0) {
+        this._value = value;
+        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 → Voxels}/State/Schema/BinarySchemaNode.d.ts

@@ -1,4 +1,4 @@
-import { StringPalette } from "../../../Interfaces/Data/StringPalette";
+import { StringPalette } from "../../../Util/StringPalette";
 import { BinarySchemaNodeData } from "../State.types";
 export declare class BinarySchemaNode {
     id: string;

package/{VoxelModels → Voxels}/State/Schema/BinarySchemaNode.js

@@ -1,4 +1,4 @@
-import { StringPalette } from "../../../Interfaces/Data/StringPalette";
+import { StringPalette } from "../../../Util/StringPalette";
 export class BinarySchemaNode {
     id;
     valuePalette;

package/{VoxelModels → Voxels}/State/Schema/Conditions/SameVoxelConditions.d.ts

@@ -1,4 +1,4 @@
-import { SameVoxelRelationsConditionData } from "../../../VoxelModel.types";
+import { SameVoxelRelationsConditionData } from "../../State.types";
 import { ShapeStateSchemaRelationsCondition } from "./ShapeStateSchemaRelationsCondition";
 import { StateSchema } from "../StateSchema";
 export declare class SameVoxelCondition extends ShapeStateSchemaRelationsCondition {

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

@@ -0,0 +1,17 @@
+import { ShapeStateSchemaRelationsCondition } from "./ShapeStateSchemaRelationsCondition";
+export class SameVoxelCondition extends ShapeStateSchemaRelationsCondition {
+    data;
+    constructor(schema, data) {
+        super(schema);
+        this.data = data;
+    }
+    evulate() {
+        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];
+        const nVoxel = this.schema.dataCursor.getVoxel(nx, ny, nz);
+        if (!nVoxel)
+            return false;
+        return this.schema.voxel.isSameVoxel(nVoxel);
+    }
+}

package/{VoxelModels → Voxels}/State/Schema/StateSchema.d.ts

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

package/{VoxelModels → Voxels}/State/Schema/StateSchema.js

@@ -1,10 +1,11 @@
 import { ShapeStateRelationsNode } from "./ShapeStateRelationsNode";
 import { BinarySchemaNode } from "./BinarySchemaNode";
-import { DataTool } from "../../../Tools/Data/DataTool";
+import { Vector3Like } from "@amodx/math";
 export class StateSchema {
-    voxel = new DataTool();
-    nVoxel = new DataTool();
     nodes = [];
+    position = Vector3Like.Create();
+    voxel;
+    dataCursor;
     constructor(schema) {
         for (const node of schema) {
             if (node.type == "binary") {

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

@@ -0,0 +1,7 @@
+import { BinarySchema } from "./BinarySchema";
+export declare class VoxelSceham {
+    id: string;
+    shapeState: BinarySchema;
+    modState: BinarySchema;
+    constructor(id: string, shapeState: BinarySchema, modState: BinarySchema);
+}

package/Voxels/State/Schema/VoxelSchema.js

@@ -0,0 +1,10 @@
+export class VoxelSceham {
+    id;
+    shapeState;
+    modState;
+    constructor(id, shapeState, modState) {
+        this.id = id;
+        this.shapeState = shapeState;
+        this.modState = modState;
+    }
+}

package/{VoxelModels → Voxels}/State/SchemaRegister.d.ts

@@ -1,15 +1,15 @@
 import { BinarySchema } from "./Schema/BinarySchema";
+import { VoxelSceham } from "./Schema/VoxelSchema";
 import { BinarySchemaNodeData, VoxelModelStateSchemaData } from "./State.types";
 export declare class SchemaRegister {
-    static modelStaeSchemaData: Map<string, BinarySchemaNodeData[]>;
+    static modelStaeBaseSchemaData: Map<string, VoxelModelStateSchemaData[]>;
+    static modelStateSchemaData: 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 voxelSchemas: Map<string, VoxelSceham>;
+    static getVoxelSchemas(voxelId: string): VoxelSceham;
     static registerModel(id: string, data: VoxelModelStateSchemaData[]): void;
     static registerVoxel(id: string, modelId: string, data: VoxelModelStateSchemaData[]): void;
 }

package/Voxels/State/SchemaRegister.js

@@ -0,0 +1,56 @@
+import { BinarySchema } from "./Schema/BinarySchema";
+import { VoxelSceham } from "./Schema/VoxelSchema";
+export class SchemaRegister {
+    static modelStaeBaseSchemaData = new Map();
+    static modelStateSchemaData = new Map();
+    static voxelModSchemaData = new Map();
+    static modelStaeSchemas = new Map();
+    static voxelModSchemas = new Map();
+    static voxelModelMap = new Map();
+    static voxelSchemas = new Map();
+    static getVoxelSchemas(voxelId) {
+        if (this.voxelSchemas.has(voxelId)) {
+            return this.voxelSchemas.get(voxelId);
+        }
+        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);
+            if (!schemaData)
+                throw new Error(`Model ${modelId} is not registered`);
+            shapeStateSchema = new BinarySchema(schemaData);
+        }
+        let modSchema = this.voxelModSchemas.get(voxelId);
+        if (!modSchema) {
+            const schemaData = this.voxelModSchemaData.get(voxelId);
+            if (!schemaData)
+                throw new Error(`Voxel ${voxelId} is not registered`);
+            modSchema = new BinarySchema(schemaData);
+        }
+        const voxelSchema = new VoxelSceham(voxelId, shapeStateSchema, 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);
+    }
+    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 → Voxels}/State/State.types.d.ts

@@ -1,4 +1,27 @@
-import { VoxelModelRelationsConditionData } from "../VoxelModel.types";
+import { Vec3Array } from "@amodx/math";
+export interface VoxelStateStringSchemaData {
+    name: string;
+    type: "string";
+    values: Record<number, string>;
+}
+export interface VoxelStateNumberSchemaData {
+    name: string;
+    type: "number";
+    maxValue: number;
+}
+export interface SameVoxelRelationsConditionData {
+    type: "same-voxel";
+    direction: Vec3Array;
+}
+export interface AnyVoxelRelationsConditionData {
+    type: "any-voxel";
+    direction: Vec3Array;
+}
+export type VoxelStateRelationsConditionData = SameVoxelRelationsConditionData | AnyVoxelRelationsConditionData;
+export interface VoxelModelRelationsSchemaData {
+    name: string;
+    conditions: VoxelStateRelationsConditionData[];
+}
 export type BinarySchemaNodeData = {
     id: string;
     type: "binary";
@@ -9,7 +32,7 @@ export type BinarySchemaNodeData = {
 export type VoxelRelationsScehmaNodeData = {
     id: string;
     type: "relation";
-    conditions: VoxelModelRelationsConditionData[];
+    conditions: VoxelStateRelationsConditionData[];
 };
 export type VoxelModelStateSchemaData = BinarySchemaNodeData | VoxelRelationsScehmaNodeData;
 export declare enum StateCompareOperations {

package/{VoxelModels → Voxels}/State/StateTreeReader.d.ts

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

package/{VoxelModels → Voxels}/State/StateTreeReader.js

@@ -20,6 +20,9 @@ export class StateTreeReader {
             if (typeof curretNode == "number") {
                 return curretNode;
             }
+            if (curretNode === undefined) {
+                return -1;
+            }
             for (let i = 0; i < curretNode.length; i++) {
                 if (curretNode[i]) {
                     index = i;

package/Voxels/State/VoxelTagStates.d.ts

@@ -0,0 +1,22 @@
+import { StateSchema } from "./Schema/StateSchema";
+import { StateTreeReader } from "./StateTreeReader";
+export type VoxelTagStatesData = Record<string, {
+    tree: any;
+    treePalette: any;
+}>[];
+export declare class VoxelTagStates {
+    static voxelTags: Record<string, {
+        tree: StateTreeReader;
+        treePalette: any[];
+    }>[];
+    static toJSON(): VoxelTagStatesData;
+    static load(data: VoxelTagStatesData): void;
+    static register(voxel: number, id: string, stateSchema: StateSchema, tree: any[], treePalette: any[]): void;
+    static isRegistered(voxel: number, id: string): boolean;
+    static getData(voxel: number, id: string): {
+        tree: StateTreeReader;
+        treePalette: any[];
+    };
+    static getState(voxel: number, id: string, state: number): number;
+    static getValue(voxel: number, id: string, state: number): any;
+}

package/Voxels/State/VoxelTagStates.js

@@ -0,0 +1,47 @@
+import { VoxelPalette } from "../../Data/Palettes/VoxelPalette";
+import { StateSchema } from "./Schema/StateSchema";
+import { StateTreeReader } from "./StateTreeReader";
+import { SchemaRegister } from "./SchemaRegister";
+export class VoxelTagStates {
+    static voxelTags = [];
+    static toJSON() {
+        const data = [];
+        this.voxelTags.forEach((v, index) => {
+            data[index] = Object.fromEntries(Object.keys(v).map((k) => [
+                k,
+                { tree: v[k].tree.tree, treePalette: v[k].treePalette },
+            ]));
+        });
+        return data;
+    }
+    static load(data) {
+        data.forEach((v, index) => {
+            if (!v)
+                return;
+            const stateSceham = new StateSchema(SchemaRegister.modelStaeBaseSchemaData.get(SchemaRegister.voxelModelMap.get(VoxelPalette.ids.getStringId(index))));
+            for (const tag in v) {
+                this.register(index, tag, stateSceham, v[tag].tree, v[tag].treePalette);
+            }
+        });
+    }
+    static register(voxel, id, stateSchema, tree, treePalette) {
+        let tags = this.voxelTags[voxel];
+        if (!tags) {
+            tags = {};
+            this.voxelTags[voxel] = tags;
+        }
+        tags[id] = { tree: new StateTreeReader(stateSchema, 0, tree), treePalette };
+    }
+    static isRegistered(voxel, id) {
+        return this.voxelTags[voxel] && this.voxelTags[voxel][id] !== undefined;
+    }
+    static getData(voxel, id) {
+        return this.voxelTags[voxel][id];
+    }
+    static getState(voxel, id, state) {
+        return this.voxelTags[voxel][id].tree.getState(state);
+    }
+    static getValue(voxel, id, state) {
+        return this.voxelTags[voxel][id].treePalette[this.voxelTags[voxel][id].tree.getState(state)];
+    }
+}

package/Voxels/Voxel.types.d.ts

@@ -0,0 +1,94 @@
+import { ConstructorTextureData } from "../Textures/Constructor.types";
+import { VoxelModelConstructorData } from "../Models/VoxelModel.types";
+export type VoxelNamedStateData = {
+    id: string;
+    name?: string;
+    state?: string;
+    mod?: string;
+    properties: {
+        [key: string]: any;
+    };
+    display: {
+        type: "texture";
+        source: ConstructorTextureData | string;
+    } | {
+        type: "model";
+        state?: string;
+        mod?: string;
+    };
+};
+/**
+ * An array representing the raw data of a voxel.
+ */
+export type RawVoxelData = [
+    /**The id of the voxel */
+    id: number,
+    /**The light of the voxel */
+    light: number,
+    /**The state of the voxel */
+    state: number,
+    /**The secondary id of the voxel */
+    secondaryId: number,
+    /**The mod of the voxel */
+    mod: number
+];
+export declare enum VoxelStructIds {
+    substance = "dve_substance",
+    shapeID = "dve_shape_id",
+    renderedMaterial = "dve_rendered_material",
+    voxelMaterial = "dve_voxel_material",
+    hardness = "dve_hardness",
+    colliderID = "dve_collider_id",
+    checkCollisions = "dve_check_collisions",
+    isLightSource = "dve_is_light_source",
+    noAO = "dve_no_ao",
+    isTransparent = "dve_is_transparent",
+    lightValue = "dve_light_value",
+    isRich = "dve_is_rich",
+    canHaveSecondary = "dve_can_have_secondary"
+}
+interface VoxelProperties {
+    [key: string]: any;
+    /** The material used to render the voxel. Used by the engine to assign meshes to the proper material. */
+    [VoxelStructIds.renderedMaterial]?: string;
+    /** A description of the material used for the voxel. Not used by the engine directly. */
+    [VoxelStructIds.voxelMaterial]?: string;
+    /** Specifies the substance of the voxel.
+     * The voxel will inherit properties from the substance and change how it acts in the world.
+     * Properties include being solid or liquid.
+     * */
+    [VoxelStructIds.substance]?: string;
+    /** Indicates whether the voxel is a light source. */
+    [VoxelStructIds.isLightSource]?: boolean;
+    /** Indicates if the voxel lets light through */
+    [VoxelStructIds.isTransparent]?: boolean;
+    /** Disables ambient occlusion for this voxel if set to true. */
+    [VoxelStructIds.noAO]?: boolean;
+    /** Defines the light value emitted by the voxel (r, g, z). */
+    [VoxelStructIds.lightValue]?: [r: number, g: number, z: number];
+    /** The collider ID for the voxel, used for collision detection. */
+    [VoxelStructIds.colliderID]?: string;
+    /** Specifies if the voxel participates in collision checks. */
+    [VoxelStructIds.checkCollisions]?: boolean;
+    /** Indicates if the voxel can have a secondary voxel. */
+    [VoxelStructIds.canHaveSecondary]?: boolean;
+    /** The hardness level of the voxel, affecting how it is broken or interacted with. */
+    [VoxelStructIds.hardness]?: number;
+    /** Marks the voxel as "rich" for specialized interactions or rendering. */
+    [VoxelStructIds.isRich]?: boolean;
+    /** Named states associated with the voxel. */
+    dve_named_states?: VoxelNamedStateData[];
+    /** Model data used to construct the voxel's appearance. */
+    dve_model_data?: VoxelModelConstructorData;
+}
+export interface VoxelData {
+    /**The id of the voxel. This should not change and must be unique. Can be used durning runtime to refernce voxels. */
+    id: string;
+    /**The name of the voxel. This can change but must be unique. Can be used durning runtime to refernce voxels. */
+    name?: string;
+    /**The title of the voxel. This can change and does not have to be unique. Cannot be used to refernce a voxel.  */
+    title?: string;
+    /**The properties of the voxel. */
+    properties: VoxelProperties;
+}
+export {};

package/Voxels/Voxel.types.js

@@ -0,0 +1,16 @@
+export var VoxelStructIds;
+(function (VoxelStructIds) {
+    VoxelStructIds["substance"] = "dve_substance";
+    VoxelStructIds["shapeID"] = "dve_shape_id";
+    VoxelStructIds["renderedMaterial"] = "dve_rendered_material";
+    VoxelStructIds["voxelMaterial"] = "dve_voxel_material";
+    VoxelStructIds["hardness"] = "dve_hardness";
+    VoxelStructIds["colliderID"] = "dve_collider_id";
+    VoxelStructIds["checkCollisions"] = "dve_check_collisions";
+    VoxelStructIds["isLightSource"] = "dve_is_light_source";
+    VoxelStructIds["noAO"] = "dve_no_ao";
+    VoxelStructIds["isTransparent"] = "dve_is_transparent";
+    VoxelStructIds["lightValue"] = "dve_light_value";
+    VoxelStructIds["isRich"] = "dve_is_rich";
+    VoxelStructIds["canHaveSecondary"] = "dve_can_have_secondary";
+})(VoxelStructIds || (VoxelStructIds = {}));

package/Voxels/VoxelMaterial.types.d.ts

@@ -0,0 +1,8 @@
+export interface VoxelMaterialProperties {
+    [key: string]: any;
+    dve_is_transparent?: boolean;
+}
+export type VoxelMaterialData = {
+    id: string;
+    properties?: VoxelMaterialProperties;
+};

package/Voxels/VoxelSubstances.types.d.ts

@@ -0,0 +1,21 @@
+export declare enum SubstanceStructIds {
+    parent = "dve_parent_substance",
+    isSolid = "dve_is_solid",
+    isTransparent = "dve_is_transparent",
+    isLiquid = "dve_is_liquid",
+    flowRate = "dve_flow_rate",
+    isWindAffected = "dve_is_wind_affected"
+}
+export interface VoxelSubstanceDataProperties {
+    [key: string]: any;
+    [SubstanceStructIds.parent]?: string;
+    [SubstanceStructIds.isTransparent]?: boolean;
+    [SubstanceStructIds.isSolid]?: boolean;
+    [SubstanceStructIds.isLiquid]?: boolean;
+    [SubstanceStructIds.flowRate]?: number;
+    [SubstanceStructIds.isWindAffected]?: boolean;
+}
+export type VoxelSubstanceData = {
+    id: string;
+    properties: VoxelSubstanceDataProperties;
+};

package/Voxels/VoxelSubstances.types.js

@@ -0,0 +1,9 @@
+export var SubstanceStructIds;
+(function (SubstanceStructIds) {
+    SubstanceStructIds["parent"] = "dve_parent_substance";
+    SubstanceStructIds["isSolid"] = "dve_is_solid";
+    SubstanceStructIds["isTransparent"] = "dve_is_transparent";
+    SubstanceStructIds["isLiquid"] = "dve_is_liquid";
+    SubstanceStructIds["flowRate"] = "dve_flow_rate";
+    SubstanceStructIds["isWindAffected"] = "dve_is_wind_affected";
+})(SubstanceStructIds || (SubstanceStructIds = {}));

package/{VoxelModels/VoxelModelRules.types.d.ts → Voxels/VoxelSyncData.d.ts}

@@ -1,9 +1,11 @@
 import { Vec3Array } from "@amodx/math";
-import { VoxelAOResultsIndexData } from "./Indexing/VoxelAOResultsIndex";
-import { VoxelFaceCullResultsIndexData } from "./Indexing/VoxelFaceCullResultsIndex";
-import { VoxelFaceTransparentResultsIndexData } from "./Indexing/VoxelFaceTransparentResultsIndex";
-import { VoxelModelStateSchemaData, StateLogicStatement } from "./State/State.types";
-import { VoxelGeometryData, VoxelGeometryNodes } from "./VoxelModel.types";
+import { VoxelAOResultsIndexData } from "../Models/Indexing/VoxelAOResultsIndex";
+import { VoxelFaceCullResultsIndexData } from "../Models/Indexing/VoxelFaceCullResultsIndex";
+import { VoxelFaceTransparentResultsIndexData } from "../Models/Indexing/VoxelFaceTransparentResultsIndex";
+import { VoxelModelStateSchemaData, StateLogicStatement } from "../Voxels/State/State.types";
+import { VoxelGeometryData, VoxelGeometryNodes } from "../Models/VoxelModel.types";
+import { VoxelEffectSyncData } from "../Voxels/Effects/VoxelEffects.types";
+import { VoxelTagStatesData } from "../Voxels/State/VoxelTagStates";
 export interface PrcoessedVoxelGeometryNodes {
     node: VoxelGeometryNodes;
     tranform: VoxelGeometryTransform;
@@ -21,14 +23,14 @@ export interface PrcoessedVoxelGeometryData {
     ogData: VoxelGeometryData;
     nodes: PrcoessedVoxelGeometryNodes[];
 }
-export interface VoxelGeometrySyncData {
+export type VoxelGeometrySyncData = {
     id: string;
     nodes: PrcoessedVoxelGeometryNodes[];
-    faceCullMap: number[][];
-    vertexHitMap: number[][];
-    aoIndex: VoxelAOResultsIndexData;
-    cullIndex: VoxelFaceCullResultsIndexData;
-}
+    faceCullMap?: number[][];
+    vertexHitMap?: number[][];
+    aoIndex?: VoxelAOResultsIndexData;
+    cullIndex?: VoxelFaceCullResultsIndexData;
+};
 export interface VoxelGeometryRulelessSyncData {
     id: string;
     nodes: PrcoessedVoxelGeometryNodes[];
@@ -37,6 +39,7 @@ export interface VoxelGeometryRulelessSyncData {
 export interface VoxelModelSyncData {
     id: string;
     schema: VoxelModelStateSchemaData[];
+    effects: VoxelEffectSyncData[];
     geoLinkMap: number[];
     shapeStateTree: any[];
     shapeStateMap: number[][];
@@ -64,4 +67,5 @@ export interface ConstructorVoxelModelSyncData {
     geometry: (VoxelGeometrySyncData | VoxelGeometryRulelessSyncData)[];
     models: VoxelModelSyncData[];
     voxels: VoxelInputsSyncData[];
+    tagState: VoxelTagStatesData;
 }

package/Voxels/VoxelSyncData.js

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

package/Voxels/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Voxel.types";
+export * from "./VoxelMaterial.types";
+export * from "./VoxelSubstances.types";

package/Voxels/index.js

@@ -0,0 +1,3 @@
+export * from "./Voxel.types";
+export * from "./VoxelMaterial.types";
+export * from "./VoxelSubstances.types";

package/index.d.ts

@@ -0,0 +1 @@
+export * from "./Voxels/Voxel.types";

package/index.js

@@ -0,0 +1 @@
+export * from "./Voxels/Voxel.types";