@divinevoxel/vlox 0.0.73 → 0.0.75

package/Voxels/Functions/BuildPaletteData.js

@@ -0,0 +1,87 @@
+import { SchemaRegister } from "../State/SchemaRegister";
+import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
+import { EngineStats } from "../../Stats/EngineStats";
+function recurse(index, current, result, valuePairs) {
+    if (index === valuePairs.length) {
+        result.push(current.join(","));
+        return;
+    }
+    const [key, values] = valuePairs[index];
+    for (const value of values) {
+        current.push(`${key}=${value}`);
+        recurse(index + 1, current, result, valuePairs);
+        current.pop();
+    }
+}
+function getAllCombinations(valuePairs) {
+    const result = [];
+    recurse(0, [], result, valuePairs);
+    return result;
+}
+export function BuildPaletteData(props) {
+    const models = new Map(props.models.models.map((_) => [_.id, _]));
+    const modelStateArray = new Map();
+    for (const [, model] of models) {
+        const schema = SchemaRegister.getModelSchema(model.id);
+        const valuePairs = [];
+        for (const node of schema.nodes) {
+            valuePairs.push([
+                node.name,
+                node.valuePalette
+                    ? node.valuePalette._palette
+                    : new Array(node.bitMask + 1).fill(0).map((_, i) => `${i}`),
+            ]);
+        }
+        const stateStrings = getAllCombinations(valuePairs);
+        const statePalette = [];
+        for (const state of stateStrings) {
+            const value = schema.readString(!state ? "*" : state);
+            statePalette.push(value);
+        }
+        modelStateArray.set(model.id, statePalette);
+    }
+    const finalPalette = [[0, 0, 0]];
+    const finalPaletteRecord = [[[0]]];
+    let paletteCount = 1;
+    for (const voxel of props.models.voxels) {
+        const schema = SchemaRegister.getVoxelModSchema(voxel.id);
+        const valuePairs = [];
+        for (const node of schema.nodes) {
+            valuePairs.push([
+                node.name,
+                node.valuePalette
+                    ? node.valuePalette._palette
+                    : new Array(node.bitMask + 1).fill(0).map((_, i) => `${i}`),
+            ]);
+        }
+        const stateStrings = getAllCombinations(valuePairs);
+        const modPalette = [];
+        if (valuePairs.length) {
+            for (const state of stateStrings) {
+                const value = schema.readString(!state ? "*" : state);
+                modPalette.push(value);
+            }
+        }
+        else {
+            modPalette.push(0);
+        }
+        const voxelId = VoxelPalettesRegister.voxelIds.getNumberId(voxel.id);
+        const statePalette = modelStateArray.get(voxel.modelId);
+        finalPaletteRecord[voxelId] = new Array(modPalette.length).fill(-1);
+        for (let modIndex = 0; modIndex < modPalette.length; modIndex++) {
+            finalPaletteRecord[voxelId][modPalette[modIndex]] = new Array(statePalette.length).fill(-1);
+            for (let stateIndex = 0; stateIndex < statePalette.length; stateIndex++) {
+                finalPalette[paletteCount] = [
+                    voxelId,
+                    statePalette[stateIndex],
+                    modPalette[modIndex],
+                ];
+                finalPaletteRecord[voxelId][modPalette[modIndex]][statePalette[stateIndex]] = paletteCount;
+                paletteCount++;
+            }
+        }
+    }
+    EngineStats.palette.paletteSize = finalPalette.length;
+    VoxelPalettesRegister.voxels = finalPalette;
+    VoxelPalettesRegister.voxelRecord = finalPaletteRecord;
+}

package/Voxels/Functions/BuildStateData.d.ts

