@divinevoxel/vlox 0.0.71 → 0.0.72

package/Tasks/Propagation/Flow/WorldFlow.js

@@ -1,6 +1,5 @@
 import { WorldSpaces } from "../../../World/WorldSpaces";
 import { WorldRegister } from "../../../World/WorldRegister";
-import { SectionHeightMap } from "../../../World/Section/SectionHeightMap";
 import { EngineSettings } from "../../../Settings/EngineSettings";
 import { SunRemove, SunUpdate } from "../Illumanation/SunUpdate";
 import { RGBRemove, RGBUpdate } from "../Illumanation/RGBUpdate";
@@ -118,7 +117,7 @@ export function WorldFlow(task) {
         const section = sector.sections[i];
         if (!section)
             continue;
-        let [minY, maxY] = SectionHeightMap.setSection(section).getMinMax();
+        let [minY, maxY] = section.getMinMax();
         const cx = sector.position[0];
         const cy = sector.position[1] + i * WorldSpaces.section.bounds.y;
         const cz = sector.position[2];
@@ -130,7 +129,7 @@ export function WorldFlow(task) {
                     const voxel = task.nDataCursor.getVoxel(x, y, z);
                     if (!voxel || voxel.isAir())
                         continue;
-                    if (voxel.getSubstanceData().isLiquid()) {
+                    if (voxel.getSubstanceData()["dve_is_liquid"]) {
                         for (let i = 0; i < 5; i++) {
                             const nVoxel = task.nDataCursor.getVoxel(x + flowUpdateChecks[i][0], y + flowUpdateChecks[i][1], z + flowUpdateChecks[i][2]);
                             if (nVoxel && nVoxel.isAir()) {

package/Tasks/Propagation/Illumanation/WorldRGB.js

@@ -1,7 +1,6 @@
 import { WorldSpaces } from "../../../World/WorldSpaces";
 import { WorldRegister } from "../../../World/WorldRegister";
 import { SectionCursor } from "../../../World/Cursor/SectionCursor";
-import { SectionHeightMap } from "../../../World/Section/SectionHeightMap";
 import { EngineSettings } from "../../../Settings/EngineSettings";
 import { RGBUpdate } from "./RGBUpdate";
 const sectionCursor = new SectionCursor();
@@ -20,7 +19,7 @@ export function WorldRGB(task) {
         if (!section)
             continue;
         sectionCursor.setSection(section);
-        let [minY, maxY] = SectionHeightMap.setSection(section).getMinMax();
+        let [minY, maxY] = section.getMinMax();
         const cx = sector.position[0];
         const cy = sector.position[1] + i * WorldSpaces.section.bounds.y;
         const cz = sector.position[2];

package/Tasks/Update/InitTasks.d.ts

@@ -1,4 +1,5 @@
+import { Thread } from "@amodx/threads";
 import { UpdateTask } from "./UpdateTask";
 export default function (props: {
-    onDone(taks: UpdateTask): void;
+    onDone(taks: UpdateTask, origin: Thread): void;
 }): void;

package/Tasks/Update/InitTasks.js

@@ -2,22 +2,22 @@ import { Threads } from "@amodx/threads";
 import { TasksIds } from "../TasksIds";
 import { VoxelUpdate, EreaseAndUpdate, PaintAndUpdate } from "./VoxelUpdate";
 export default function (props) {
-    Threads.registerTask(TasksIds.VoxelUpdate, async (data) => {
+    Threads.registerTask(TasksIds.VoxelUpdate, async (data, origin) => {
         const tasks = await VoxelUpdate(data);
         if (!tasks)
             return;
-        props.onDone(tasks);
+        props.onDone(tasks, origin);
     });
-    Threads.registerTask(TasksIds.VoxelErease, async (data) => {
+    Threads.registerTask(TasksIds.VoxelErease, async (data, origin) => {
         const tasks = await EreaseAndUpdate(data);
         if (!tasks)
             return;
-        props.onDone(tasks);
+        props.onDone(tasks, origin);
     });
-    Threads.registerTask(TasksIds.VoxelPaint, async (data) => {
+    Threads.registerTask(TasksIds.VoxelPaint, async (data, origin) => {
         const tasks = await PaintAndUpdate(data);
         if (!tasks)
             return;
-        props.onDone(tasks);
+        props.onDone(tasks, origin);
     });
 }

package/Tasks/Update/VoxelUpdate.js

@@ -1,13 +1,11 @@
 import { EngineSettings as ES } from "../../Settings/EngineSettings.js";
 import { $3dCardinalNeighbors } from "../../Math/CardinalNeighbors.js";
 import { UpdateTask } from "./UpdateTask.js";
-import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
 import { RGBRemove, RGBUpdate } from "../Propagation/Illumanation/RGBUpdate.js";
 import { SunRemove, SunUpdate } from "../Propagation/Illumanation/SunUpdate.js";
 import { FlowUpdate } from "../Propagation/Flow/FlowUpdate.js";
 import { FlowRemove } from "../Propagation/Flow/FlowRemove.js";
 const tasks = new UpdateTask();
-const substanceData = new SubstanceDataTool();
 const updateLightTask = (tasks) => {
     let doRGB = ES.doRGBPropagation;
     let doSun = ES.doSunPropagation;
@@ -38,9 +36,9 @@ export async function EreaseAndUpdate(location) {
     let voxel = tasks.sDataCursor.getVoxel(x, y, z);
     if (!voxel)
         return false;
-    substanceData.setSubstance(voxel.getSubstance());
+    const substanceData = voxel.getSubstanceData();
     if (!voxel.isAir() && ES.doFlow && voxel.isRenderable()) {
-        if (substanceData.isLiquid()) {
+        if (substanceData["dve_is_liquid"]) {
             FlowRemove(tasks);
             return tasks;
         }
@@ -70,6 +68,11 @@ export async function EreaseAndUpdate(location) {
             SunUpdate(tasks);
         }
     }
+    for (let i = 0; i < $3dCardinalNeighbors.length; i++) {
+        tasks.sDataCursor
+            .getVoxel($3dCardinalNeighbors[i][0] + x, $3dCardinalNeighbors[i][1] + y, $3dCardinalNeighbors[i][2] + z)
+            ?.updateVoxel(2);
+    }
     return tasks;
 }
 export async function PaintAndUpdate(data) {
@@ -107,6 +110,7 @@ export async function PaintAndUpdate(data) {
     voxel.setLevel(raw[2]);
     voxel.setState(raw[3]);
     voxel.setMod(raw[4]);
+    voxel.process();
     if (raw[3] > 0 && voxel.canHaveSecondaryVoxel()) {
         voxel.setSecondary(true);
         voxel.setId(raw[5]);
@@ -128,11 +132,15 @@ export async function PaintAndUpdate(data) {
     }
     voxel = tasks.sDataCursor.getVoxel(x, y, z);
     if (ES.doFlow) {
-        if (!voxel.isAir() &&
-            substanceData.setSubstance(voxel.getSubstance()).isLiquid()) {
+        if (!voxel.isAir() && voxel.getSubstanceData()["dve_is_liquid"]) {
             FlowUpdate(tasks);
         }
     }
+    for (let i = 0; i < $3dCardinalNeighbors.length; i++) {
+        tasks.sDataCursor
+            .getVoxel($3dCardinalNeighbors[i][0] + x, $3dCardinalNeighbors[i][1] + y, $3dCardinalNeighbors[i][2] + z)
+            ?.updateVoxel(2);
+    }
     return tasks;
 }
 export async function VoxelUpdate(data) {
@@ -155,7 +163,7 @@ export async function VoxelUpdate(data) {
         }
     }
     if (ES.doFlow) {
-        if (substanceData.setSubstance(voxel.getSubstance()).isLiquid()) {
+        if (voxel.getSubstanceData()["dve_is_solid"]) {
             FlowUpdate(tasks);
         }
     }

package/Tasks/WorldGeneration/WorldGenBrush.js

@@ -64,6 +64,7 @@ export class WorldGenBrush extends BrushTool {
         if (!voxel)
             return false;
         const sl = voxel.getLight();
+        voxel.updateVoxel(2);
         if (lightData.hasRGBLight(sl)) {
             this.tasks.rgb.update.push(this.x, this.y, this.z);
             //    Propagation.instance.rgbUpdate(this.tasks);

package/Templates/Cursor/TemplateCursor.d.ts

@@ -1,5 +1,5 @@
 import { TemplateVoxelCursor } from "./TemplateVoxelCursor";
-import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
+import { DataCursorInterface } from "../../Tools/DataCursor.interface";
 import { FullVoxelTemplate } from "Templates/FullVoxelTemplate";
 export declare class TemplateCursor extends DataCursorInterface {
     _voxelIndex: number;

package/Templates/Cursor/TemplateCursor.js

@@ -1,5 +1,5 @@
 import { TemplateVoxelCursor } from "./TemplateVoxelCursor";
-import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
+import { DataCursorInterface } from "../../Tools/DataCursor.interface";
 export class TemplateCursor extends DataCursorInterface {
     _voxelIndex = 0;
     _template = null;

package/Templates/Functions/CreateTemplate.js

@@ -2,7 +2,7 @@ import { Flat3DIndex, Traverse } from "@amodx/math";
 import { StringPalette } from "../../Util/StringPalette";
 import { VoxelTemplate } from "../VoxelTemplate";
 import { NumberPalette } from "../../Util/NumberPalette";
-import { convertToPaletteBuffer } from "../../Data/Functions/Palettes";
+import { convertToPaletteBuffer } from "../../Util/Binary/Palettes";
 import { WorldCursor } from "../../World";
 export default function CreateTemplate(dimension, start, end) {
     const dataTool = new WorldCursor();

package/Templates/VoxelTemplate.js

@@ -1,10 +1,9 @@
 import { Flat3DIndex, Traverse } from "@amodx/math";
 import { StringPalette } from "../Util/StringPalette";
 import { NumberPalette } from "../Util/NumberPalette";
-import { VoxelPalette } from "../Voxels/Palettes/VoxelPalette";
-import { VoxelStruct } from "../Voxels/Structs/VoxelStruct";
-import { VoxelStructIds } from "../Voxels/Types/Voxel.types";
-import { getPaletteArray } from "../Data/Functions/Palettes";
+import { getPaletteArray } from "../Util/Binary/Palettes";
+import { VoxelPalettesRegister } from "../Voxels/Data/VoxelPalettesRegister";
+import { VoxelTagsRegister } from "../Voxels/Data/VoxelTagsRegister";
 export class VoxelTemplate {
     index = Flat3DIndex.GetXZYOrder();
     size;
@@ -49,7 +48,7 @@ export class VoxelTemplate {
     }
     getId(index) {
         const ids = this.ids;
-        return VoxelPalette.ids.getNumberId(this.idPalette.getStringId(typeof ids == "number" ? ids : ids[index]));
+        return VoxelPalettesRegister.voxels.getNumberId(this.idPalette.getStringId(typeof ids == "number" ? ids : ids[index]));
     }
     getState(index) {
         const state = this.state;
@@ -65,9 +64,8 @@ export class VoxelTemplate {
     }
     getSecondary(id, index) {
         const secondary = this.secondary;
-        VoxelStruct.setVoxel(id);
-        if (VoxelStruct.instance[VoxelStructIds.canHaveSecondary] == 1) {
-            return VoxelPalette.ids.getNumberId(this.secondaryIdPalette.getStringId(typeof secondary == "number" ? secondary : secondary[index]));
+        if (VoxelTagsRegister.VoxelTags[id]["dve_can_have_secondary"]) {
+            return VoxelPalettesRegister.voxels.getNumberId(this.secondaryIdPalette.getStringId(typeof secondary == "number" ? secondary : secondary[index]));
         }
         return this.secondaryStatePalette.getValue(typeof secondary == "number" ? secondary : secondary[index]);
     }

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;
@@ -11,7 +10,6 @@ export declare class BrushTool {
     name: string;
     voxelCursor: VoxelCursor;
     dataCursor: WorldCursor;
-    substanceData: SubstanceDataTool;
     setXYZ(x: number, y: number, z: number): this;
     newSector(): void;
     setData(data: Partial<PaintVoxelData>): this;

package/Tools/Brush/Brush.js

@@ -1,8 +1,7 @@
-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 {
@@ -21,7 +20,6 @@ export class BrushTool {
     name = airId;
     voxelCursor = new VoxelCursor();
     dataCursor = new WorldCursor();
-    substanceData = new SubstanceDataTool();
     setXYZ(x, y, z) {
         this.x = x;
         this.y = y;
@@ -67,7 +65,7 @@ export class BrushTool {
         return this;
     }
     setName(name) {
-        this.data.id = VoxelPalette.name.getId(name);
+        this.data.id = VoxelPalettesRegister.voxelName.getId(name);
         this.name = name;
         return this;
     }
@@ -109,7 +107,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 +118,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/{Data/Cursor → Tools}/DataCursor.interface.d.ts

@@ -1,4 +1,4 @@
-import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface";
+import { VoxelCursorInterface } from "../Voxels/Cursor/VoxelCursor.interface";
 export declare abstract class DataCursorInterface {
     abstract getVoxel(x: number, y: number, z: number): VoxelCursorInterface | null;
     abstract inBounds(x: number, y: number, z: number): boolean;

package/Util/Binary/BitArray.d.ts

@@ -0,0 +1,4 @@
+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 getBitArrayIndex(data: Uint8Array, arrayIndex: number): number;
+export declare function setBitArrayIndex(data: Uint8Array, arrayIndex: number, value: number): void;

package/Util/Binary/BitArray.js

@@ -0,0 +1,16 @@
+export function getBitValue(data, bitIndex, bitSize) {
+    const mask = 2 ** bitSize - 1;
+    return ((mask << bitIndex) & data) >>> bitIndex;
+}
+export function setBitValue(data, bitIndex, value, bitSize) {
+    const mask = 2 ** bitSize - 1;
+    return (data & ~(mask << bitIndex)) | ((value & mask) << bitIndex);
+}
+export function getBitArrayIndex(data, arrayIndex) {
+    const arrayByteIndex = (arrayIndex / 8) >> 0;
+    return getBitValue(data[arrayByteIndex], arrayIndex - arrayByteIndex * 8, 1);
+}
+export function setBitArrayIndex(data, arrayIndex, value) {
+    const arrayByteIndex = (arrayIndex / 8) >> 0;
+    data[arrayByteIndex] = setBitValue(data[arrayByteIndex], arrayIndex - arrayByteIndex * 8, value, 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/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;

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,7 +105,7 @@ export class VoxelCursorInterface {
     getLight() {
         if (this._loadedId == 0)
             return this.light[this._index];
-        const lightValue = this.__struct[VoxelStructIds.lightValue];
+        const lightValue = this._tags[VoxelTagIds.lightValue];
         if (this.isOpaque()) {
             if (this.isLightSource() && lightValue) {
                 return lightValue;
@@ -146,19 +126,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,16 +169,16 @@ 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));
+        this.setStringId(VoxelPalettesRegister.voxelName.getId(name));
     }
     getName() {
         return this.getStringId();

package/Voxels/Cursor/VoxelCursor.js

@@ -1,11 +1,13 @@
 import { VoxelCursorInterface } from "./VoxelCursor.interface";
-import { VoxelPalette } from "../../Voxels/Palettes/VoxelPalette";
-import { VoxelLevelReader } from "../VoxelLevelReader";
+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 && VoxelPalette.ids.getNumberId(data.id)) || 0;
+        const id = (data.id !== undefined &&
+            VoxelPalettesRegister.voxels.getNumberId(data.id)) ||
+            0;
         const secondaryId = (data.secondaryVoxelId !== undefined &&
-            VoxelPalette.ids.getNumberId(data.secondaryVoxelId)) ||
+            VoxelPalettesRegister.voxels.getNumberId(data.secondaryVoxelId)) ||
             0;
         let levleData = 0;
         if (data.level !== undefined)
@@ -14,13 +16,12 @@ export class VoxelCursor extends VoxelCursorInterface {
             levleData = VoxelLevelReader.setLevelState(levleData, data.levelState);
         return [id, light, levleData, data.state || 0, data.mod || 0, secondaryId];
     }
-    ids = [0];
-    light = [0];
-    level = [0];
-    state = [0];
-    secondary = [0];
-    mod = [0];
+    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) {
-    }
+    updateVoxel(mode) { }
 }

package/Voxels/Cursor/VoxelLightData.d.ts

@@ -20,8 +20,7 @@ export declare class VoxelLightData {
     mixLight(l1: number, l2: number): number;
     getRGB(sl: number): number;
     setRGB(value: number, sl: number): number;
-    decodeLightFromVoxelData(voxelData: number): number;
-    encodeLightIntoVoxelData(voxelData: number, encodedLight: number): number;
+    createLightValue(s: number, r: number, g: number, b: number): number;
     /**# Set Light Values
      * ---
      * Give an array of light values it will return an encoded light number.
@@ -37,8 +36,8 @@ export declare class VoxelLightData {
      * - 3: Blue Light
      * @param value
      */
-    getLightValues(value: number): AllLight;
-    getLightValuesToRef(value: number, values: AllLight): AllLight;
+    getLightValuesArray(value: number): AllLight;
+    getLightValuesArrayToRef(value: number, values: AllLight): AllLight;
     addLightValues(sl: number, sl2: number): number;
     divideLightValue(sl: number, divisor: number): number;
 }