@divinevoxel/vlox 0.0.71 → 0.0.73

package/Tools/Brush/Brush.d.ts

@@ -1,6 +1,5 @@
 import type { PaintVoxelData, RawVoxelData } from "../../Voxels/Types/Voxel.types.js";
 import { WorldCursor } from "../../World/Cursor/WorldCursor.js";
-import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
 import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor.js";
 export declare class BrushTool {
     data: PaintVoxelData;
@@ -8,10 +7,8 @@ export declare class BrushTool {
     x: number;
     y: number;
     z: number;
-    name: string;
     voxelCursor: VoxelCursor;
     dataCursor: WorldCursor;
-    substanceData: SubstanceDataTool;
     setXYZ(x: number, y: number, z: number): this;
     newSector(): void;
     setData(data: Partial<PaintVoxelData>): this;
@@ -21,6 +18,7 @@ export declare class BrushTool {
     setId(id: string): this;
     setName(name: string): this;
     setSecondaryId(id: string): this;
+    setSecondaryName(name: string): this;
     setShapeState(state: number): this;
     setLevel(level: number): this;
     setLevelState(levelState: number): this;

package/Tools/Brush/Brush.js

@@ -1,15 +1,16 @@
-import { VoxelPalette } from "../../Voxels/Palettes/VoxelPalette.js";
 import { WorldCursor } from "../../World/Cursor/WorldCursor.js";
-import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
 import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor.js";
 import { WorldRegister } from "../../World/WorldRegister.js";
+import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister.js";
 const airId = "dve_air";
 const air = [0, 0, 0, 0, 0, 0];
 export class BrushTool {
     data = {
         id: airId,
+        name: "",
         state: 0,
         secondaryVoxelId: "",
+        secondaryVoxeName: "",
         level: 0,
         levelState: 0,
         mod: 0,
@@ -18,10 +19,8 @@ export class BrushTool {
     x = 0;
     y = 0;
     z = 0;
-    name = airId;
     voxelCursor = new VoxelCursor();
     dataCursor = new WorldCursor();
-    substanceData = new SubstanceDataTool();
     setXYZ(x, y, z) {
         this.x = x;
         this.y = y;
@@ -32,11 +31,22 @@ export class BrushTool {
         WorldRegister.sectors.new(this.dimension, this.x, this.y, this.z);
     }
     setData(data) {
-        this.data.id = data.id ? data.id : airId;
+        this.clear();
+        if (data.name) {
+            this.setName(data.name);
+        }
+        else {
+            if (data.id)
+                this.setId(data.id);
+        }
+        if (data.secondaryVoxeName) {
+            this.setSecondaryName(data.secondaryVoxeName);
+        }
+        else {
+            if (data.secondaryVoxelId)
+                this.setSecondaryId(data.secondaryVoxelId);
+        }
         this.data.state = data.state ? data.state : 0;
-        this.data.secondaryVoxelId = data.secondaryVoxelId
-            ? data.secondaryVoxelId
-            : airId;
         this.data.level = data.level ? data.level : 0;
         this.data.levelState = data.levelState ? data.levelState : 0;
         this.data.mod = data.mod ? data.mod : 0;
@@ -64,15 +74,34 @@ export class BrushTool {
     }
     setId(id) {
         this.data.id = id;
+        this.data.name = VoxelPalettesRegister.voxelIdToNameMap.get(id);
         return this;
     }
     setName(name) {
-        this.data.id = VoxelPalette.name.getId(name);
-        this.name = name;
+        this.data.id = VoxelPalettesRegister.voxelNametoIdMap.get(name);
+        this.data.name = name;
         return this;
     }
     setSecondaryId(id) {
         this.data.secondaryVoxelId = id;
+        if (id) {
+            this.data.secondaryVoxeName =
+                VoxelPalettesRegister.voxelIdToNameMap.get(id);
+        }
+        else {
+            this.data.secondaryVoxeName = "";
+        }
+        return this;
+    }
+    setSecondaryName(name) {
+        if (name) {
+            this.data.secondaryVoxelId =
+                VoxelPalettesRegister.voxelNametoIdMap.get(name);
+        }
+        else {
+            this.data.secondaryVoxelId = "";
+        }
+        this.data.secondaryVoxeName = name;
         return this;
     }
     setShapeState(state) {
@@ -93,6 +122,7 @@ export class BrushTool {
     }
     clear() {
         this.data.id = "dve_air";
+        this.data.name = "";
         this.data.secondaryVoxelId = "";
         this.data.level = 0;
         this.data.levelState = 0;
@@ -109,7 +139,7 @@ export class BrushTool {
         const voxel = this.dataCursor.getVoxel(this.x, this.y, this.z);
         if (!voxel)
             return;
-        const id = VoxelPalette.ids.getNumberId(this.data.id);
+        const id = VoxelPalettesRegister.voxels.getNumberId(this.data.id);
         if (id < 0)
             return false;
         voxel.setId(id);
@@ -120,13 +150,14 @@ export class BrushTool {
         voxel.setLevel(this.data.level);
         voxel.setMod(this.data.mod);
         if (this.data.secondaryVoxelId) {
-            const vid = VoxelPalette.ids.getNumberId(this.data.secondaryVoxelId);
+            const vid = VoxelPalettesRegister.voxels.getNumberId(this.data.secondaryVoxelId);
             if (vid > 0) {
                 voxel.setSecondary(true);
                 voxel.setId(vid);
                 voxel.setSecondary(false);
             }
         }
+        voxel.process();
         if (voxel.isLightSource() && voxel.getLightSourceValue()) {
             voxel.setLight(voxel.getLightSourceValue());
         }

package/Util/Binary/BinaryArrays.d.ts

@@ -0,0 +1,6 @@
+export declare function getBitArrayIndex(data: Uint8Array, arrayIndex: number): number;
+export declare function setBitArrayIndex(data: Uint8Array, arrayIndex: number, value: number): void;
+export declare function getNibbleArrayIndex(data: Uint8Array, arrayIndex: number): number;
+export declare function setNibbleArrayIndex(data: Uint8Array, arrayIndex: number, value: number): void;
+export declare function getHalfNibbleArrayIndex(data: Uint8Array, arrayIndex: number): number;
+export declare function setHalfNibbleArrayIndex(data: Uint8Array, arrayIndex: number, value: number): void;

package/Util/Binary/BinaryArrays.js

@@ -0,0 +1,25 @@
+import { getBitValue, setBitValue } from "./BinaryFunctions";
+export function getBitArrayIndex(data, arrayIndex) {
+    const arrayByteIndex = Math.floor(arrayIndex / 8);
+    const bitPosition = arrayIndex % 8;
+    return getBitValue(data[arrayByteIndex], bitPosition, 1);
+}
+export function setBitArrayIndex(data, arrayIndex, value) {
+    const arrayByteIndex = Math.floor(arrayIndex / 8);
+    const bitPosition = arrayIndex % 8;
+    data[arrayByteIndex] = setBitValue(data[arrayByteIndex], bitPosition, value & 1, 1);
+}
+export function getNibbleArrayIndex(data, arrayIndex) {
+    return getBitValue(data[(arrayIndex / 2) >> 0], arrayIndex % 2 === 0 ? 4 : 0, 4);
+}
+export function setNibbleArrayIndex(data, arrayIndex, value) {
+    const arrayByteIndex = (arrayIndex / 2) >> 0;
+    data[arrayByteIndex] = setBitValue(data[arrayByteIndex], arrayIndex % 2 === 0 ? 4 : 0, value, 4);
+}
+export function getHalfNibbleArrayIndex(data, arrayIndex) {
+    return getBitValue(data[(arrayIndex / 4) >> 0], (arrayIndex % 4) * 2, 2);
+}
+export function setHalfNibbleArrayIndex(data, arrayIndex, value) {
+    const arrayByteIndex = (arrayIndex / 4) >> 0;
+    data[arrayByteIndex] = setBitValue(data[arrayByteIndex], (arrayIndex % 4) * 2, value, 2);
+}

package/Util/Binary/BinaryBuffer.d.ts

@@ -0,0 +1,29 @@
+export type BinaryBufferTypes = 
+/**If the buffer compressed to a single value the type will be a vlaue */
+"value" | "1-bit" | "2-bit" | "4-bit" | "8-bit" | "16-bit";
+export interface BinaryBufferData {
+    type?: BinaryBufferTypes;
+    buffer: number | Uint8Array | Uint16Array;
+}
+export interface BinaryBuffer extends BinaryBufferData {
+}
+export declare class BinaryBuffer {
+    static BytePaletteMax: number;
+    static NibblePaletteMax: number;
+    static HalfNibblePaletteMax: number;
+    static BitPaletteMax: number;
+    static DetermineSubByteArray: (paletteSize: number) => BinaryBufferTypes | null;
+    static CreateBufferForType(type: BinaryBufferTypes, length: number): Uint16Array | Uint8Array;
+    static GetConvertedBufferSize(source: Uint8Array | Uint16Array, type: BinaryBufferTypes): number;
+    static GetIndexLength(source: Uint8Array | Uint16Array, type: BinaryBufferTypes): number;
+    static ReadBufferAtIndex(source: Uint8Array | Uint16Array, type: BinaryBufferTypes, index: number): number;
+    static SetBufferAtIndex(source: Uint8Array | Uint16Array, type: BinaryBufferTypes, index: number, value: number): number | void;
+    static Convert(source: Uint8Array | Uint16Array, sourceType: BinaryBufferTypes, destinationType: BinaryBufferTypes): Uint16Array | Uint8Array;
+    static Create(data: Partial<BinaryBufferData>): BinaryBufferData;
+    constructor(data: BinaryBufferData);
+    getValue(index: number): number;
+    toJSON(): {
+        type?: BinaryBufferTypes | undefined;
+        buffer: number | Uint16Array | Uint8Array;
+    };
+}

package/Util/Binary/BinaryBuffer.js

@@ -0,0 +1,130 @@
+import { getBitArrayIndex, getHalfNibbleArrayIndex, getNibbleArrayIndex, setBitArrayIndex, setHalfNibbleArrayIndex, setNibbleArrayIndex, } from "./BinaryArrays";
+const excludeStore = ["16-bit", "8-bit", "value"];
+export class BinaryBuffer {
+    static BytePaletteMax = 256;
+    static NibblePaletteMax = 16;
+    static HalfNibblePaletteMax = 4;
+    static BitPaletteMax = 2;
+    static DetermineSubByteArray = (paletteSize) => {
+        if (paletteSize == BinaryBuffer.BitPaletteMax)
+            return "1-bit";
+        if (paletteSize > BinaryBuffer.BitPaletteMax &&
+            paletteSize <= BinaryBuffer.HalfNibblePaletteMax)
+            return "2-bit";
+        if (paletteSize > BinaryBuffer.HalfNibblePaletteMax &&
+            paletteSize <= BinaryBuffer.NibblePaletteMax)
+            return "4-bit";
+        if (paletteSize > BinaryBuffer.NibblePaletteMax &&
+            paletteSize <= BinaryBuffer.BytePaletteMax)
+            return "8-bit";
+        return null;
+    };
+    static CreateBufferForType(type, length) {
+        if (type == "16-bit")
+            return new Uint16Array(length);
+        if (type == "8-bit")
+            return new Uint8Array(length);
+        if (type == "1-bit")
+            return new Uint8Array(length);
+        if (type == "2-bit")
+            return new Uint8Array(length);
+        if (type == "4-bit")
+            return new Uint8Array(length);
+        return new Uint8Array(length);
+    }
+    static GetConvertedBufferSize(source, type) {
+        if (type == "16-bit" || type == "8-bit")
+            return source.length;
+        if (type == "1-bit")
+            return source.length / 8;
+        if (type == "4-bit")
+            return source.length / 2;
+        if (type == "2-bit")
+            return source.length / 4;
+        if (type == "value")
+            return 1;
+        return source.length;
+    }
+    static GetIndexLength(source, type) {
+        if (type == "16-bit" || type == "8-bit")
+            return source.length;
+        if (type == "1-bit")
+            return source.length * 8;
+        if (type == "4-bit")
+            return source.length * 2;
+        if (type == "2-bit")
+            return source.length * 4;
+        if (type == "value")
+            return 1;
+        return source.length;
+    }
+    static ReadBufferAtIndex(source, type, index) {
+        if (type == "16-bit" || type == "8-bit")
+            return source[index];
+        if (type == "1-bit")
+            return getBitArrayIndex(source, index);
+        if (type == "4-bit")
+            return getNibbleArrayIndex(source, index);
+        if (type == "2-bit")
+            return getHalfNibbleArrayIndex(source, index);
+        return source[index];
+    }
+    static SetBufferAtIndex(source, type, index, value) {
+        if (type == "16-bit" || type == "8-bit") {
+            return (source[index] = value);
+        }
+        if (type == "1-bit")
+            return setBitArrayIndex(source, index, value);
+        if (type == "4-bit")
+            return setNibbleArrayIndex(source, index, value);
+        if (type == "2-bit")
+            return setHalfNibbleArrayIndex(source, index, value);
+        return source[index];
+    }
+    static Convert(source, sourceType, destinationType) {
+        if (sourceType == destinationType ||
+            (sourceType == "16-bit" && destinationType == "8-bit") ||
+            (sourceType == "8-bit" && destinationType == "16-bit")) {
+            const destination = this.CreateBufferForType(destinationType, this.GetConvertedBufferSize(source, destinationType));
+            destination.set(source);
+            return destination;
+        }
+        const length = this.GetIndexLength(source, sourceType);
+        const destination = this.CreateBufferForType(destinationType, this.GetConvertedBufferSize(source, destinationType));
+        for (let i = 0; i < length; i++) {
+            this.SetBufferAtIndex(destination, destinationType, i, this.ReadBufferAtIndex(source, sourceType, i));
+        }
+        return destination;
+    }
+    static Create(data) {
+        return {
+            buffer: 0,
+            ...data,
+        };
+    }
+    constructor(data) {
+        this.buffer = data.buffer;
+        if (data.type) {
+            this.type = data.type;
+        }
+        else {
+            if (typeof data.buffer === "number")
+                this.type = "value";
+            if (data.buffer instanceof Uint16Array)
+                this.type = "16-bit";
+            if (data.buffer instanceof Uint8Array)
+                this.type = "8-bit";
+        }
+    }
+    getValue(index) {
+        if (typeof this.buffer == "number")
+            return this.buffer;
+        return BinaryBuffer.ReadBufferAtIndex(this.buffer, this.type, index);
+    }
+    toJSON() {
+        return {
+            buffer: this.buffer,
+            ...(excludeStore.includes(this.type) ? {} : { type: this.type }),
+        };
+    }
+}

package/Util/Binary/BinaryFunctions.d.ts

@@ -0,0 +1,3 @@
+export declare function getBitValue(data: number, bitIndex: number, bitSize: number): number;
+export declare function setBitValue(data: number, bitIndex: number, value: number, bitSize: number): number;
+export declare function forceMultipleOf2(n: number): number;

package/Util/Binary/BinaryFunctions.js

@@ -0,0 +1,11 @@
+export function getBitValue(data, bitIndex, bitSize) {
+    const mask = (1 << bitSize) - 1;
+    return (data >>> bitIndex) & mask;
+}
+export function setBitValue(data, bitIndex, value, bitSize) {
+    const mask = (1 << bitSize) - 1;
+    return (data & ~(mask << bitIndex)) | ((value & mask) << bitIndex);
+}
+export function forceMultipleOf2(n) {
+    return n % 2 === 0 ? n : n + 1;
+}

package/Util/StringPalette.d.ts

@@ -4,6 +4,7 @@ export declare class StringPalette {
     _map: Record<string, number>;
     constructor(inital?: ArrayLike<string>);
     get size(): number;
+    load(palette: string[]): void;
     register(string: string): number;
     get(): string[];
     getMap(): Record<string, number>;

package/Util/StringPalette.js

@@ -13,6 +13,14 @@ export class StringPalette {
     get size() {
         return this._count;
     }
+    load(palette) {
+        this._palette = [];
+        this._map = {};
+        const length = palette.length;
+        for (let i = 0; i < length; i++) {
+            this.register(palette[i]);
+        }
+    }
     register(string) {
         const id = this._count;
         this._count++;

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

@@ -0,0 +1,5 @@
+import { VoxelCursorInterface } from "./VoxelCursor.interface";
+export interface DataCursorInterface {
+    getVoxel(x: number, y: number, z: number): VoxelCursorInterface | null;
+    inBounds(x: number, y: number, z: number): boolean;
+}

package/Voxels/Cursor/VoxelCursor.d.ts

@@ -2,12 +2,12 @@ import { VoxelCursorInterface } from "./VoxelCursor.interface";
 import { PaintVoxelData, RawVoxelData } from "../Types/Voxel.types";
 export declare class VoxelCursor extends VoxelCursorInterface {
     static VoxelDataToRaw(data: Partial<PaintVoxelData>, light?: number): RawVoxelData;
-    ids: number[];
-    light: number[];
-    level: number[];
-    state: number[];
-    secondary: number[];
-    mod: number[];
+    ids: Uint16Array;
+    light: Uint16Array;
+    level: Uint8Array;
+    state: Uint16Array;
+    mod: Uint16Array;
+    secondary: Uint16Array;
     loadIn(): void;
     updateVoxel(mode: 0 | 1): void;
 }

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

@@ -1,7 +1,6 @@
 import { VoxelLightData } from "./VoxelLightData";
-import { VoxelStruct } from "../Structs/VoxelStruct";
 import { RawVoxelData } from "../Types/Voxel.types";
-import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool";
+import { VoxelSubstanceTags, VoxelTags } from "../../Voxels/Data/VoxelTag.types";
 interface WritableArrayLike<T> {
     length: number;
     [index: number]: T;
@@ -10,7 +9,8 @@ export declare abstract class VoxelCursorInterface {
     _loadedId: number;
     id: number;
     secondaryId: number;
-    __struct: VoxelStruct;
+    _tags: VoxelTags;
+    _substanceTags: VoxelSubstanceTags;
     __secondary: boolean;
     _index: number;
     abstract ids: WritableArrayLike<number>;
@@ -21,24 +21,19 @@ export declare abstract class VoxelCursorInterface {
     abstract mod: WritableArrayLike<number>;
     /**
      *
-     * @param mode 0 for add 1 for remove
+     * @param mode 0 for add 1 for remove 2 for the voxel needs a buried check only
      */
-    abstract updateVoxel(mode: 0 | 1): void;
+    abstract updateVoxel(mode: 0 | 1 | 2): void;
     _lightData: VoxelLightData;
-    _substanceData: SubstanceDataTool;
     process(): void;
     abstract loadIn(): void;
     setSecondary(enable: boolean): this;
-    getRenderedMaterial(): number;
-    getRenderedMaterialStringId(): string;
-    getMaterial(): number;
-    getMaterialStringId(): string;
+    getRenderedMaterial(): string;
+    getMaterial(): string;
     checkCollisions(): boolean;
-    getCollider(): number;
-    getColliderStringId(): string | null;
-    getSubstance(): number;
-    getSubstanceData(): SubstanceDataTool;
-    getSubstanceStringId(): string;
+    getCollider(): string;
+    getSubstance(): string;
+    getSubstanceData(): VoxelSubstanceTags;
     isOpaque(): boolean;
     getMod(): number;
     setMod(mod: number): this;
@@ -64,7 +59,7 @@ export declare abstract class VoxelCursorInterface {
     setId(id: number): this;
     setStringId(id: string): this;
     getStringId(): string;
-    setName(name: string): void;
+    setName(name: string): this;
     getName(): string;
     isSameVoxel(voxel: VoxelCursorInterface): boolean;
     copy(cursor: VoxelCursorInterface): this;

package/Voxels/Cursor/VoxelCursor.interface.js

@@ -1,26 +1,20 @@
-import { VoxelStructIds } from "../Types/Voxel.types";
 import { VoxelLightData } from "./VoxelLightData";
-import { MappedDataRegister } from "../../Data/Register/MappedDataRegister";
-import { VoxelStruct } from "../Structs/VoxelStruct";
-import { VoxelLevelReader } from "../VoxelLevelReader";
-import { VoxelTagStates } from "../State/VoxelTagStates";
-import { VoxelPalette } from "../Palettes/VoxelPalette";
-import { SubstancePalette } from "../Palettes/SubstancePalette";
-import { MaterialPalette } from "../Palettes/MaterialPalette";
-import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool";
+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";
 export class VoxelCursorInterface {
     _loadedId = 0;
     id = 0;
     secondaryId = 0;
-    __struct;
+    _tags;
+    _substanceTags;
     __secondary = false;
     // private _section: Section;
     _index = 0;
     _lightData = new VoxelLightData();
-    _substanceData = new SubstanceDataTool();
     process() {
-        if (!this.__struct)
-            this.__struct = VoxelStruct.clone();
         this.id = this.ids[this._index];
         this.secondaryId = this.secondary[this._index];
         if (this.secondaryId > 1) {
@@ -29,52 +23,38 @@ export class VoxelCursorInterface {
         else {
             this.secondaryId = 0;
         }
-        this.__struct.setIndex(VoxelStruct.voxelIndex[this.id]);
         this._loadedId = this.getId();
+        this._tags = VoxelTagsRegister.VoxelTags[this._loadedId];
+        this._substanceTags =
+            VoxelTagsRegister.SubstanceStags[VoxelPalettesRegister.substance.getNumberId(this._tags["dve_substance"])];
     }
     setSecondary(enable) {
         this.__secondary = enable;
-        if (enable) {
-            this.__struct.setIndex(VoxelStruct.voxelIndex[this.secondaryId]);
-        }
-        else {
-            this.__struct.setIndex(VoxelStruct.voxelIndex[this.id]);
-        }
+        VoxelTagIds;
+        VoxelTagsRegister;
         this._loadedId = this.getId();
         return this;
     }
     getRenderedMaterial() {
-        return this.__struct[VoxelStructIds.renderedMaterial];
-    }
-    getRenderedMaterialStringId() {
-        return MaterialPalette.id.stringFromNumber(this.__struct[VoxelStructIds.renderedMaterial]);
+        return this._tags[VoxelTagIds.renderedMaterial];
     }
     getMaterial() {
-        return this.__struct[VoxelStructIds.voxelMaterial];
-    }
-    getMaterialStringId() {
-        return MaterialPalette.id.stringFromNumber(this.__struct[VoxelStructIds.voxelMaterial]);
+        return this._tags[VoxelTagIds.voxelMaterial];
     }
     checkCollisions() {
-        return this.__struct[VoxelStructIds.checkCollisions] == 1;
+        return this._tags[VoxelTagIds.checkCollisions];
     }
     getCollider() {
-        return this.__struct[VoxelStructIds.colliderID];
-    }
-    getColliderStringId() {
-        return MappedDataRegister.stringMaps.get("voxel", VoxelStructIds.colliderID, this.__struct[VoxelStructIds.colliderID]);
+        return this._tags[VoxelTagIds.colliderID];
     }
     getSubstance() {
-        return this.__struct[VoxelStructIds.substance];
+        return this._tags[VoxelTagIds.substance];
     }
     getSubstanceData() {
-        return this._substanceData.setSubstance(this.getSubstance());
-    }
-    getSubstanceStringId() {
-        return SubstancePalette.id.stringFromNumber(this.getSubstance());
+        return this._substanceTags;
     }
     isOpaque() {
-        return this.__struct[VoxelStructIds.isTransparent] == 0;
+        return !this._tags[VoxelTagIds.isTransparent];
     }
     getMod() {
         return this.mod[this._index];
@@ -108,7 +88,7 @@ export class VoxelCursorInterface {
         return this.secondaryId > 1;
     }
     canHaveSecondaryVoxel() {
-        return this.__struct[VoxelStructIds.canHaveSecondary] == 1;
+        return this._tags[VoxelTagIds.canHaveSecondary];
     }
     hasRGBLight() {
         const light = this.getLight();
@@ -125,17 +105,14 @@ export class VoxelCursorInterface {
     getLight() {
         if (this._loadedId == 0)
             return this.light[this._index];
-        const lightValue = this.__struct[VoxelStructIds.lightValue];
         if (this.isOpaque()) {
-            if (this.isLightSource() && lightValue) {
-                return lightValue;
-            }
-            else {
-                return -1;
+            if (this.isLightSource()) {
+                return this._tags[VoxelTagIds.lightValue];
             }
+            return -1;
         }
-        if (this.isLightSource() && lightValue) {
-            return this._lightData.mixLight(this.light[this._index], lightValue);
+        if (this.isLightSource()) {
+            return this._lightData.mixLight(this.light[this._index], this._tags[VoxelTagIds.lightValue]);
         }
         return this.light[this._index];
     }
@@ -146,19 +123,19 @@ export class VoxelCursorInterface {
     isLightSource() {
         if (this._loadedId <= 0)
             return false;
-        return VoxelTagStates.isRegistered(this._loadedId, VoxelStructIds.isLightSource)
-            ? VoxelTagStates.getValue(this._loadedId, VoxelStructIds.isLightSource, this.getState()) === true
-            : this.__struct[VoxelStructIds.isLightSource] == 1;
+        return VoxelTagStates.isRegistered(this._loadedId, VoxelTagIds.isLightSource)
+            ? VoxelTagStates.getValue(this._loadedId, VoxelTagIds.isLightSource, this.getState()) === true
+            : this._tags[VoxelTagIds.isLightSource];
     }
     getLightSourceValue() {
         if (this._loadedId <= 0)
             return 0;
-        return this.__struct[VoxelStructIds.lightValue];
+        return this._tags[VoxelTagIds.lightValue];
     }
     noAO() {
         if (this._loadedId <= 0)
             return false;
-        return this.__struct[VoxelStructIds.noAO] == 1;
+        return this._tags[VoxelTagIds.noAO];
     }
     isRenderable() {
         if (this.id > 0)
@@ -189,19 +166,19 @@ export class VoxelCursorInterface {
         return this;
     }
     setStringId(id) {
-        return this.setId(VoxelPalette.ids.getNumberId(id));
+        return this.setId(VoxelPalettesRegister.voxels.getNumberId(id));
     }
     getStringId() {
         if (this.__secondary) {
-            return VoxelPalette.ids.getStringId(this.secondaryId);
+            return VoxelPalettesRegister.voxels.getStringId(this.secondaryId);
         }
-        return VoxelPalette.ids.getStringId(this.id);
+        return VoxelPalettesRegister.voxels.getStringId(this.id);
     }
     setName(name) {
-        this.setStringId(VoxelPalette.name.getId(name));
+        return this.setStringId(VoxelPalettesRegister.voxelNametoIdMap.get(name));
     }
     getName() {
-        return this.getStringId();
+        return VoxelPalettesRegister.voxelIdToNameMap.get(this.getStringId());
     }
     isSameVoxel(voxel) {
         return this.getId() == voxel.getId();