@@ -1,25 +1,23 @@
-import { BinarySchemaNodeData, VoxelRelationsScehmaNodeData, StateLogicStatement } from "../State/State.types";
-import { VoxelRulesModoel } from "../../Models/Rules/Classes/VoxelRulesModel";
+import { StateLogicStatement, VoxelStateSchemaData } from "../State/State.types";
+import { VoxelRulesModoel } from "../Models/Rules/Classes/VoxelRulesModel";
 import { StringPalette } from "../../Util/StringPalette";
 import { VoxelEffectSyncData } from "../Effects/VoxelEffects.types";
 export declare function BuildStateData(model: VoxelRulesModoel, geoPalette: StringPalette): {
-    schema: (BinarySchemaNodeData | VoxelRelationsScehmaNodeData)[];
+    schema: VoxelStateSchemaData;
     effects: VoxelEffectSyncData[];
-    shapeStateGeometryPalette: number[][];
+    stateGeometryPalette: number[][];
     condiotnalShapeStateGeometryPalette: number[][];
-    shapeStateTree: any[];
-    geometryLinkPalette: Record<string, number>;
-    geometryLinkStateMap: number[];
-    relativeByteCount: number;
-    shapeStatePalette: number[][];
-    shapeStateRecord: Record<string, number>;
+    stateTree: any[];
+    geometryLinkStateMap: Record<string, Record<number, number>>;
+    statePalette: number[][];
+    stateRecord: Record<string, number>;
     condiotnalNodeStateTree: any;
     condiotnalStatements: StateLogicStatement[];
-    condiotnalShapeStatePalette: number[][];
+    condiotnalStatePalette: number[][];
     condiotnalShapeStateRecord: Record<string, number>;
     condiotanlStatePalette: number[][][];
     condiotanlGeometryStatePalette: number[][][];
-    shapeStateRelativeGeometryMap: number[][];
+    stateRelativeGeometryMap: number[][];
     relativeGeometryByteIndexMap: number[];
     condiotnalShapeStateRelativeGeometryMap: number[][];
 };

package/Voxels/Functions/BuildStateData.js

@@ -1,19 +1,6 @@
 import { StateCompareOperationsMap, StateLogicOperationsMap, } from "../State/State.types";
 import { StringPalette } from "../../Util/StringPalette";
