@divinevoxel/vlox 0.0.1 → 0.0.3

package/Contexts/World/DivineVoxelEngineWorld.d.ts

@@ -1,23 +1,15 @@
-import { EngineSettings } from "../../Data/Settings/EngineSettings.js";
+import { EngineSettings } from "../../Settings/EngineSettings.js";
 import { Threads } from "@amodx/threads/";
 import { WorldThreadManager } from "./WorldThreads.js";
-import { DVEConstructorTasksQueues } from "../Constructor/DVEConstructorTasksQueues";
+import { DVEConstructorTasksQueues } from "../Constructor/Tasks/DVEConstructorTasksQueues.js";
 import { WorldTasks } from "./Tasks/WorldTasks";
 import { LocationData } from "../../Math";
 import { DataSync } from "./Data/DataSync.js";
-import { DataRegister } from "./Data/DataRegister.js";
-import { DataStructBuilders } from "./Data/DataStructBuilders.js";
 /**# Divine Voxel Engine World
  * ---
  * This handles everything in the world worker context.
  */
-export type DVEWorldProps = {
-    nexusEnabled?: boolean;
-    richWorldEnabled?: boolean;
-    dataLoaderEnabled?: boolean;
-};
 export declare class DivineVoxelEngineWorld {
-    props: DVEWorldProps;
     static environment: "node" | "browser";
     static instance: DivineVoxelEngineWorld;
     TC: typeof Threads;
@@ -25,10 +17,7 @@ export declare class DivineVoxelEngineWorld {
     threads: WorldThreadManager;
     dataSync: DataSync;
     queues: DVEConstructorTasksQueues;
-    dataRegiser: DataRegister;
-    dataTagBulders: DataStructBuilders;
     tasks: WorldTasks;
-    constructor(props?: DVEWorldProps);
-    init(): Promise<void>;
+    constructor();
     removeColumnsOutsideRadius(origion: LocationData, radius: number): void;
 }

package/Contexts/World/DivineVoxelEngineWorld.js

@@ -1,43 +1,30 @@
 //objects
-import { EngineSettings } from "../../Data/Settings/EngineSettings.js";
-import { Environment } from "@amodx/core/Environment/Environment.js";
+import { EngineSettings } from "../../Settings/EngineSettings.js";
 //functions
-import InitWorldWorker from "./InitWorker.js";
 import { Threads } from "@amodx/threads/";
 import { WorldThreadManager } from "./WorldThreads.js";
-import { DVEConstructorTasksQueues } from "../Constructor/DVEConstructorTasksQueues";
-import InitWorldTasks, { WorldTasks } from "./Tasks/WorldTasks";
+import { DVEConstructorTasksQueues } from "../Constructor/Tasks/DVEConstructorTasksQueues.js";
+import { WorldTasks } from "./Tasks/WorldTasks";
 import { Distance3D } from "@amodx/math";
 import { WorldRegister } from "../../Data/World/WorldRegister";
 import { DataSync } from "./Data/DataSync.js";
-import { DataRegister } from "./Data/DataRegister.js";
-import { DataStructBuilders } from "./Data/DataStructBuilders.js";
+/**# Divine Voxel Engine World
+ * ---
+ * This handles everything in the world worker context.
+ */
 export class DivineVoxelEngineWorld {
-    props;
     static environment = "browser";
     static instance;
     TC = Threads;
     settings = EngineSettings;
-    threads;
-    dataSync;
-    queues;
-    dataRegiser;
-    dataTagBulders;
+    threads = new WorldThreadManager();
+    dataSync = new DataSync();
+    queues = new DVEConstructorTasksQueues(this.threads.constructors);
     tasks = new WorldTasks(this);
-    constructor(props = {}) {
-        this.props = props;
+    constructor() {
         if (DivineVoxelEngineWorld.instance)
             return DivineVoxelEngineWorld.instance;
         DivineVoxelEngineWorld.instance = this;
-        this.threads = new WorldThreadManager(props);
-        this.dataSync = new DataSync();
-        this.queues = new DVEConstructorTasksQueues(this.threads.constructors);
-        this.dataRegiser = new DataRegister();
-        this.dataTagBulders = new DataStructBuilders();
-        InitWorldTasks(this);
-    }
-    async init() {
-        await InitWorldWorker(this);
     }
     removeColumnsOutsideRadius(origion, radius) {
         const [dimesnionId, x, y, z] = origion;
@@ -58,7 +45,3 @@ export class DivineVoxelEngineWorld {
         });
     }
 }
-DivineVoxelEngineWorld.environment = Environment.nodeJS.isNode
-    ? "node"
-    : "browser";
-Threads.threadName = "world";

package/Contexts/World/Lock/WorldLock.d.ts

@@ -1,6 +1,6 @@
-import type { WorldLockTasks } from "../../../Types/Tasks.types";
+import type { WorldLockTasks } from "../../../Tasks/Tasks.types";
 import type { LocationData } from "../../../Math";
-import { DataLoaderTool } from "../../../DataLoader/World/Tools/DataLoaderTool.js";
+import { DataLoaderTool } from "../../../Tasks/DataLoader/World/Tools/DataLoaderTool.js";
 export declare const WorldLock: {
     locks: Map<string, WorldLockTasks>;
     dataLoader: DataLoaderTool;

package/Contexts/World/Tasks/WorldTasks.js

@@ -1,11 +1,11 @@
 import { Threads } from "@amodx/threads/";
 //data
 import { WorldRegister } from "../../../Data/World/WorldRegister.js";
-import { RegionHeaderRegister } from "../../../Data/RegionHeaderRegister.js";
-import { DataLoaderTool } from "../../../DataLoader/World/Tools/DataLoaderTool.js";
+import { RegionHeaderRegister } from "../../../Data/World/RegionHeaderRegister.js";
+import { DataLoaderTool } from "../../../Tasks/DataLoader/World/Tools/DataLoaderTool.js";
 import { WorldSpaces } from "../../../Data/World/WorldSpaces.js";
 import { WorldLock } from "../Lock/WorldLock.js";
-import { DataSync } from "../Data/DataSync.js";
+import { MesherTool } from "../../../Tools/Mesher/MesherTool.js";
 export class WorldTasks {
     DVEW;
     constructor(DVEW) {
@@ -14,7 +14,7 @@ export class WorldTasks {
     loadColumn(location, column) {
         WorldRegister.instance.setDimension(location[0]);
         WorldRegister.instance.column.add(location[1], location[2], location[3], column);
-        DataSync.instance.worldData.column.sync(location);
+        this.DVEW.dataSync.worldData.column.sync(location);
     }
     unLoadColumn(location) {
         if (WorldLock.isLocked(location))
@@ -32,12 +32,13 @@ export class WorldTasks {
     }
     loadRegionHeader(location, data) {
         RegionHeaderRegister.add(location, data);
-        DataSync.instance.worldData.regionHeader.sync(location);
+        this.DVEW.dataSync.worldData.regionHeader.sync(location);
     }
 }
 export default function (DVEW) {
     const dataLoaderTool = new DataLoaderTool();
     const loadInMap = new Map();
+    const mesher = new MesherTool();
     Threads.registerTasks("add-chunk", async (location) => {
         WorldRegister.instance.setDimension(location[0]);
         const chunk = WorldRegister.instance.chunk.get(location[1], location[2], location[3]);
@@ -92,6 +93,11 @@ export default function (DVEW) {
         const resutls = DVEW.tasks.loadColumn(location, column);
         return onDone ? onDone(resutls) : resutls;
     });
+    Threads.registerTasks("build-queue", async ([dim, chunks]) => {
+        for (const position of chunks) {
+            mesher.setLocation([dim, ...position]).buildChunk();
+        }
+    });
     Threads.registerTasks("clear-all", () => {
         WorldRegister.instance.clearAll();
     });

package/Contexts/World/WorldThreads.d.ts

@@ -1,14 +1,8 @@
 import { ThreadPool } from "@amodx/threads/";
-import { WorldThreadState } from "./WorldThreadState.js";
-import { ThreadManager } from "../../Interfaces/Classes/ThreadManager.js";
-import { DVEWorldProps } from "./index.js";
+import { ThreadManager } from "../Base/ThreadManager.js";
 export declare class WorldThreadManager extends ThreadManager {
-    props: DVEWorldProps;
     constructors: ThreadPool;
     parent: import("@amodx/threads/").Thread;
-    state: WorldThreadState;
-    richWorld: import("@amodx/threads/").Thread;
-    dataLoader: import("@amodx/threads/").Thread;
     nexus: import("@amodx/threads/").Thread;
-    constructor(props?: DVEWorldProps);
+    constructor();
 }

package/Contexts/World/WorldThreads.js

@@ -1,34 +1,15 @@
 import { Threads } from "@amodx/threads/";
-import { EngineSettings } from "../../Data/Settings/EngineSettings.js";
-import { ThreadManager } from "../../Interfaces/Classes/ThreadManager.js";
+import { ThreadManager } from "../Base/ThreadManager.js";
 export class WorldThreadManager extends ThreadManager {
-    props;
     constructors = Threads.createThreadPool({
         name: "constructor",
         onPortSet(port, commName) { },
     });
     parent = Threads.parent;
-    state;
-    richWorld = Threads.createThread("rich-world");
-    dataLoader = Threads.createThread("data-loader");
     nexus = Threads.createThread("nexus");
-    constructor(props = {}) {
+    constructor() {
         super();
-        this.props = props;
         this.addThread(this.constructors);
         this.addThread(this.parent);
-        Threads.registerTasks("sync-settings", (settings) => {
-            EngineSettings.syncSettings(settings);
-            this.state.settingsSynced = true;
-        });
-        if (props.nexusEnabled) {
-            this.addThread(this.nexus);
-        }
-        if (props.dataLoaderEnabled) {
-            this.addThread(this.dataLoader);
-        }
-        if (props.richWorldEnabled) {
-            this.addThread(this.richWorld);
-        }
     }
 }

package/Data/Cursor/Interfaces/DataCursor.interface.d.ts

@@ -0,0 +1,5 @@
+import { VoxelCursorInterface } from "./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/Data/Cursor/Interfaces/DataCursor.interface.js

@@ -0,0 +1,2 @@
+export class DataCursorInterface {
+}

package/Data/Cursor/Interfaces/VoxelCursor.interface.d.ts

@@ -0,0 +1,63 @@
+import { VoxelStruct } from "../../Structs/VoxelStruct";
+import { DataTool } from "../../../Tools/Data/DataTool";
+import { RawVoxelData } from "../../../Voxels/Voxel.types";
+interface WritableArrayLike<T> {
+    length: number;
+    [index: number]: T;
+}
+export declare abstract class VoxelCursorInterface {
+    _loadedId: number;
+    id: number;
+    secondaryId: number;
+    __struct: VoxelStruct;
+    __secondary: boolean;
+    _index: number;
+    abstract ids: WritableArrayLike<number>;
+    abstract light: WritableArrayLike<number>;
+    abstract state: WritableArrayLike<number>;
+    abstract secondary: WritableArrayLike<number>;
+    abstract mod: WritableArrayLike<number>;
+    process(): void;
+    abstract loadIn(): void;
+    setSecondary(enable: boolean): this;
+    getRenderedMaterial(): number;
+    getRenderedMaterialStringId(): string;
+    getMaterial(): number;
+    getMaterialStringId(): string;
+    getSubstance(): number;
+    getSubstanceStringId(): string;
+    isOpaque(): boolean;
+    getMod(): number;
+    setMod(mod: number): this;
+    getLevel(): number;
+    setLevel(level: number): this;
+    getLevelState(): number;
+    setLevelState(state: number): this;
+    getShapeState(): number;
+    setShapeState(state: number): this;
+    hasSecondaryVoxel(): boolean;
+    canHaveSecondaryVoxel(): boolean;
+    hasRGBLight(): boolean;
+    hasSunLight(): boolean;
+    getLight(): number;
+    setLight(light: number): this;
+    isLightSource(): boolean;
+    getLightSourceValue(): number;
+    noAO(): boolean;
+    isRenderable(): boolean;
+    isAir(): boolean;
+    setAir(): this;
+    isBarrier(): boolean;
+    getId(): number;
+    setId(id: number): this;
+    setStringId(id: string): this;
+    getStringId(): string;
+    setName(name: string): void;
+    getName(): string;
+    isSameVoxel(voxel: VoxelCursorInterface | DataTool): boolean;
+    copy(cursor: VoxelCursorInterface): this;
+    copyRaw(raw: RawVoxelData): this;
+    getRaw(): RawVoxelData;
+    getRawToRef(raw: RawVoxelData): RawVoxelData;
+}
+export {};

package/Data/Cursor/Interfaces/VoxelCursor.interface.js

@@ -0,0 +1,233 @@
+import { VoxelStructIds } from "../../../Voxels/Voxel.types";
+import { LightData } from "../../../Voxels/LightData";
+import { VoxelStruct } from "../../Structs/VoxelStruct";
+import { VoxelStateReader } from "../../../Voxels/VoxelStateReader";
+import { VoxelTagStates } from "../../../Voxels/State/VoxelTagStates";
+import { VoxelPalette } from "../../Palettes/VoxelPalette";
+import { SubstancePalette } from "../../Palettes/SubstancePalette";
+import { MaterialPalette } from "../../../Data/Palettes/MaterialPalette";
+export class VoxelCursorInterface {
+    _loadedId = 0;
+    id = 0;
+    secondaryId = 0;
+    __struct;
+    __secondary = false;
+    // private _chunk: Chunk;
+    _index = 0;
+    process() {
+        if (!this.__struct)
+            this.__struct = VoxelStruct.clone();
+        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.__struct.setIndex(VoxelStruct.voxelIndex[this.id]);
+        this._loadedId = this.getId();
+    }
+    setSecondary(enable) {
+        this.__secondary = enable;
+        if (enable) {
+            this.__struct.setIndex(VoxelStruct.voxelIndex[this.secondaryId]);
+        }
+        else {
+            this.__struct.setIndex(VoxelStruct.voxelIndex[this.id]);
+        }
+        this._loadedId = this.getId();
+        return this;
+    }
+    getRenderedMaterial() {
+        return this.__struct[VoxelStructIds.renderedMaterial];
+    }
+    getRenderedMaterialStringId() {
+        return MaterialPalette.id.stringFromNumber(this.__struct[VoxelStructIds.renderedMaterial]);
+    }
+    getMaterial() {
+        return this.__struct[VoxelStructIds.voxelMaterial];
+    }
+    getMaterialStringId() {
+        return MaterialPalette.id.stringFromNumber(this.__struct[VoxelStructIds.voxelMaterial]);
+    }
+    getSubstance() {
+        return this.__struct[VoxelStructIds.substance];
+    }
+    getSubstanceStringId() {
+        return SubstancePalette.id.stringFromNumber(this.getSubstance());
+    }
+    isOpaque() {
+        return this.__struct[VoxelStructIds.isTransparent] == 0;
+    }
+    getMod() {
+        return this.mod[this._index];
+    }
+    setMod(mod) {
+        this.mod[this._index] = mod;
+        return this;
+    }
+    getLevel() {
+        return VoxelStateReader.getLevel(this.state[this._index]);
+    }
+    setLevel(level) {
+        this.state[this._index] = VoxelStateReader.setLevel(this.state[this._index], level);
+        return this;
+    }
+    getLevelState() {
+        return VoxelStateReader.getLevelState(this.state[this._index]);
+    }
+    setLevelState(state) {
+        this.state[this._index] = VoxelStateReader.setLevelState(this.state[this._index], state);
+        return this;
+    }
+    getShapeState() {
+        return VoxelStateReader.getShapeState(this.state[this._index]);
+    }
+    setShapeState(state) {
+        this.state[this._index] = VoxelStateReader.setShapeState(this.state[this._index], state);
+        return this;
+    }
+    hasSecondaryVoxel() {
+        return this.secondaryId > 1;
+    }
+    canHaveSecondaryVoxel() {
+        return this.__struct[VoxelStructIds.canHaveSecondary] == 1;
+    }
+    hasRGBLight() {
+        const light = this.getLight();
+        if (light <= 0)
+            false;
+        return LightData.hasRGBLight(light);
+    }
+    hasSunLight() {
+        const light = this.getLight();
+        if (light <= 0)
+            false;
+        return LightData.hasSunLight(light);
+    }
+    getLight() {
+        const vID = this._loadedId;
+        if (vID == 0)
+            return this.light[this._index];
+        if (vID < 2)
+            return -1;
+        const lightValue = this.__struct[VoxelStructIds.lightValue];
+        if (this.isOpaque()) {
+            if (this.isLightSource() && lightValue) {
+                return lightValue;
+            }
+            else {
+                return -1;
+            }
+        }
+        if (this.isLightSource() && lightValue) {
+            return LightData.mixLight(this.light[this._index], lightValue);
+        }
+        return this.light[this._index];
+    }
+    setLight(light) {
+        this.light[this._index] = light;
+        return this;
+    }
+    isLightSource() {
+        const vID = this._loadedId;
+        if (vID < 2)
+            return false;
+        return VoxelTagStates.isRegistered(this._loadedId, VoxelStructIds.isLightSource)
+            ? VoxelTagStates.getValue(this._loadedId, VoxelStructIds.isLightSource, this.getShapeState()) === true
+            : this.__struct[VoxelStructIds.isLightSource] == 1;
+    }
+    getLightSourceValue() {
+        const vID = this._loadedId;
+        if (vID < 2)
+            return 0;
+        return this.__struct[VoxelStructIds.lightValue];
+    }
+    noAO() {
+        const vID = this._loadedId;
+        if (vID < 2)
+            return false;
+        return this.__struct[VoxelStructIds.noAO] == 1;
+    }
+    isRenderable() {
+        if (this.id < 2 && this.secondaryId < 2)
+            return false;
+        return true;
+    }
+    isAir() {
+        return 0 == this.ids[this._index];
+    }
+    setAir() {
+        this.ids[0] = 0;
+        return this;
+    }
+    isBarrier() {
+        return 1 == this.ids[this._index];
+    }
+    getId() {
+        if (this.__secondary) {
+            return this.secondaryId;
+        }
+        return this.id;
+    }
+    setId(id) {
+        if (this.__secondary) {
+            this.secondary[this._index] = id;
+            return this;
+        }
+        this.ids[this._index] = id;
+        return this;
+    }
+    setStringId(id) {
+        return this.setId(VoxelPalette.ids.getNumberId(id));
+    }
+    getStringId() {
+        if (this.__secondary) {
+            return VoxelPalette.ids.getStringId(this.secondaryId);
+        }
+        return VoxelPalette.ids.getStringId(this.id);
+    }
+    setName(name) {
+        this.setStringId(VoxelPalette.name.getId(name));
+    }
+    getName() {
+        return this.getStringId();
+    }
+    isSameVoxel(voxel) {
+        return this.getId() == voxel.getId();
+    }
+    copy(cursor) {
+        this.ids[this._index] = cursor.ids[cursor._index];
+        this.light[this._index] = cursor.light[cursor._index];
+        this.state[this._index] = cursor.state[cursor._index];
+        this.secondary[this._index] = cursor.secondary[cursor._index];
+        this.mod[this._index] = cursor.mod[cursor._index];
+        return this;
+    }
+    copyRaw(raw) {
+        this.ids[this._index] = raw[0];
+        this.light[this._index] = raw[1];
+        this.state[this._index] = raw[2];
+        this.secondary[this._index] = raw[3];
+        this.mod[this._index] = raw[4];
+        return this;
+    }
+    getRaw() {
+        return [
+            this.ids[this._index],
+            this.light[this._index],
+            this.state[this._index],
+            this.secondary[this._index],
+            this.mod[this._index],
+        ];
+    }
+    getRawToRef(raw) {
+        raw[0] = this.ids[this._index];
+        raw[1] = this.light[this._index];
+        raw[2] = this.state[this._index];
+        raw[3] = this.secondary[this._index];
+        raw[4] = this.mod[this._index];
+        return raw;
+    }
+}

package/Data/Cursor/Template/TemplateCursor.d.ts

@@ -0,0 +1,11 @@
+import { TemplateVoxelCursor } from "./TemplateVoxelCursor";
+import { DataCursorInterface } from "../Interfaces/DataCursor.interface";
+import { FullVoxelTemplate } from "Templates/FullVoxelTemplate";
+export declare class TemplateCursor extends DataCursorInterface {
+    _voxelIndex: number;
+    _template: FullVoxelTemplate | null;
+    private voxel;
+    inBounds(x: number, y: number, z: number): boolean;
+    setTemplate(template: FullVoxelTemplate): void;
+    getVoxel(x: number, y: number, z: number): TemplateVoxelCursor | null;
+}

package/Data/Cursor/Template/TemplateCursor.js

@@ -0,0 +1,20 @@
+import { TemplateVoxelCursor } from "./TemplateVoxelCursor";
+import { DataCursorInterface } from "../Interfaces/DataCursor.interface";
+export class TemplateCursor extends DataCursorInterface {
+    _voxelIndex = 0;
+    _template = null;
+    voxel = new TemplateVoxelCursor(this);
+    inBounds(x, y, z) {
+        return true;
+    }
+    setTemplate(template) {
+        this._template = template;
+    }
+    getVoxel(x, y, z) {
+        if (!this._template)
+            return null;
+        this._voxelIndex = this._template.index.getIndexXYZ(x, y, z);
+        this.voxel.loadIn();
+        return this.voxel;
+    }
+}

package/Data/Cursor/Template/TemplateVoxelCursor.d.ts

@@ -0,0 +1,13 @@
+import { VoxelCursorInterface } from "../Interfaces/VoxelCursor.interface";
+import { TemplateCursor } from "./TemplateCursor";
+export declare class TemplateVoxelCursor extends VoxelCursorInterface {
+    dataCursor: TemplateCursor;
+    private _template;
+    get ids(): Uint16Array;
+    get light(): Uint16Array;
+    get state(): Uint16Array;
+    get secondary(): Uint16Array;
+    get mod(): Uint16Array;
+    constructor(dataCursor: TemplateCursor);
+    loadIn(): void;
+}

package/Data/Cursor/Template/TemplateVoxelCursor.js

@@ -0,0 +1,31 @@
+import { VoxelCursorInterface } from "../Interfaces/VoxelCursor.interface";
+export class TemplateVoxelCursor extends VoxelCursorInterface {
+    dataCursor;
+    _template;
+    get ids() {
+        return this._template.ids;
+    }
+    get light() {
+        return this._template.light;
+    }
+    get state() {
+        return this._template.state;
+    }
+    get secondary() {
+        return this._template.secondary;
+    }
+    get mod() {
+        return this._template.mod;
+    }
+    constructor(dataCursor) {
+        super();
+        this.dataCursor = dataCursor;
+    }
+    loadIn() {
+        if (!this.dataCursor._template)
+            return;
+        this._template = this.dataCursor._template;
+        this._index = this.dataCursor._voxelIndex;
+        this.process();
+    }
+}

package/Data/Cursor/VoxelCursor.d.ts

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

package/Data/Cursor/VoxelCursor.js

@@ -0,0 +1,25 @@
+import { VoxelCursorInterface } from "./Interfaces/VoxelCursor.interface";
+import { VoxelPalette } from "../Palettes/VoxelPalette";
+import { VoxelStateReader } from "../../Voxels/VoxelStateReader";
+export class VoxelCursor extends VoxelCursorInterface {
+    static VoxelDataToRaw(data, light = 0) {
+        const id = (data.id !== undefined && VoxelPalette.ids.getNumberId(data.id)) || 0;
+        const secondaryId = (data.secondaryVoxelId !== undefined &&
+            VoxelPalette.ids.getNumberId(data.secondaryVoxelId)) ||
+            0;
+        let stateData = 0;
+        if (data.level !== undefined)
+            stateData = VoxelStateReader.setLevel(stateData, data.level);
+        if (data.levelState !== undefined)
+            stateData = VoxelStateReader.setLevelState(stateData, data.levelState);
+        if (data.shapeState !== undefined)
+            stateData = VoxelStateReader.setShapeState(stateData, data.shapeState);
+        return [id, light, stateData, secondaryId, data.mod || 0];
+    }
+    ids = [0];
+    light = [0];
+    state = [0];
+    secondary = [0];
+    mod = [0];
+    loadIn() { }
+}

package/Data/Cursor/World/ChunkCursor.d.ts

@@ -0,0 +1,16 @@
+import { Chunk } from "../../World/Classes";
+import { WorldVoxelCursor } from "./WorldVoxelCursor";
+import { Vector3Like } from "@amodx/math";
+import { DataCursorInterface } from "../Interfaces/DataCursor.interface";
+import { WorldSectionCursorInterface } from "./WorldSectionCursor.interface";
+export declare class ChunkCursor extends DataCursorInterface implements WorldSectionCursorInterface {
+    _chunk: Chunk | null;
+    private voxel;
+    _voxelIndex: number;
+    _voxelPosition: Vector3Like;
+    _chunkPosition: Vector3Like;
+    inBounds(x: number, y: number, z: number): boolean;
+    setChunk(chunk: Chunk): boolean;
+    setChunk(dimension: string, x: number, y: number, z: number): boolean;
+    getVoxel(x: number, y: number, z: number): WorldVoxelCursor | null;
+}