@divinevoxel/vlox 0.0.74 → 0.0.76

package/Voxels/Cursor/VoxelCursor.interface.js

@@ -1,68 +1,54 @@
 import { VoxelLightData } from "./VoxelLightData";
 import { VoxelLevelReader } from "./VoxelLevelReader";
-import { VoxelTagStates } from "../Data/VoxelTagStates";
 import { VoxelTagIds, } from "../../Voxels/Data/VoxelTag.types";
 import { VoxelTagsRegister } from "../../Voxels/Data/VoxelTagsRegister";
 import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
 import { VoxelLogicRegister } from "../../Voxels/Logic/VoxelLogicRegister";
+import { SchemaRegister } from "../../Voxels/State/SchemaRegister";
 export class VoxelCursorInterface {
-    _loadedId = 0;
+    _voxelId = 0;
     id = 0;
     secondaryId = 0;
-    _tags = {};
-    _substanceTags = {};
-    __secondary = false;
+    schema;
+    tags = {};
+    substanceTags = {};
+    __readingSecondaryVoxel = false;
     // private _section: Section;
     _index = 0;
     _lightData = new VoxelLightData();
     process() {
         this.id = this.ids[this._index];
         this.secondaryId = this.secondary[this._index];
-        if (this.secondaryId > 1) {
-            this.id = this.secondaryId;
-        }
-        else {
-            this.secondaryId = 0;
-        }
-        this._loadedId = this.getId();
-        this._tags = VoxelTagsRegister.VoxelTags[this._loadedId];
-        this._substanceTags =
-            VoxelTagsRegister.SubstanceStags[VoxelPalettesRegister.substance.getNumberId(this._tags["dve_substance"])];
+        this._voxelId = this.getVoxelId();
+        this.tags = VoxelTagsRegister.VoxelTags[this._voxelId];
+        this.substanceTags =
+            VoxelTagsRegister.SubstanceStags[VoxelPalettesRegister.substance.getNumberId(this.tags["dve_substance"])];
+        this.schema = SchemaRegister.getVoxelSchemas(this.getStringId());
     }
     setSecondary(enable) {
-        this.__secondary = enable;
-        VoxelTagIds;
-        VoxelTagsRegister;
-        this._loadedId = this.getId();
+        this.__readingSecondaryVoxel = enable;
         return this;
     }
     getRenderedMaterial() {
-        return this._tags[VoxelTagIds.renderedMaterial];
+        return this.tags[VoxelTagIds.renderedMaterial];
     }
     getMaterial() {
-        return this._tags[VoxelTagIds.voxelMaterial];
+        return this.tags[VoxelTagIds.voxelMaterial];
     }
     checkCollisions() {
-        return this._tags[VoxelTagIds.checkCollisions];
+        return this.tags[VoxelTagIds.checkCollisions];
     }
     getCollider() {
-        return this._tags[VoxelTagIds.colliderID];
+        return this.tags[VoxelTagIds.colliderID];
     }
     getSubstance() {
-        return this._tags[VoxelTagIds.substance];
+        return this.tags[VoxelTagIds.substance];
     }
     getSubstanceData() {
-        return this._substanceTags;
+        return this.substanceTags;
     }
     isOpaque() {
-        return !this._tags[VoxelTagIds.isTransparent];
-    }
-    getMod() {
-        return this.mod[this._index];
-    }
-    setMod(mod) {
-        this.mod[this._index] = mod;
-        return this;
+        return !this.tags[VoxelTagIds.isTransparent];
     }
     getLevel() {
         return VoxelLevelReader.getLevel(this.level[this._index]);
@@ -78,18 +64,11 @@ export class VoxelCursorInterface {
         this.level[this._index] = VoxelLevelReader.setLevelState(this.level[this._index], state);
         return this;
     }
-    getState() {
-        return this.state[this._index];
-    }
-    setState(state) {
-        this.state[this._index] = state;
-        return this;
-    }
     hasSecondaryVoxel() {
         return this.secondaryId > 1;
     }
     canHaveSecondaryVoxel() {
-        return this._tags[VoxelTagIds.canHaveSecondary];
+        return this.tags[VoxelTagIds.canHaveSecondary];
     }
     hasRGBLight() {
         const light = this.getLight();
@@ -104,16 +83,16 @@ export class VoxelCursorInterface {
         return this._lightData.hasSunLight(light);
     }
     getLight() {
-        if (this._loadedId == 0)
+        if (this._voxelId == 0)
             return this.light[this._index];
         if (this.isOpaque()) {
             if (this.isLightSource()) {
-                return this._tags[VoxelTagIds.lightValue];
+                return this.tags[VoxelTagIds.lightValue];
             }
             return -1;
         }
         if (this.isLightSource()) {
-            return this._lightData.mixLight(this.light[this._index], this._tags[VoxelTagIds.lightValue]);
+            return this._lightData.mixLight(this.light[this._index], this.tags[VoxelTagIds.lightValue]);
         }
         return this.light[this._index];
     }
@@ -122,42 +101,40 @@ export class VoxelCursorInterface {
         return this;
     }
     isLightSource() {
-        if (this._loadedId <= 0)
+        if (this._voxelId <= 0)
             return false;
-        if (VoxelLogicRegister.voxels[this._loadedId]?.hasTag(VoxelTagIds.isLightSource)) {
-            return VoxelLogicRegister.voxels[this._loadedId].getTagValue(VoxelTagIds.isLightSource, this);
+        if (VoxelLogicRegister.voxels[this._voxelId]?.hasTag(VoxelTagIds.isLightSource)) {
+            return VoxelLogicRegister.voxels[this._voxelId].getTagValue(VoxelTagIds.isLightSource, this);
         }
-        return VoxelTagStates.isRegistered(this._loadedId, VoxelTagIds.isLightSource)
-            ? VoxelTagStates.getValue(this._loadedId, VoxelTagIds.isLightSource, this.getState()) === true
-            : this._tags[VoxelTagIds.isLightSource];
+        return this.tags[VoxelTagIds.isLightSource];
     }
     doesVoxelAffectLogic() {
-        if (this._tags["dve_can_be_powered"] ||
-            this._tags["dve_can_hold_power"] ||
-            this._tags["dve_can_carry_power"] ||
-            this._tags["dve_is_power_source"])
+        if (this.tags["dve_can_be_powered"] ||
+            this.tags["dve_can_hold_power"] ||
+            this.tags["dve_can_carry_power"] ||
+            this.tags["dve_is_power_source"])
             return true;
         return false;
     }
     getLightSourceValue() {
-        if (this._loadedId <= 0)
+        if (this._voxelId <= 0)
             return 0;
-        return this._tags[VoxelTagIds.lightValue];
+        return this.tags[VoxelTagIds.lightValue];
     }
     getPower() {
-        if (this._loadedId == 0)
+        if (this._voxelId == 0)
             return -1;
-        if (this._substanceTags["dve_is_liquid"])
+        if (this.substanceTags["dve_is_liquid"])
             return -1;
-        if (!this._tags["dve_can_carry_power"] &&
-            !this._tags["dve_can_hold_power"] &&
-            !this._tags["dve_can_be_powered"] &&
-            !this._tags["dve_is_power_source"])
+        if (!this.tags["dve_can_carry_power"] &&
+            !this.tags["dve_can_hold_power"] &&
+            !this.tags["dve_can_be_powered"] &&
+            !this.tags["dve_is_power_source"])
             return -1;
         const level = VoxelLevelReader.getLevel(this.level[this._index]);
-        if (this._tags["dve_is_power_source"] &&
-            this._tags["dve_power_value"] > level)
-            return this._tags["dve_power_value"];
+        if (this.tags["dve_is_power_source"] &&
+            this.tags["dve_power_value"] > level)
+            return this.tags["dve_power_value"];
         return level;
     }
     setPower(level) {
@@ -165,21 +142,22 @@ export class VoxelCursorInterface {
         return this;
     }
     isPowerSource() {
-        if (this._loadedId <= 0)
+        if (this._voxelId <= 0)
             return false;
-        return VoxelTagStates.isRegistered(this._loadedId, VoxelTagIds.isPowerSource)
-            ? VoxelTagStates.getValue(this._loadedId, VoxelTagIds.isPowerSource, this.getState()) === true
-            : this._tags[VoxelTagIds.isPowerSource];
+        if (VoxelLogicRegister.voxels[this._voxelId]?.hasTag(VoxelTagIds.isPowerSource)) {
+            return VoxelLogicRegister.voxels[this._voxelId].getTagValue(VoxelTagIds.isPowerSource, this);
+        }
+        return this.tags[VoxelTagIds.isPowerSource];
     }
     getPowerSourceValue() {
-        if (this._loadedId <= 0)
+        if (this._voxelId <= 0)
             return 0;
-        return this._tags[VoxelTagIds.powerValue];
+        return this.tags[VoxelTagIds.powerValue];
     }
     noAO() {
-        if (this._loadedId <= 0)
+        if (this._voxelId <= 0)
             return false;
-        return this._tags[VoxelTagIds.noAO];
+        return this.tags[VoxelTagIds.noAO];
     }
     isRenderable() {
         if (this.id > 0)
@@ -192,57 +170,80 @@ export class VoxelCursorInterface {
         return 0 == this.ids[this._index];
     }
     setAir() {
-        this.ids[0] = 0;
+        this.ids[this._index] = 0;
         return this;
     }
+    /**Get the voxels palette id. The id is the combination of the true id, state, and mod. */
     getId() {
-        if (this.__secondary) {
+        if (this.__readingSecondaryVoxel) {
             return this.secondaryId;
         }
         return this.id;
     }
     setId(id) {
-        if (this.__secondary) {
+        if (this.__readingSecondaryVoxel) {
             this.secondary[this._index] = id;
             return this;
         }
         this.ids[this._index] = id;
         return this;
     }
-    setStringId(id) {
-        return this.setId(VoxelPalettesRegister.voxels.getNumberId(id));
+    /**Get the true voxel id. Meaning the numeric id for the string id of the voxel */
+    getVoxelId() {
+        return this.getIndexData()[0];
+    }
+    setVoxelId(id, state = 0, mod = 0) {
+        return this.setId(VoxelPalettesRegister.getVoxelId(id, state, mod));
+    }
+    setStringId(id, state = 0, mod = 0) {
+        return this.setVoxelId(VoxelPalettesRegister.voxelIds.getNumberId(id), state, mod);
     }
     getStringId() {
-        if (this.__secondary) {
-            return VoxelPalettesRegister.voxels.getStringId(this.secondaryId);
-        }
-        return VoxelPalettesRegister.voxels.getStringId(this.id);
+        return VoxelPalettesRegister.voxelIds.getStringId(this.getIndexData()[0]);
     }
-    setName(name) {
-        return this.setStringId(VoxelPalettesRegister.voxelNametoIdMap.get(name));
+    setName(name, state = 0, mod = 0) {
+        return this.setVoxelId(VoxelPalettesRegister.voxelIds.getNumberId(VoxelPalettesRegister.voxelNametoIdMap.get(name)), state, mod);
     }
     getName() {
         return VoxelPalettesRegister.voxelIdToNameMap.get(this.getStringId());
     }
+    getIndexData() {
+        if (this.__readingSecondaryVoxel) {
+            return VoxelPalettesRegister.voxels[this.secondary[this._index]];
+        }
+        return VoxelPalettesRegister.voxels[this.ids[this._index]];
+    }
+    getMod() {
+        return VoxelPalettesRegister.voxels[this.ids[this._index]][2];
+    }
+    setMod(mod) {
+        const index = VoxelPalettesRegister.voxels[this.ids[this._index]];
+        this.setId(VoxelPalettesRegister.getVoxelId(index[0], index[1], mod));
+        return this;
+    }
+    getState() {
+        return this.getIndexData()[1];
+    }
+    setState(state) {
+        const index = this.getIndexData();
+        this.setId(VoxelPalettesRegister.getVoxelId(index[0], state, index[2]));
+        return this;
+    }
     isSameVoxel(voxel) {
-        return this.getId() == voxel.getId();
+        return this.getIndexData()[0] == voxel.getIndexData()[0];
     }
     copy(cursor) {
         this.ids[this._index] = cursor.ids[cursor._index];
         this.light[this._index] = cursor.light[cursor._index];
         this.level[this._index] = cursor.level[cursor._index];
-        this.state[this._index] = cursor.state[cursor._index];
-        this.mod[this._index] = cursor.mod[cursor._index];
         this.secondary[this._index] = cursor.secondary[cursor._index];
         return this;
     }
-    copyRaw(raw) {
+    setRaw(raw) {
         this.ids[this._index] = raw[0];
         this.light[this._index] = raw[1];
         this.level[this._index] = raw[2];
-        this.state[this._index] = raw[3];
-        this.secondary[this._index] = raw[4];
-        this.mod[this._index] = raw[5];
+        this.secondary[this._index] = raw[3];
         return this;
     }
     getRaw() {
@@ -250,8 +251,6 @@ export class VoxelCursorInterface {
             this.ids[this._index],
             this.light[this._index],
             this.level[this._index],
-            this.state[this._index],
-            this.mod[this._index],
             this.secondary[this._index],
         ];
     }
@@ -259,9 +258,7 @@ export class VoxelCursorInterface {
         raw[0] = this.ids[this._index];
         raw[1] = this.light[this._index];
         raw[2] = this.level[this._index];
-        raw[3] = this.state[this._index];
-        raw[4] = this.mod[this._index];
-        raw[5] = this.secondary[this._index];
+        raw[3] = this.secondary[this._index];
         return raw;
     }
 }

package/Voxels/Cursor/VoxelCursor.js

@@ -3,25 +3,35 @@ import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
 import { VoxelLevelReader } from "./VoxelLevelReader";
 export class VoxelCursor extends VoxelCursorInterface {
     static VoxelDataToRaw(data, light = 0) {
-        const id = (data.id !== undefined &&
-            VoxelPalettesRegister.voxels.getNumberId(data.id)) ||
+        let stringId = data.id
+            ? data.id
+            : data.name
+                ? VoxelPalettesRegister.voxelNametoIdMap.get(data.name)
+                : "dve_air";
+        let secondaryStringId = data.id
+            ? data.id
+            : data.name
+                ? VoxelPalettesRegister.voxelNametoIdMap.get(data.name)
+                : "dve_air";
+        const id = (stringId !== "dve_air" &&
+            VoxelPalettesRegister.getVoxelIdFromString(stringId, data.state || 0, data.mod || 0)) ||
             0;
-        const secondaryId = (data.secondaryVoxelId !== undefined &&
-            VoxelPalettesRegister.voxels.getNumberId(data.secondaryVoxelId)) ||
+        const secondaryId = (secondaryStringId !== "dve_air" &&
+            VoxelPalettesRegister.getVoxelIdFromString(secondaryStringId, data.state || 0, data.mod || 0)) ||
             0;
         let levleData = 0;
         if (data.level !== undefined)
             levleData = VoxelLevelReader.setLevel(levleData, data.level);
         if (data.levelState !== undefined)
             levleData = VoxelLevelReader.setLevelState(levleData, data.levelState);
-        return [id, light, levleData, data.state || 0, data.mod || 0, secondaryId];
+        return [id, light, levleData, secondaryId];
+    }
+    ids = [];
+    light = [];
+    level = [];
+    secondary = [];
+    loadIn() {
+        this.process();
     }
-    ids = new Uint16Array(1);
-    light = new Uint16Array(1);
-    level = new Uint8Array(1);
-    state = new Uint16Array(1);
-    mod = new Uint16Array(1);
-    secondary = new Uint16Array(1);
-    loadIn() { }
     updateVoxel(mode) { }
 }

package/Voxels/Cursor/VoxelLightData.d.ts

@@ -4,6 +4,8 @@ type AllLight = [s: number, r: number, g: number, b: number];
  * Used to decode light color info.
  */
 export declare class VoxelLightData {
+    /**The rate at which sun light falls off. RGB light falls off at a default of 1 and sun has a default of 2. */
+    static SunFallOffValue: number;
     _lightValues: AllLight;
     sumRGB(value: number): number;
     getS(value: number): number;

package/Voxels/Cursor/VoxelLightData.js

@@ -3,6 +3,8 @@
  * Used to decode light color info.
  */
 export class VoxelLightData {
+    /**The rate at which sun light falls off. RGB light falls off at a default of 1 and sun has a default of 2. */
+    static SunFallOffValue = 2;
     _lightValues = [0, 0, 0, 0];
     sumRGB(value) {
         return this.getR(value) + this.getG(value) + this.getB(value);

package/Voxels/Data/VoxelPalettesRegister.d.ts

@@ -1,8 +1,18 @@
+import { NumberPalette } from "../../Util/NumberPalette";
 import { StringPalette } from "../../Util/StringPalette";
 export declare class VoxelPalettesRegister {
     static material: StringPalette;
     static substance: StringPalette;
-    static voxels: StringPalette;
+    static voxelIds: StringPalette;
     static voxelNametoIdMap: Map<string, string>;
     static voxelIdToNameMap: Map<string, string>;
+    static state: NumberPalette;
+    static mod: NumberPalette;
+    static getVoxelId(id: number, state?: number, mod?: number): number;
+    static getVoxelIdFromString(id: string, state?: number, mod?: number): number;
+    static getVoxelIdFromName(name: string, state?: number, mod?: number): number;
+    /**Palette of voxel ids to their tree id, state, and mod value */
+    static voxels: [voxelId: number, state: number, mod: number][];
+    /**Palette of true voxel ids to state then their mod then the final palette voxel id */
+    static voxelRecord: number[][][];
 }

package/Voxels/Data/VoxelPalettesRegister.js

@@ -1,8 +1,24 @@
+import { NumberPalette } from "../../Util/NumberPalette";
 import { StringPalette } from "../../Util/StringPalette";
 export class VoxelPalettesRegister {
     static material = new StringPalette();
     static substance = new StringPalette();
-    static voxels = new StringPalette();
+    static voxelIds = new StringPalette();
     static voxelNametoIdMap = new Map();
     static voxelIdToNameMap = new Map();
+    static state = new NumberPalette();
+    static mod = new NumberPalette();
+    static getVoxelId(id, state = 0, mod = 0) {
+        return this.voxelRecord[id][mod][state];
+    }
+    static getVoxelIdFromString(id, state = 0, mod = 0) {
+        return this.voxelRecord[this.voxelIds.getNumberId(id)][mod][state];
+    }
+    static getVoxelIdFromName(name, state = 0, mod = 0) {
+        return this.voxelRecord[this.voxelIds.getNumberId(this.voxelNametoIdMap.get(name))][mod][state];
+    }
+    /**Palette of voxel ids to their tree id, state, and mod value */
+    static voxels = [];
+    /**Palette of true voxel ids to state then their mod then the final palette voxel id */
+    static voxelRecord = [];
 }

package/Voxels/Data/VoxelPropertiesRegister.d.ts

@@ -0,0 +1,4 @@
+import { VoxelProperties } from "../Types/Voxel.types";
+export declare class VoxelPropertiesRegister {
+    static VoxelProperties: VoxelProperties[];
+}

package/Voxels/Data/VoxelPropertiesRegister.js

@@ -0,0 +1,3 @@
+export class VoxelPropertiesRegister {
+    static VoxelProperties = [];
+}

package/Voxels/Data/VoxelTag.types.d.ts

@@ -3,6 +3,7 @@ export declare enum VoxelTagIds {
     renderedMaterial = "dve_rendered_material",
     voxelMaterial = "dve_voxel_material",
     hardness = "dve_hardness",
+    modelId = "dve_model_id",
     colliderID = "dve_collider_id",
     checkCollisions = "dve_check_collisions",
     isLightSource = "dve_is_light_source",
@@ -14,9 +15,13 @@ export declare enum VoxelTagIds {
     canCarryPower = "dve_can_carry_power",
     canHoldPower = "dve_can_hold_power",
     isPowerSource = "dve_is_power_source",
-    powerValue = "dve_power_value"
+    powerValue = "dve_power_value",
+    fullBlock = "dve_full_block",
+    simulationBehavior = "dve_simulation_behavior"
 }
 export interface VoxelTags {
+    [VoxelTagIds.simulationBehavior]: string;
+    [VoxelTagIds.fullBlock]: boolean;
     /** The material used to render the voxel. Used by the engine to assign meshes to the proper material. */
     [VoxelTagIds.renderedMaterial]: string;
     /** A description of the material used for the voxel. Not used by the engine directly. */
@@ -34,6 +39,7 @@ export interface VoxelTags {
     [VoxelTagIds.noAO]: boolean;
     /** Defines the light value emitted by the voxel (r, g, z). */
     [VoxelTagIds.lightValue]: [r: number, g: number, z: number] | number;
+    [VoxelTagIds.modelId]: string;
     /** The collider ID for the voxel, used for collision detection. */
     [VoxelTagIds.colliderID]: string;
     /** Specifies if the voxel participates in collision checks. */

package/Voxels/Data/VoxelTag.types.js

@@ -4,6 +4,7 @@ export var VoxelTagIds;
     VoxelTagIds["renderedMaterial"] = "dve_rendered_material";
     VoxelTagIds["voxelMaterial"] = "dve_voxel_material";
     VoxelTagIds["hardness"] = "dve_hardness";
+    VoxelTagIds["modelId"] = "dve_model_id";
     VoxelTagIds["colliderID"] = "dve_collider_id";
     VoxelTagIds["checkCollisions"] = "dve_check_collisions";
     VoxelTagIds["isLightSource"] = "dve_is_light_source";
@@ -16,6 +17,8 @@ export var VoxelTagIds;
     VoxelTagIds["canHoldPower"] = "dve_can_hold_power";
     VoxelTagIds["isPowerSource"] = "dve_is_power_source";
     VoxelTagIds["powerValue"] = "dve_power_value";
+    VoxelTagIds["fullBlock"] = "dve_full_block";
+    VoxelTagIds["simulationBehavior"] = "dve_simulation_behavior";
 })(VoxelTagIds || (VoxelTagIds = {}));
 export var VoxelSubstanceTagIdds;
 (function (VoxelSubstanceTagIdds) {

package/Voxels/Data/VoxelTagsRegister.js

@@ -16,7 +16,9 @@ export class VoxelTagsRegister {
         VoxelTagIds.canBePowered,
         VoxelTagIds.canCarryPower,
         VoxelTagIds.canHoldPower,
-        VoxelTagIds.powerValue
+        VoxelTagIds.powerValue,
+        VoxelTagIds.fullBlock,
+        VoxelTagIds.simulationBehavior,
     ];
     static IncludedSubstnacesTags = [
         VoxelSubstanceTagIds.parent,
@@ -30,6 +32,7 @@ export class VoxelTagsRegister {
         [VoxelTagIds.renderedMaterial]: "dve_solid",
         [VoxelTagIds.substance]: "dve_solid",
         [VoxelTagIds.colliderID]: "dve_cube",
+        [VoxelTagIds.simulationBehavior]: "dve_default",
     };
     static VoxelTags = [];
     static SubstanceStagDefaults = {};

package/Voxels/Functions/BuildPaletteData.d.ts

@@ -0,0 +1,6 @@
+import { FinalCompiledVoxelModelData } from "../Models/CompiledVoxelModel.types";
+type BuildPaletteDataProps = {
+    models: FinalCompiledVoxelModelData;
+};
+export declare function BuildPaletteData(props: BuildPaletteDataProps): void;
+export {};

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,16 +1,14 @@
-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[];
     stateGeometryPalette: number[][];
     condiotnalShapeStateGeometryPalette: number[][];
     stateTree: any[];
-    geometryLinkPalette: Record<string, number>;
-    geometryLinkStateMap: number[];
-    relativeByteCount: number;
+    geometryLinkStateMap: Record<string, Record<number, number>>;
     statePalette: number[][];
     stateRecord: Record<string, number>;
     condiotnalNodeStateTree: any;