-import { VoxelModelRuleBuilderRegister } from "../../Models/Rules/VoxelModelRuleBuilderRegister";
-import { VoxelTagStates } from "../Data/VoxelTagStates";
-import { VoxelPalettesRegister } from "../Data/VoxelPalettesRegister";
-import { StateSchema } from "../State/Schema/StateSchema";
-function bitsNeeded(n) {
-    if (n < 0)
-        throw new Error("Input must be a non-negative integer.");
-    let bits = 0;
-    while (n > 0) {
-        bits++;
-        n >>= 1;
-    }
-    return bits;
-}
+import { VoxelModelRuleBuilderRegister } from "../Models/Rules/VoxelModelRuleBuilderRegister";
 class StateTreeNode {
     id;
     children = new Map();
@@ -116,51 +103,23 @@ function reMapTree(schemaIdPalette, schemaValuePalette, baseObj, newObj, modelOr
     return newObj;
 }
 function buildSchemas(binaryNodes, relationNodes) {
-    const baseSchema = [];
+    const baseSchema = {
+        binary: [],
+        relational: [],
+    };
     const schemaIdPalette = new StringPalette();
     const schemaValuePalette = new Map();
-    {
-        let bitIndex = 0;
-        for (const schemaNode of binaryNodes) {
-            schemaIdPalette.register(schemaNode.name);
-            const maxBits = bitsNeeded(schemaNode.type == "string"
-                ? Object.keys(schemaNode.values)
-                    .map((_) => Number(_))
-                    .sort((a, b) => a - b)
-                    .pop()
-                : schemaNode.maxValue);
-            const nodeData = {
-                id: schemaNode.name,
-                type: "binary",
-                index: bitIndex,
-                mask: (1 << maxBits) - 1,
-            };
-            bitIndex += maxBits;
-            if (schemaNode.type == "string") {
-                const valuePalette = new StringPalette();
-                for (const vIndex in schemaNode.values) {
-                    const vValue = schemaNode.values[vIndex];
-                    valuePalette.register(vValue);
-                }
-                schemaValuePalette.set(schemaNode.name, valuePalette);
-                nodeData.valuePalette = valuePalette._palette;
-            }
-            baseSchema.push(nodeData);
+    for (const schemaNode of binaryNodes) {
+        schemaIdPalette.register(schemaNode.name);
+        if (schemaNode.values) {
+            schemaValuePalette.set(schemaNode.name, new StringPalette(schemaNode.values));
         }
+        baseSchema.binary.push(schemaNode);
     }
-    {
-        for (const schemaNode of relationNodes) {
-            schemaIdPalette.register(schemaNode.name);
-            baseSchema.push({
-                id: schemaNode.name,
-                type: "relation",
-                conditions: schemaNode.conditions,
-            });
-            const valuePalette = new StringPalette();
-            valuePalette.register("false");
-            valuePalette.register("true");
-            schemaValuePalette.set(schemaNode.name, valuePalette);
-        }
+    for (const schemaNode of relationNodes) {
+        schemaIdPalette.register(schemaNode.name);
+        baseSchema.relational.push(schemaNode);
+        schemaValuePalette.set(schemaNode.name, new StringPalette(["false", "true"]));
     }
     return {
         baseSchema,
@@ -170,56 +129,51 @@ function buildSchemas(binaryNodes, relationNodes) {
 }
 export function BuildStateData(model, geoPalette) {
     const data = model.data;
-    const { baseSchema, schemaIdPalette, schemaValuePalette } = buildSchemas(data.shapeStateSchema, data.relationsSchema);
-    const geometryLinkPalette = new StringPalette();
+    const { baseSchema, schemaIdPalette, schemaValuePalette } = buildSchemas(data.stateSchema, data.relationsSchema);
     //maps geo link ids to geomtry ids
-    const geometryLinkStateMap = [];
-    const log = model.data.id == "dve_simple_stair";
+    const geometryLinkStateMap = {};
     //add geomtry from main shape states
-    for (const key in data.shapeStatesNodes) {
-        const nodeData = data.shapeStatesNodes[key];
-        for (const node of nodeData) {
-            if (geometryLinkPalette.isRegistered(node.id))
-                continue;
-            const linkId = geometryLinkPalette.register(node.id);
-            geometryLinkStateMap[linkId] = geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node));
+    for (const key in data.stateNodes) {
+        const nodeData = data.stateNodes[key];
+        for (let i = 0; i < nodeData.length; i++) {
+            geometryLinkStateMap[key] ??= {};
+            const node = nodeData[i];
+            geometryLinkStateMap[key][i] ??= geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node));
         }
     }
     //add geomtry from condiotnal  shape states
-    for (const key in data.shapeStatesConditonalNodes) {
-        const nodeData = data.shapeStatesConditonalNodes[key];
-        for (const node of nodeData) {
-            if (geometryLinkPalette.isRegistered(node.id))
-                continue;
-            const linkId = geometryLinkPalette.register(node.id);
-            geometryLinkStateMap[linkId] = geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node));
+    for (const key in data.conditonalNodes) {
+        const nodeData = data.conditonalNodes[key];
+        for (let i = 0; i < nodeData.length; i++) {
+            geometryLinkStateMap[key] ??= {};
+            const node = nodeData[i];
+            geometryLinkStateMap[key][i] ??= geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node));
         }
     }
-    const shapeStateRelativeGeometryMap = [];
+    const stateRelativeGeometryMap = [];
     const relativeGeometryByteIndexMap = [];
     //build state trees
-    const shapeStateTree = new StateTreeNode("root");
-    const shapeStateGeoLinkPalette = [];
-    const shapeStateGeometryPalette = [];
+    const stateTree = new StateTreeNode("root");
+    const stateGeoLinkPalette = [];
+    const stateGeometryPalette = [];
     let relativeGeoId = 0;
     let relativeByteCount = 0;
-    const shapeStateRecord = {};
-    for (const key in data.shapeStatesNodes) {
-        shapeStateGeoLinkPalette.push(data.shapeStatesNodes[key].map((_) => geometryLinkPalette.getNumberId(_.id)));
-        shapeStateGeometryPalette.push(data.shapeStatesNodes[key].map((_) => geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(_))));
-        shapeStateRecord[key] = shapeStateGeometryPalette.length - 1;
-        shapeStateRelativeGeometryMap[shapeStateRecord[key]] ??= [];
-        const nodeData = data.shapeStatesNodes[key];
+    const stateRecord = {};
+    for (const key in data.stateNodes) {
+        stateGeoLinkPalette.push(data.stateNodes[key].map((_, index) => geometryLinkStateMap[key][index]));
+        stateGeometryPalette.push(data.stateNodes[key].map((_) => geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(_))));
+        stateRecord[key] = stateGeometryPalette.length - 1;
+        stateRelativeGeometryMap[stateRecord[key]] ??= [];
+        const nodeData = data.stateNodes[key];
         for (const node of nodeData) {
-            shapeStateRelativeGeometryMap[shapeStateRecord[key]][geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node))] = relativeGeoId;
+            stateRelativeGeometryMap[stateRecord[key]][geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node))] = relativeGeoId;
             relativeGeometryByteIndexMap[relativeGeoId] = relativeByteCount;
             relativeGeoId++;
