@divinevoxel/vlox 0.0.80 → 0.0.81

package/Voxels/Archive/VoxelPaletteArchiveReader.js

@@ -1,8 +1,8 @@
 import { VoxelSchemas } from "../State/VoxelSchemas";
 import { BinarySchema } from "../State/Schema/BinarySchema";
 import { BinaryBuffer } from "../../Util/BinaryBuffer/BinaryBuffer";
-const temp = ["", 0, 0];
 export class VoxelPaletteArchiveReader {
+    temp = ["", 0, 0];
     voxelPalette;
     _voxels = [];
     _voxelStateSchema = new Map();
@@ -21,26 +21,27 @@ export class VoxelPaletteArchiveReader {
                 this._modSchema.set(voxel.id, binarySchema);
             }
             if (voxel.stateSchemaId && this._stateSchemas.has(voxel.stateSchemaId)) {
-                this._voxelStateSchema.set(voxel.stateSchemaId, this._stateSchemas.get(voxel.stateSchemaId));
+                this._voxelStateSchema.set(voxel.id, this._stateSchemas.get(voxel.stateSchemaId));
             }
         }
         this.voxelPalette = BinaryBuffer.ToTypedArray(palettes.voxelPalette);
     }
     getVoxelData(id) {
+        const temp = this.temp;
         const index = id * 3;
         const voxelId = this._voxels[this.voxelPalette[index]]?.id;
         temp[0] = voxelId;
+        temp[1] = 0;
+        temp[2] = 0;
         if (temp[0] == "dve_air") {
-            temp[1] = 0;
-            temp[2] = 0;
             return temp;
         }
         const currentStateSchema = VoxelSchemas.getStateSchema(voxelId);
-        let finalStateValue = 0;
         if (this._voxelStateSchema.has(voxelId)) {
             const stateSchema = this._voxelStateSchema.get(voxelId);
             const stateValue = this.voxelPalette[index + 1];
             stateSchema.startEncoding(stateValue);
+            currentStateSchema.startEncoding(0);
             for (const node of stateSchema.nodes) {
                 if (node.valuePalette) {
                     currentStateSchema.setValue(node.name, stateSchema.getValue(node.name));
@@ -49,15 +50,14 @@ export class VoxelPaletteArchiveReader {
                     currentStateSchema.setNumber(node.name, stateSchema.getNumber(node.name));
                 }
             }
-            finalStateValue = stateSchema.getEncoded();
+            temp[1] = currentStateSchema.getEncoded();
         }
-        temp[1] = finalStateValue;
-        let finalModValue = 0;
         const currentModSchema = VoxelSchemas.mod.get(voxelId);
         if (this._modSchema.has(voxelId)) {
             const modSchema = this._modSchema.get(voxelId);
             const modValue = this.voxelPalette[index + 2];
             modSchema.startEncoding(modValue);
+            currentModSchema.startEncoding(0);
             for (const node of modSchema.nodes) {
                 if (node.valuePalette) {
                     currentModSchema.setValue(node.name, modSchema.getValue(node.name));
@@ -66,9 +66,8 @@ export class VoxelPaletteArchiveReader {
                     currentModSchema.setNumber(node.name, modSchema.getNumber(node.name));
                 }
             }
-            finalModValue = modSchema.getEncoded();
+            temp[2] = currentModSchema.getEncoded();
         }
-        temp[2] = finalModValue;
         return temp;
     }
 }

package/Voxels/Archive/VoxelPaletteArechive.js

@@ -36,13 +36,13 @@ export class VoxelArchivePalette {
     register(id) {
         if (this._voxelsRegistered.has(id))
             return this._voxelsRegistered.get(id);
-        const stringId = VoxelLUT.voxelIds.getStringId(VoxelLUT.voxels[id][0]);
+        const stringId = VoxelLUT.voxelIds.getStringId(VoxelLUT.voxelIdToTrueId[id]);
         let voxelId = 0;
         if (!this._ids.isRegistered(stringId)) {
             voxelId = this._ids.register(stringId);
             const modelId = VoxelLUT.models.getStringId(VoxelLUT.modelsIndex[VoxelLUT.voxelIds.getNumberId(stringId)]);
-            const stateData = VoxelSchemas.getStateSchema(stringId).getSchema();
-            const modData = VoxelSchemas.mod.get(stringId).getSchema();
+            const stateData = VoxelSchemas.getStateSchema(stringId)?.getSchema();
+            const modData = VoxelSchemas.mod.get(stringId)?.getSchema();
             if (stateData && stateData?.length) {
                 this._stateShemas[modelId] = stateData;
             }
@@ -60,7 +60,8 @@ export class VoxelArchivePalette {
         else {
             voxelId = this._ids.getNumberId(stringId);
         }
-        const [, state, mod] = VoxelLUT.voxels[id];
+        const state = VoxelLUT.voxelIdToState[id];
+        const mod = VoxelLUT.voxelIdToMod[id];
         this._voxelPalette.push(voxelId, state, mod);
         const paletteId = this._voxelCount;
         this._voxelsRegistered.set(id, paletteId);

package/Voxels/Cursor/VoxelCursor.interface.d.ts

@@ -61,11 +61,11 @@ export declare abstract class VoxelCursorInterface {
     getStringId(): string;
     setName(name: string, state?: number, mod?: number): this;
     getName(): string;
-    getIndexData(): [voxelId: number, state: number, mod: number];
     getMod(): number;
     setMod(mod: number): this;
     getState(): number;
     setState(state: number): this;
+    isFullBlock(): boolean;
     isSameVoxel(voxel: VoxelCursorInterface): boolean;
     copy(cursor: VoxelCursorInterface): this;
     setRaw(raw: RawVoxelData): this;

package/Voxels/Cursor/VoxelCursor.interface.js

@@ -18,10 +18,12 @@ export class VoxelCursorInterface {
     process() {
         this.id = this.ids[this._index];
         this.secondaryId = this.secondary[this._index];
-        this._voxelId = this.getVoxelId();
+        this._voxelId = this.__readingSecondaryVoxel
+            ? VoxelLUT.voxelIdToTrueId[this.secondary[this._index]]
+            : VoxelLUT.voxelIdToTrueId[this.ids[this._index]];
         this.tags = VoxelTagsRegister.VoxelTags[this._voxelId];
         this.substanceTags =
-            VoxelTagsRegister.SubstanceTags[VoxelLUT.substance.getNumberId(this.tags["dve_substance"])];
+            VoxelTagsRegister.SubstanceTags[VoxelLUT.substanceMap[this._voxelId]];
     }
     setSecondary(enable) {
         this.__readingSecondaryVoxel = enable;
@@ -188,7 +190,10 @@ export class VoxelCursorInterface {
     }
     /**Get the true voxel id. Meaning the numeric id for the string id of the voxel */
     getVoxelId() {
-        return this.getIndexData()[0];
+        if (this.__readingSecondaryVoxel) {
+            return VoxelLUT.voxelIdToTrueId[this.secondary[this._index]];
+        }
+        return VoxelLUT.voxelIdToTrueId[this.ids[this._index]];
     }
     setVoxelId(id, state = 0, mod = 0) {
         return this.setId(VoxelLUT.getVoxelId(id, state, mod));
@@ -197,7 +202,7 @@ export class VoxelCursorInterface {
         return this.setVoxelId(VoxelLUT.voxelIds.getNumberId(id), state, mod);
     }
     getStringId() {
-        return VoxelLUT.voxelIds.getStringId(this.getIndexData()[0]);
+        return VoxelLUT.voxelIds.getStringId(this.getVoxelId());
     }
     setName(name, state = 0, mod = 0) {
         return this.setVoxelId(VoxelLUT.voxelIds.getNumberId(VoxelLUT.voxelNametoIdMap.get(name)), state, mod);
@@ -205,30 +210,31 @@ export class VoxelCursorInterface {
     getName() {
         return VoxelLUT.voxelIdToNameMap.get(this.getStringId());
     }
-    getIndexData() {
+    getMod() {
         if (this.__readingSecondaryVoxel) {
-            return VoxelLUT.voxels[this.secondary[this._index]];
+            return VoxelLUT.voxelIdToMod[this.secondary[this._index]];
         }
-        return VoxelLUT.voxels[this.ids[this._index]];
-    }
-    getMod() {
-        return VoxelLUT.voxels[this.ids[this._index]][2];
+        return VoxelLUT.voxelIdToMod[this.ids[this._index]];
     }
     setMod(mod) {
-        const index = VoxelLUT.voxels[this.ids[this._index]];
-        this.setId(VoxelLUT.getVoxelId(index[0], index[1], mod));
+        this.setId(VoxelLUT.getVoxelId(this.getVoxelId(), this.getState(), mod));
         return this;
     }
     getState() {
-        return this.getIndexData()[1];
+        if (this.__readingSecondaryVoxel) {
+            return VoxelLUT.voxelIdToState[this.secondary[this._index]];
+        }
+        return VoxelLUT.voxelIdToState[this.ids[this._index]];
     }
     setState(state) {
-        const index = this.getIndexData();
-        this.setId(VoxelLUT.getVoxelId(index[0], state, index[2]));
+        this.setId(VoxelLUT.getVoxelId(this.getVoxelId(), state, this.getMod()));
         return this;
     }
+    isFullBlock() {
+        return this.tags["dve_full_block"];
+    }
     isSameVoxel(voxel) {
-        return this.getIndexData()[0] == voxel.getIndexData()[0];
+        return this.getVoxelId() == voxel.getVoxelId();
     }
     copy(cursor) {
         this.ids[this._index] = cursor.ids[cursor._index];

package/Voxels/Data/VoxelLUT.d.ts

@@ -5,31 +5,39 @@ export type VoxelLUTExport = {
     substance: string[];
     substanceMap: number[];
     voxelIds: string[];
-    voxelNametoIdMap: [key: string, value: string][];
-    voxelIdToNameMap: [key: string, value: string][];
+    voxelNametoIdMap: [string, string][];
+    voxelIdToNameMap: [string, string][];
     models: string[];
     modelsIndex: number[];
-    totalStates: number[];
-    totalMods: number[];
-    totalReltionalStates: number[];
-    totalReltionalMods: number[];
-    geometryIndex: number[][];
-    geometryInputsIndex: number[][];
+    totalStates: ArrayBufferLike;
+    totalMods: ArrayBufferLike;
+    totalReltionalStates: ArrayBufferLike;
+    totalReltionalMods: ArrayBufferLike;
+    totalVoxelIds: number;
+    totalRelationalVoxelIds: number;
+    totalCombinedIds: number;
+    modelStateMaps: [number, number][][];
+    modelRelationalStateMaps: [number, number][][];
+    voxelModMaps: [number, number][][];
+    voxelRelationalModMaps: [number, number][][];
+    voxelIdToTrueId: ArrayBufferLike;
+    voxelIdToState: ArrayBufferLike;
+    voxelIdToMod: ArrayBufferLike;
+    voxelRecordStartIndex: ArrayBufferLike;
+    voxelRecord: ArrayBufferLike;
+    relationalVoxelIdToTrueId: ArrayBufferLike;
+    relationalVoxelIdToState: ArrayBufferLike;
+    relationalVoxelIdToMod: ArrayBufferLike;
+    relationalVoxelRecordStartIndex: ArrayBufferLike;
+    relationalVoxelRecord: ArrayBufferLike;
+    geometryIndex: ArrayBufferLike;
+    geometryInputsIndex: ArrayBufferLike;
     conditionalGeometryIndex: [
         geometryId: number,
         modelState: number,
         modelReltionalState: boolean[]
     ][][];
     conditionalGeometryInputIndex: number[][][];
-    voxels: [voxelId: number, state: number, mod: number][];
-    voxelRecord: number[][][];
-    voxelIdToModelState: number[];
-    reltioanlVoxels: [
-        voxelId: number,
-        reltionalState: number,
-        reltioanlMod: number
-    ][];
-    reltionalVoxelRecord: number[][][];
 };
 export declare class VoxelLUT {
     static material: StringPalette;
@@ -41,43 +49,62 @@ export declare class VoxelLUT {
     static voxelIdToNameMap: Map<string, string>;
     static models: StringPalette;
     static modelsIndex: number[];
-    static totalStates: number[];
-    static totalMods: number[];
-    static totalReltionalStates: number[];
-    static totalReltionalMods: number[];
-    static geometryIndex: number[][];
-    static geometryInputsIndex: number[][];
+    static totalStates: Uint16Array;
+    static totalMods: Uint16Array;
+    static totalReltionalStates: Uint16Array;
+    static totalReltionalMods: Uint16Array;
+    static totalVoxelIds: number;
+    static totalRelationalVoxelIds: number;
+    /** totalVoxelIds * totalRelationalVoxelIds */
+    static totalCombinedIds: number;
+    /**Maps model ids to their state maps */
+    static modelStateMaps: Map<number, number>[];
+    /**Maps model ids to their relational state maps */
+    static modelRelationalStateMaps: Map<number, number>[];
+    /**Maps voxel true ids to their mod maps */
+    static voxelModMaps: Map<number, number>[];
+    /**Maps voxel true ids to their relational mod maps */
+    static voxelRelationalModMaps: Map<number, number>[];
+    /**Maps voxel id to its true voxel id */
+    static voxelIdToTrueId: Uint16Array;
+    /**Maps voxel id to its state */
+    static voxelIdToState: Uint16Array;
+    /**Maps voxel id to its mod */
+    static voxelIdToMod: Uint16Array;
+    /** Maps a voxels true id to where it starts in the voxel record.*/
+    static voxelRecordStartIndex: Uint16Array;
+    /** Maps a voxels true id to its state x mod to get the actual final voxel id*/
+    static voxelRecord: Uint16Array;
+    /**Maps voxel id to its true voxel id */
+    static relationalVoxelIdToTrueId: Uint16Array;
+    /**Maps voxel id to its state */
+    static relationalVoxelIdToState: Uint16Array;
+    /**Maps voxel id to its mod */
+    static relationalVoxelIdToMod: Uint16Array;
+    /** Maps a voxels true id to where it starts in the voxel record.*/
+    static relationalVoxelRecordStartIndex: Uint16Array;
+    /** Maps a voxels true id to its state x mod to get the actual final voxel id*/
+    static relationalVoxelRecord: Uint16Array;
+    static geometryIndex: Uint16Array;
+    static geometryInputsIndex: Uint16Array;
     static conditionalGeometryIndex: [
         geometryId: number,
         modelState: number,
         modelReltionalState: boolean[]
     ][][];
     static conditionalGeometryInputIndex: 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[][][];
-    static voxelIdToModelState: number[];
-    /**Palette of voxel ids to their tree id, state, and mod value */
-    static reltioanlVoxels: [
-        voxelId: number,
-        reltionalState: number,
-        reltioanlMod: number
-    ][];
-    /**Palette of true voxel ids to reltional state then theirreltional  mod then the final reltional palette voxel id */
-    static reltionalVoxelRecord: number[][][];
-    static getVoxelId(id: number, state?: number, mod?: number): number;
+    static getStateIndex(x: number, y: number, boundsX: number): number;
+    static getVoxelId(trueId: number, state?: number, mod?: number): number;
     static getVoxelIdFromString(id: string, state?: number, mod?: number): number;
-    static getVoxelIdFromName(name: string, state?: number, mod?: number): number;
-    static getReltionalVoxelId(id: number, reltioanlState?: number, reltioanlMod?: number): number;
-    static getGeometryIndex(voxelId?: number, reltioanlId?: number): number;
-    static getGeometryInputIndex(voxelId?: number, reltioanlId?: number): number;
+    static getReltionalVoxelId(trueId: number, relationalState?: number, relationalMod?: number): number;
+    static getGeometryIndex(voxelId?: number, relationalId?: number): number;
+    static getGeometryInputIndex(voxelId?: number, relationalId?: number): number;
     static getConditionalGeometryNodes(trueVoxelId: number): [
         geometryId: number,
         modelState: number,
         modelReltionalState: boolean[]
     ][];
-    static getConditionalGeometryInputIndex(getIndex: number, voxelId?: number, reltioanlId?: number): number;
+    static getConditionalGeometryInputIndex(getIndex: number, voxelId?: number, relationalId?: number): number;
     static export(): VoxelLUTExport;
     static import(exported: VoxelLUTExport): void;
 }

package/Voxels/Data/VoxelLUT.js

@@ -16,55 +16,86 @@ export class VoxelLUT {
     static models = new StringPalette();
     //maps true voxel ids to their model palette id
     static modelsIndex = [];
+    //TOTALS
     //maps true voxel ids to the total number of states
-    static totalStates = [];
+    static totalStates;
     //maps true voxel ids to the total number of mod states
-    static totalMods = [];
+    static totalMods;
     //maps true voxel ids to the total number of reltional states
-    static totalReltionalStates = [];
+    static totalReltionalStates;
     //maps true voxel ids to the total number of reltional mod states
-    static totalReltionalMods = [];
+    static totalReltionalMods;
+    static totalVoxelIds = 1;
+    static totalRelationalVoxelIds = 1;
+    /** totalVoxelIds * totalRelationalVoxelIds */
+    static totalCombinedIds = 0;
+    //MAPS
+    /**Maps model ids to their state maps */
+    static modelStateMaps = [];
+    /**Maps model ids to their relational state maps */
+    static modelRelationalStateMaps = [];
+    /**Maps voxel true ids to their mod maps */
+    static voxelModMaps = [];
+    /**Maps voxel true ids to their relational mod maps */
+    static voxelRelationalModMaps = [];
+    //VOXELS IDS
+    /**Maps voxel id to its true voxel id */
+    static voxelIdToTrueId;
+    /**Maps voxel id to its state */
+    static voxelIdToState;
+    /**Maps voxel id to its mod */
+    static voxelIdToMod;
+    /** Maps a voxels true id to where it starts in the voxel record.*/
+    static voxelRecordStartIndex;
+    /** Maps a voxels true id to its state x mod to get the actual final voxel id*/
+    static voxelRecord;
+    //RELATIONAL VOXEL IDS
+    /**Maps voxel id to its true voxel id */
+    static relationalVoxelIdToTrueId;
+    /**Maps voxel id to its state */
+    static relationalVoxelIdToState;
+    /**Maps voxel id to its mod */
+    static relationalVoxelIdToMod;
+    /** Maps a voxels true id to where it starts in the voxel record.*/
+    static relationalVoxelRecordStartIndex;
+    /** Maps a voxels true id to its state x mod to get the actual final voxel id*/
+    static relationalVoxelRecord;
+    //GEOMETRY
     //maps [voxel id x reltional voxel id] to the geometry index
-    static geometryIndex = [];
+    static geometryIndex;
     //maps [voxel id x reltional voxel id] to the geometry inputs index
-    static geometryInputsIndex = [];
-    //maps voxel id to its conditional nodes and the needed voxel id and reltional voxel id
+    static geometryInputsIndex;
+    //maps model id to its conditional nodes and the needed voxel id and reltional voxel id
     static conditionalGeometryIndex = [];
     //maps [geometry id x voxel id x reltional voxel id] to the geometry index
     static conditionalGeometryInputIndex = [];
-    /**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 = [];
-    //Maps the voxel id to the model state
-    static voxelIdToModelState = [];
-    /**Palette of voxel ids to their tree id, state, and mod value */
-    static reltioanlVoxels = [];
-    /**Palette of true voxel ids to reltional state then theirreltional  mod then the final reltional palette voxel id */
-    static reltionalVoxelRecord = [];
-    static getVoxelId(id, state = 0, mod = 0) {
-        return this.voxelRecord[id][mod][state];
+    static getStateIndex(x, y, boundsX) {
+        return x + y * boundsX;
     }
-    static getVoxelIdFromString(id, state = 0, mod = 0) {
-        return this.voxelRecord[this.voxelIds.getNumberId(id)][mod][state];
+    static getVoxelId(trueId, state = 0, mod = 0) {
+        return this.voxelRecord[this.voxelRecordStartIndex[trueId] +
+            this.getStateIndex(this.modelStateMaps[this.modelsIndex[trueId]].get(state) ?? 0, this.voxelModMaps[trueId].get(mod) ?? 0, this.totalStates[trueId])];
     }
-    static getVoxelIdFromName(name, state = 0, mod = 0) {
-        return this.voxelRecord[this.voxelIds.getNumberId(this.voxelNametoIdMap.get(name))][mod][state];
+    static getVoxelIdFromString(id, state = 0, mod = 0) {
+        if (id == "dve_air")
+            return 0;
+        return this.getVoxelId(this.voxelIds.getNumberId(id), state, mod);
     }
-    static getReltionalVoxelId(id, reltioanlState = 0, reltioanlMod = 0) {
-        return this.reltionalVoxelRecord[id][reltioanlMod][reltioanlState];
+    static getReltionalVoxelId(trueId, relationalState = 0, relationalMod = 0) {
+        return this.relationalVoxelRecord[this.relationalVoxelRecordStartIndex[trueId] +
+            this.getStateIndex(this.modelRelationalStateMaps[this.modelsIndex[trueId]].get(relationalState), this.voxelRelationalModMaps[trueId].get(relationalMod), this.totalReltionalStates[trueId])];
     }
-    static getGeometryIndex(voxelId = 0, reltioanlId = 0) {
-        return this.geometryIndex[voxelId][reltioanlId];
+    static getGeometryIndex(voxelId = 0, relationalId = 0) {
+        return this.geometryIndex[VoxelLUT.getStateIndex(voxelId, relationalId, VoxelLUT.totalVoxelIds)];
     }
-    static getGeometryInputIndex(voxelId = 0, reltioanlId = 0) {
-        return this.geometryInputsIndex[voxelId][reltioanlId];
+    static getGeometryInputIndex(voxelId = 0, relationalId = 0) {
+        return this.geometryInputsIndex[VoxelLUT.getStateIndex(voxelId, relationalId, VoxelLUT.totalVoxelIds)];
     }
     static getConditionalGeometryNodes(trueVoxelId) {
         return this.conditionalGeometryIndex[trueVoxelId];
     }
-    static getConditionalGeometryInputIndex(getIndex, voxelId = 0, reltioanlId = 0) {
-        return this.conditionalGeometryInputIndex[getIndex][voxelId][reltioanlId];
+    static getConditionalGeometryInputIndex(getIndex, voxelId = 0, relationalId = 0) {
+        return this.conditionalGeometryInputIndex[getIndex][voxelId][relationalId];
     }
     static export() {
         return {
@@ -77,19 +108,33 @@ export class VoxelLUT {
             voxelIdToNameMap: [...this.voxelIdToNameMap],
             models: this.models._palette,
             modelsIndex: this.modelsIndex,
-            totalStates: this.totalStates,
-            totalMods: this.totalMods,
-            totalReltionalStates: this.totalReltionalStates,
-            totalReltionalMods: this.totalReltionalMods,
-            geometryIndex: this.geometryIndex,
-            geometryInputsIndex: this.geometryInputsIndex,
+            totalStates: this.totalStates.buffer,
+            totalMods: this.totalMods.buffer,
+            totalReltionalStates: this.totalReltionalStates.buffer,
+            totalReltionalMods: this.totalReltionalMods.buffer,
+            totalVoxelIds: this.totalVoxelIds,
+            totalRelationalVoxelIds: this.totalRelationalVoxelIds,
+            totalCombinedIds: this.totalCombinedIds,
+            modelStateMaps: this.modelStateMaps.map((m) => [...m]),
+            modelRelationalStateMaps: this.modelRelationalStateMaps.map((m) => [
+                ...m,
+            ]),
+            voxelModMaps: this.voxelModMaps.map((m) => [...m]),
+            voxelRelationalModMaps: this.voxelRelationalModMaps.map((m) => [...m]),
+            voxelIdToTrueId: this.voxelIdToTrueId.buffer,
+            voxelIdToState: this.voxelIdToState.buffer,
+            voxelIdToMod: this.voxelIdToMod.buffer,
+            voxelRecordStartIndex: this.voxelRecordStartIndex.buffer,
+            voxelRecord: this.voxelRecord.buffer,
+            relationalVoxelIdToTrueId: this.relationalVoxelIdToTrueId.buffer,
+            relationalVoxelIdToState: this.relationalVoxelIdToState.buffer,
+            relationalVoxelIdToMod: this.relationalVoxelIdToMod.buffer,
+            relationalVoxelRecordStartIndex: this.relationalVoxelRecordStartIndex.buffer,
+            relationalVoxelRecord: this.relationalVoxelRecord.buffer,
+            geometryIndex: this.geometryIndex.buffer,
+            geometryInputsIndex: this.geometryInputsIndex.buffer,
             conditionalGeometryIndex: this.conditionalGeometryIndex,
             conditionalGeometryInputIndex: this.conditionalGeometryInputIndex,
-            voxels: this.voxels,
-            voxelRecord: this.voxelRecord,
-            voxelIdToModelState: this.voxelIdToModelState,
-            reltioanlVoxels: this.reltioanlVoxels,
-            reltionalVoxelRecord: this.reltionalVoxelRecord,
         };
     }
     static import(exported) {
@@ -102,18 +147,30 @@ export class VoxelLUT {
         this.voxelIdToNameMap = new Map(exported.voxelIdToNameMap);
         this.models.load(exported.models);
         this.modelsIndex = exported.modelsIndex;
-        this.totalStates = exported.totalStates;
-        this.totalMods = exported.totalMods;
-        this.totalReltionalStates = exported.totalReltionalStates;
-        this.totalReltionalMods = exported.totalReltionalMods;
-        this.geometryIndex = exported.geometryIndex;
-        this.geometryInputsIndex = exported.geometryInputsIndex;
+        this.totalStates = new Uint16Array(exported.totalStates);
+        this.totalMods = new Uint16Array(exported.totalMods);
+        this.totalReltionalStates = new Uint16Array(exported.totalReltionalStates);
+        this.totalReltionalMods = new Uint16Array(exported.totalReltionalMods);
+        this.totalVoxelIds = exported.totalVoxelIds;
+        this.totalRelationalVoxelIds = exported.totalRelationalVoxelIds;
+        this.totalCombinedIds = exported.totalCombinedIds;
+        this.modelStateMaps = exported.modelStateMaps.map((m) => new Map(m));
+        this.modelRelationalStateMaps = exported.modelRelationalStateMaps.map((m) => new Map(m));
+        this.voxelModMaps = exported.voxelModMaps.map((m) => new Map(m));
+        this.voxelRelationalModMaps = exported.voxelRelationalModMaps.map((m) => new Map(m));
+        this.voxelIdToTrueId = new Uint16Array(exported.voxelIdToTrueId);
+        this.voxelIdToState = new Uint16Array(exported.voxelIdToState);
+        this.voxelIdToMod = new Uint16Array(exported.voxelIdToMod);
+        this.voxelRecordStartIndex = new Uint16Array(exported.voxelRecordStartIndex);
+        this.voxelRecord = new Uint16Array(exported.voxelRecord);
+        this.relationalVoxelIdToTrueId = new Uint16Array(exported.relationalVoxelIdToTrueId);
+        this.relationalVoxelIdToState = new Uint16Array(exported.relationalVoxelIdToState);
+        this.relationalVoxelIdToMod = new Uint16Array(exported.relationalVoxelIdToMod);
+        this.relationalVoxelRecordStartIndex = new Uint16Array(exported.relationalVoxelRecordStartIndex);
+        this.relationalVoxelRecord = new Uint16Array(exported.relationalVoxelRecord);
+        this.geometryIndex = new Uint16Array(exported.geometryIndex);
+        this.geometryInputsIndex = new Uint16Array(exported.geometryInputsIndex);
         this.conditionalGeometryIndex = exported.conditionalGeometryIndex;
         this.conditionalGeometryInputIndex = exported.conditionalGeometryInputIndex;
-        this.voxels = exported.voxels;
-        this.voxelRecord = exported.voxelRecord;
-        this.voxelIdToModelState = exported.voxelIdToModelState;
-        this.reltioanlVoxels = exported.reltioanlVoxels;
-        this.reltionalVoxelRecord = exported.reltionalVoxelRecord;
     }
 }