-            relativeByteCount += Math.ceil(VoxelModelRuleBuilderRegister.getGeomtryFromLink(node).faceCount / 8);
         }
-        addPathToTree(shapeStateTree, key
+        addPathToTree(stateTree, key
             .split(",")
             .map((pair) => pair.split("="))
-            .flat(), shapeStateGeoLinkPalette.length - 1);
+            .flat(), stateGeoLinkPalette.length - 1);
     }
     const condiotnalShapeStateRelativeGeometryMap = [];
     const condiotnalShapeStateNodePalette = [];
@@ -227,19 +181,17 @@ export function BuildStateData(model, geoPalette) {
     const condiotnalShapeStateNodeRecord = {};
     const condiotnalStatements = [];
     const compareOperations = Object.keys(StateCompareOperationsMap);
-    for (const key in data.shapeStatesConditonalNodes) {
-        condiotnalShapeStateNodePalette.push(data.shapeStatesConditonalNodes[key].map((_) => geometryLinkPalette.getNumberId(_.id)));
-        condiotnalShapeStateGeometryPalette.push(data.shapeStatesConditonalNodes[key].map((_) => geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(_))));
+    for (const key in data.conditonalNodes) {
+        condiotnalShapeStateNodePalette.push(data.conditonalNodes[key].map((_, index) => geometryLinkStateMap[key][index]));
+        condiotnalShapeStateGeometryPalette.push(data.conditonalNodes[key].map((_) => geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(_))));
         condiotnalShapeStateNodeRecord[key] =
             condiotnalShapeStateGeometryPalette.length - 1;
         condiotnalShapeStateRelativeGeometryMap[condiotnalShapeStateNodeRecord[key]] ??= [];
-        const nodeData = data.shapeStatesConditonalNodes[key];
+        const nodeData = data.conditonalNodes[key];
         for (const node of nodeData) {
-            condiotnalShapeStateRelativeGeometryMap[condiotnalShapeStateNodeRecord[key]][geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node))] =
-                relativeGeoId;
+            condiotnalShapeStateRelativeGeometryMap[condiotnalShapeStateNodeRecord[key]][geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node))] = relativeGeoId;
             relativeGeometryByteIndexMap[relativeGeoId] = relativeByteCount;
             relativeGeoId++;
-            relativeByteCount += Math.ceil(VoxelModelRuleBuilderRegister.getGeomtryFromLink(node).faceCount / 8);
         }
         const statement = [];
         const nodes = key.split(" ");
@@ -290,9 +242,9 @@ export function BuildStateData(model, geoPalette) {
         condiotanlStatePalette.push(newStateCombo);
         condiotanlGeometryStatePalette.push(newGeoCombo);
     }
-    const shapeStateTreeData = shapeStateTree.toJSON();
+    const stateTreeData = stateTree.toJSON();
     const newShapeStateTree = [];
-    reMapTree(schemaIdPalette, schemaValuePalette, shapeStateTreeData, newShapeStateTree, model.data.id);
+    reMapTree(schemaIdPalette, schemaValuePalette, stateTreeData, newShapeStateTree, model.data.id);
     const modelEffects = [];
     const tagEffects = [];
     if (model.data.effects) {
@@ -328,14 +280,10 @@ export function BuildStateData(model, geoPalette) {
             }
         }
     }
-    const schema = new StateSchema(baseSchema);
     for (const [voxelId, voxelData] of model.voxels) {
         const modeStateTree = new StateTreeNode("root");
         const modStatePalette = [];
         const modStateRecord = {};
-        for (const tag of tagEffects) {
-            VoxelTagStates.register(VoxelPalettesRegister.voxels.getNumberId(voxelId), tag.tagId, schema, tag.tree, tag.treePalette);
-        }
         const { baseSchema, schemaIdPalette, schemaValuePalette } = buildSchemas(voxelData.modSchema || [], voxelData.modRelationSchema || []);
         for (const key in voxelData.inputs) {
             modStatePalette.push(voxelData.inputs[key]);
@@ -358,21 +306,19 @@ export function BuildStateData(model, geoPalette) {
     const finalData = {
         schema: baseSchema,
         effects: modelEffects,
-        shapeStateGeometryPalette,
+        stateGeometryPalette: stateGeometryPalette,
         condiotnalShapeStateGeometryPalette,
-        shapeStateTree: newShapeStateTree,
-        geometryLinkPalette: geometryLinkPalette._map,
+        stateTree: newShapeStateTree,
         geometryLinkStateMap,
-        relativeByteCount,
-        shapeStatePalette: shapeStateGeoLinkPalette,
-        shapeStateRecord,
+        statePalette: stateGeoLinkPalette,
+        stateRecord: stateRecord,
         condiotnalNodeStateTree,
         condiotnalStatements,
-        condiotnalShapeStatePalette: condiotnalShapeStateNodePalette,
+        condiotnalStatePalette: condiotnalShapeStateNodePalette,
         condiotnalShapeStateRecord: condiotnalShapeStateNodeRecord,
         condiotanlStatePalette,
         condiotanlGeometryStatePalette,
-        shapeStateRelativeGeometryMap,
+        stateRelativeGeometryMap: stateRelativeGeometryMap,
         relativeGeometryByteIndexMap,
         condiotnalShapeStateRelativeGeometryMap,
     };

package/Voxels/Functions/{BuildTagAndPaletteData.d.ts → BuildTagData.d.ts}

@@ -2,7 +2,7 @@ import { VoxelData } from "../Types/Voxel.types";
 import { VoxelMaterialData } from "../Types/VoxelMaterial.types";
 import { VoxelSubstanceData } from "../Types/VoxelSubstances.types";
 import { CompiledVoxelTagAndPaletteData } from "../Types/VoxelModelCompiledData.types";
-export type BuildTagAndPaletteDataProps = {
+export type BuildTagDataProps = {
     voxels: VoxelData[];
     voxelsOverrides?: Record<string, (value: any) => any>;
     substances: VoxelSubstanceData[];
@@ -10,4 +10,4 @@ export type BuildTagAndPaletteDataProps = {
     materials: VoxelMaterialData[];
     materialsOverrides?: Record<string, (value: any) => any>;
 };
-export declare function BuildTagAndPaletteData(props: BuildTagAndPaletteDataProps): CompiledVoxelTagAndPaletteData;
+export declare function BuildTagAndPaletteData(props: BuildTagDataProps): CompiledVoxelTagAndPaletteData;

package/Voxels/Functions/{BuildTagAndPaletteData.js → BuildTagData.js}

@@ -1,11 +1,34 @@
 import { VoxelTagsRegister } from "../Data/VoxelTagsRegister";
 import { VoxelPalettesRegister } from "../Data/VoxelPalettesRegister";
+import { VoxelModelRuleBuilderRegister } from "../Models/Rules/VoxelModelRuleBuilderRegister";
+import { VoxelPropertiesRegister } from "../Data/VoxelPropertiesRegister";
+import { VoxelPlacingStrategyRegister } from "../../Voxels/Interaction/Placing/VoxelPlacingStrategyRegister";
 export function BuildTagAndPaletteData(props) {
+    const logic = {};
     for (const voxel of props.voxels) {
         const tags = {};
-        const voxelId = VoxelPalettesRegister.voxels.register(voxel.id);
+        if (VoxelPalettesRegister.voxelIds._map[voxel.id] !== undefined) {
+            throw new Error(`Voxel with id [${voxel.id}] is already registered.`);
+        }
+        const voxelId = VoxelPalettesRegister.voxelIds.register(voxel.id);
+        VoxelPropertiesRegister.VoxelProperties[voxelId] = voxel.properties;
+        if (voxel.properties["dve_model_data"]) {
+            tags["dve_model_id"] = voxel.properties["dve_model_data"].id;
+            const model = VoxelModelRuleBuilderRegister.models.get(voxel.properties["dve_model_data"].id);
+            if (model?.data.properties) {
+                for (const tagId in model.data.properties) {
+                    voxel.properties[tagId] = model.data.properties[tagId];
+                }
+            }
+        }
+        if (voxel.properties["dve_placing_strategy"]) {
+            VoxelPlacingStrategyRegister.register(voxel.id, voxel.properties["dve_placing_strategy"]);
+        }
         VoxelPalettesRegister.voxelIdToNameMap.set(voxel.id, voxel.name || "");
         VoxelPalettesRegister.voxelNametoIdMap.set(voxel.name || voxel.id, voxel.id);
+        if (voxel.properties["dve_logic_data"]) {
+            logic[voxel.id] = voxel.properties["dve_logic_data"];
+        }
         for (const tag of VoxelTagsRegister.IncludedVoxelTags) {
             if (voxel.properties[tag] === undefined) {
                 tags[tag] = VoxelTagsRegister.VoxelTagDefaults[tag] || false;
@@ -41,7 +64,10 @@ export function BuildTagAndPaletteData(props) {
     }
     return {
         data: {
-            palette: VoxelPalettesRegister.voxels._palette,
+            logic,
+            palette: [],
+            record: [],
+            idPalette: VoxelPalettesRegister.voxelIds._palette,
             tags: VoxelTagsRegister.VoxelTags,
             idToNameMap: [...VoxelPalettesRegister.voxelIdToNameMap.entries()],
             nameToIdMap: [...VoxelPalettesRegister.voxelNametoIdMap.entries()],

package/Voxels/Indexes/VoxelIndex.d.ts

@@ -1,4 +1,4 @@
-import { PaintVoxelData } from "../Types/Voxel.types";
+import { PaintVoxelData } from "../Types/PaintVoxelData";
 import { VoxelData, RawVoxelData, VoxelNamedStateData } from "../Types/Voxel.types";
 export declare class VoxelNamedState {
     voxelId: string;
@@ -7,8 +7,8 @@ export declare class VoxelNamedState {
     compiled: {
         mod: number;
         modAny: boolean;
-        shapeState: number;
-        shapeStateAny: boolean;
+        state: number;
+        stateAny: boolean;
     };
     constructor(voxelId: string, data: VoxelNamedStateData);
     getPaintData(): PaintVoxelData;

package/Voxels/Indexes/VoxelIndex.js

@@ -1,4 +1,4 @@
-import { PaintVoxelData } from "../Types/Voxel.types";
+import { PaintVoxelData } from "../Types/PaintVoxelData";
 import { SchemaRegister } from "../State/SchemaRegister";
 import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
 export class VoxelNamedState {
@@ -8,8 +8,8 @@ export class VoxelNamedState {
     compiled = {
         mod: 0,
         modAny: false,
-        shapeState: 0,
-        shapeStateAny: false,
+        state: 0,
+        stateAny: false,
     };
     constructor(voxelId, data) {
         this.voxelId = voxelId;
@@ -17,13 +17,13 @@ export class VoxelNamedState {
         for (const key in data.properties) {
             this.tags.set(key, data.properties[key]);
         }
-        if (SchemaRegister.voxelModSchemaData.has(this.voxelId)) {
+        if (SchemaRegister.modSchemaData.has(this.voxelId)) {
             const schema = SchemaRegister.getVoxelSchemas(this.voxelId);
             if (this.data.state == "*") {
-                this.compiled.shapeStateAny = true;
+                this.compiled.stateAny = true;
             }
             else if (this.data.state) {
-                this.compiled.shapeState = schema.state.readString(this.data.state);
+                this.compiled.state = schema.state.readString(this.data.state);
             }
             if (this.data.mod == "*") {
                 this.compiled.modAny = true;
@@ -34,7 +34,7 @@ export class VoxelNamedState {
         }
         else {
             this.compiled.modAny = true;
-            this.compiled.shapeStateAny = true;
+            this.compiled.stateAny = true;
         }
     }
     getPaintData() {
@@ -43,7 +43,7 @@ export class VoxelNamedState {
             id: this.voxelId,
             level: 0,
             levelState: 0,
-            state: this.compiled.shapeState,
+            state: this.compiled.state,
             mod: this.compiled.mod,
         });
     }
@@ -108,25 +108,24 @@ export class VoxelIndex {
         const conatiner = this.states.get(data.id);
         if (!conatiner)
             return false;
-        const { mod, state: shapeState } = data;
-        for (const state of conatiner?.stateArray) {
-            if ((mod == state.compiled.mod || state.compiled.modAny) &&
-                (shapeState == state.compiled.shapeState ||
-                    state.compiled.shapeStateAny))
-                return state;
+        const { mod, state } = data;
+        for (const modelState of conatiner?.stateArray) {
+            if ((mod == modelState.compiled.mod || modelState.compiled.modAny) &&
+                (state == modelState.compiled.state || modelState.compiled.stateAny))
+                return modelState;
         }
         return false;
     }
     getStateFromRawData(data) {
-        const [id, light, shapeState, secondary, mod] = data;
-        const conatiner = this.states.get(VoxelPalettesRegister.voxels.getStringId(id));
+        const [id, light, secondary] = data;
+        const [, mod, state] = VoxelPalettesRegister.voxels[id];
+        const conatiner = this.states.get(VoxelPalettesRegister.voxelIds.getStringId(id));
         if (!conatiner)
             return false;
-        for (const state of conatiner?.stateArray) {
-            if ((mod == state.compiled.mod || state.compiled.modAny) &&
-                (shapeState == state.compiled.shapeState ||
-                    state.compiled.shapeStateAny))
-                return state;
+        for (const modelState of conatiner?.stateArray) {
+            if ((mod == modelState.compiled.mod || modelState.compiled.modAny) &&
+                (state == modelState.compiled.state || modelState.compiled.stateAny))
+                return modelState;
         }
         return false;
     }

package/Voxels/InitVoxelData.d.ts

@@ -1,4 +1,4 @@
-import { VoxelGeometryData, VoxelModelData } from "../Models/VoxelModel.types";
+import { VoxelGeometryData, VoxelModelData } from "./Models/VoxelModel.types";
 import { VoxelData } from "./Types/Voxel.types";
 import { CompiledVoxelData } from "./Types/VoxelModelCompiledData.types";
 import { VoxelMaterialData } from "./Types/VoxelMaterial.types";