@divinevoxel/vlox 0.0.4 → 0.0.6

package/Tools/Tasks/TasksTool.js

@@ -1,217 +1,102 @@
-import { Threads } from "@amodx/threads/";
-import { WorldSpaces } from "../../Data/World/WorldSpaces.js";
-import { ConstructorRemoteThreadTasks } from "../../Contexts/Constructor/Tasks/ConstructorRemoteThreadTasks.js";
-import { DVEConstructorTasksQueues } from "../../Contexts/Constructor/Tasks/DVEConstructorTasksQueues.js";
+import { Thread } from "@amodx/threads/";
 import { TasksIds } from "../../Tasks/TasksIds.js";
-export class TaskTool {
-    _data = {
-        dimension: "main",
-        queue: "main",
-    };
-    _thread = "";
-    _priority = 0;
-    constructor() {
-        this._thread = Threads.threadName;
+class TaskQueue {
+    _task;
+    _queue = [];
+    constructor(_task) {
+        this._task = _task;
+    }
+    add(data) {
+        this._queue.push(data);
+    }
+    clear() {
+        this._queue.length = 0;
+    }
+    run() {
+        return new Promise((resolve) => {
+            let waitingFor = 0;
+            const onDone = () => {
+                waitingFor--;
+                if (waitingFor <= 0)
+                    resolve(true);
+            };
+            while (this._queue.length) {
+                const data = this._queue.shift();
+                waitingFor++;
+                this._task.run(data, null, onDone);
+            }
+        });
+    }
+}
+export class TaskToolTask {
+    id;
+    _count = 0;
+    _threads;
+    constructor(id, threads) {
+        this.id = id;
+        if (threads instanceof Thread) {
+            this._threads = [threads];
+        }
+        else {
+            this._threads = [...threads.getThreads()];
+        }
+    }
+    run(data, transfer, onDone) {
+        const thread = this._threads[this._count];
+        thread.runTask(this.id, data, transfer, onDone);
+        this._count++;
+        if (this._count >= this._threads.length)
+            this._count = 0;
     }
-    setPriority(priority) {
-        this._priority = priority;
-        return this;
+    runAsync(data, transfer) {
+        return new Promise((resolve) => {
+            this.run(data, transfer, resolve);
+        });
     }
-    setFocalPoint(location) {
-        const [dimesnion, x, y, z] = location;
-        const queueKey = `${dimesnion}-${WorldSpaces.region.getKeyXYZ(x, y, z)}`;
-        DVEConstructorTasksQueues.instance.addQueue(queueKey);
-        this._data.queue = queueKey;
-        this._thread = Threads.threadName;
-        return this;
+    createQueue() {
+        return new TaskQueue(this);
+    }
+}
+class VoxelTasks {
+    tool;
+    update;
+    paint;
+    erease;
+    constructor(tool) {
+        this.tool = tool;
+        this.update = new TaskToolTask(TasksIds.VoxelUpdate, tool.threads);
+        this.paint = new TaskToolTask(TasksIds.VoxelPaint, tool.threads);
+        this.erease = new TaskToolTask(TasksIds.VoxelErease, tool.threads);
+    }
+}
+class BuildTask {
+    tool;
+    section;
+    sector;
+    constructor(tool) {
+        this.tool = tool;
+        this.section = new TaskToolTask(TasksIds.BuildSection, tool.threads);
+        this.sector = new TaskToolTask(TasksIds.BuildSector, tool.threads);
+    }
+}
+export class TaskTool {
+    threads;
+    voxel;
+    build;
+    explosion;
+    anaylzer;
+    propagation;
+    generate;
+    decorate;
+    worldSun;
+    constructor(threads) {
+        this.threads = threads;
+        this.voxel = new VoxelTasks(this);
+        this.build = new BuildTask(this);
+        this.explosion = new TaskToolTask(TasksIds.Explosion, threads);
+        this.propagation = new TaskToolTask(TasksIds.Propagation, threads);
+        this.generate = new TaskToolTask(TasksIds.Generate, threads);
+        this.decorate = new TaskToolTask(TasksIds.Decorate, threads);
+        this.worldSun = new TaskToolTask(TasksIds.WorldSun, threads);
     }
-    voxelUpdate = {
-        update: {
-            run: (location, raw, onDone, mode = "sync") => {
-                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.VoxelUpdate, [location, raw, this._data.queue, this._thread], [], onDone, mode == "sync" ? 0 : undefined);
-            },
-        },
-        erase: {
-            run: (location, onDone, mode = "sync") => {
-                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.VoxelErease, [location, this._data.queue, this._thread], [], onDone, mode == "sync" ? 0 : undefined);
-            },
-        },
-        paint: {
-            run: (location, raw, onDone, mode = "sync") => {
-                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.VoxelPaint, [location, raw, this._data.queue, this._thread], [], onDone, mode == "sync" ? 0 : undefined);
-            },
-        },
-    };
-    build = {
-        chunk: {
-            deferred: {
-                run: (buildTasks, onDone) => {
-                    DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.BuildChunk, {
-                        data: buildTasks,
-                        priority: this._priority,
-                    }, [], onDone, undefined, 0);
-                },
-            },
-            queued: {
-                add: (location) => {
-                    DVEConstructorTasksQueues.instance.getTasks("build-chunk").add({
-                        data: [location, 1],
-                        priority: this._priority,
-                    }, this._data.queue);
-                },
-                run: (onDone) => {
-                    DVEConstructorTasksQueues.instance
-                        .getTasks("build-chunk")
-                        .run(this._data.queue);
-                    DVEConstructorTasksQueues.instance
-                        .getTasks("build-chunk")
-                        .onDone(this._data.queue, onDone);
-                },
-                runAndAwait: async () => {
-                    await DVEConstructorTasksQueues.instance
-                        .getTasks("build-chunk")
-                        .runAndAwait(this._data.queue);
-                },
-            },
-        },
-        column: {
-            queued: {},
-            deferred: {
-                run: (location, onDone) => {
-                    DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.BuildColumn, [location, 1], [], onDone, undefined, 0);
-                },
-            },
-        },
-    };
-    explosion = {
-        run: (location, radius, onDone) => {
-            DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.Explosion, [location, radius, "", ""], [], onDone, undefined, 0);
-        },
-    };
-    anaylzer = {
-        update: {
-            run: (location, onDone) => {
-                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.AnalyzerUpdate, [location, this._data.queue, this._thread], [], onDone, undefined, 0);
-            },
-        },
-    };
-    propagation = {
-        deferred: {
-            run: (location, onDone) => {
-                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.AnalyzerPropagation, [location, this._data.queue, this._thread], [], onDone, undefined, 0);
-            },
-        },
-        queued: {
-            add: (location) => {
-                DVEConstructorTasksQueues.instance
-                    .getTasks("propagation")
-                    .add([location, this._data.queue, this._thread], this._data.queue);
-            },
-            run: (onDone) => {
-                DVEConstructorTasksQueues.instance
-                    .getTasks("propagation")
-                    .run(this._data.queue);
-                DVEConstructorTasksQueues.instance
-                    .getTasks("propagation")
-                    .onDone(this._data.queue, onDone);
-            },
-            runAndAwait: async () => {
-                await DVEConstructorTasksQueues.instance
-                    .getTasks("propagation")
-                    .runAndAwait(this._data.queue);
-            },
-        },
-    };
-    generate = {
-        deferred: {
-            run(location, data, onDone) {
-                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.Generate, [location, data], [], onDone, undefined, 0);
-            },
-        },
-        queued: {
-            add: (data) => {
-                DVEConstructorTasksQueues.instance
-                    .getTasks("generate")
-                    .add(data, this._data.queue);
-            },
-            run: (onDone) => {
-                DVEConstructorTasksQueues.instance
-                    .getTasks("generate")
-                    .run(this._data.queue);
-                DVEConstructorTasksQueues.instance
-                    .getTasks("generate")
-                    .onDone(this._data.queue, onDone);
-            },
-            runAndAwait: async () => {
-                await DVEConstructorTasksQueues.instance
-                    .getTasks("generate")
-                    .runAndAwait(this._data.queue);
-            },
-        },
-    };
-    decorate = {
-        deferred: {
-            run: (location, data, onDone) => {
-                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.Decorate, [location, data], [], onDone, undefined, 0);
-            },
-        },
-        queued: {
-            add: async (data) => {
-                DVEConstructorTasksQueues.instance
-                    .getTasks("decorate")
-                    .add(data, this._data.queue);
-            },
-            run: (onDone) => {
-                DVEConstructorTasksQueues.instance
-                    .getTasks("decorate")
-                    .run(this._data.queue);
-                DVEConstructorTasksQueues.instance
-                    .getTasks("decorate")
-                    .onDone(this._data.queue, onDone);
-            },
-            runAndAwait: async () => {
-                await DVEConstructorTasksQueues.instance
-                    .getTasks("decorate")
-                    .runAndAwait(this._data.queue);
-            },
-        },
-    };
-    worldSun = {
-        deferred: {
-            run: (location, onDone) => {
-                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.WorldSun, [location, this._thread], [], onDone, undefined, 0);
-            },
-        },
-        queued: {
-            add: (location) => {
-                DVEConstructorTasksQueues.instance
-                    .getTasks("world-sun")
-                    .add([[...location], this._data.queue, this._thread], this._data.queue);
-            },
-            run: (onDone) => {
-                DVEConstructorTasksQueues.instance
-                    .getTasks("world-sun")
-                    .run(this._data.queue);
-                DVEConstructorTasksQueues.instance
-                    .getTasks("world-sun")
-                    .onDone(this._data.queue, onDone);
-            },
-            runAndAwait: async () => {
-                await DVEConstructorTasksQueues.instance
-                    .getTasks("world-sun")
-                    .runAndAwait(this._data.queue);
-            },
-        },
-    };
 }
-DVEConstructorTasksQueues.onCreated.subscribe("TaskTool", () => {
-    DVEConstructorTasksQueues.instance.registerTasks("world-sun", TasksIds.WorldSun);
-    DVEConstructorTasksQueues.instance.registerTasks("decorate", TasksIds.Decorate);
-    DVEConstructorTasksQueues.instance.registerTasks("generate", TasksIds.Generate);
-    DVEConstructorTasksQueues.instance.registerTasks("propagation", TasksIds.AnalyzerPropagation);
-    const tasks = new TaskTool();
-    Threads.registerTasks(ConstructorRemoteThreadTasks.BuildChunk, (data) => {
-        tasks.setPriority(data.priority);
-        tasks.build.chunk.deferred.run(data.data, () => { });
-    });
-});

package/Util/BinaryObject.d.ts

@@ -0,0 +1,2 @@
+export declare function compressBinaryObject(object: any): Promise<ArrayBuffer>;
+export declare function expandBinaryObject<T = any>(buffer: ArrayBuffer | Uint8Array, useSharedMemory?: boolean): Promise<T>;

package/Util/BinaryObject.js

@@ -0,0 +1,14 @@
+import { BinaryObject } from "@amodx/binary";
+export async function compressBinaryObject(object) {
+    const compressedArrayBuffer = await new Response(new Blob([BinaryObject.objectToBuffer(object)])
+        .stream()
+        .pipeThrough(new CompressionStream("gzip"))).arrayBuffer();
+    return compressedArrayBuffer;
+}
+export async function expandBinaryObject(buffer, useSharedMemory = false) {
+    const decompressedBuffer = await new Response(new Blob([buffer]).stream().pipeThrough(new DecompressionStream("gzip"))).arrayBuffer();
+    BinaryObject.setUseSharedMemory(useSharedMemory);
+    const object = BinaryObject.bufferToObject(decompressedBuffer);
+    BinaryObject.setUseSharedMemory(false);
+    return object;
+}

package/Util/Environment.d.ts

@@ -0,0 +1,4 @@
+export declare class Environment {
+    static isNode(): boolean;
+    static isBrowser(): boolean;
+}

package/Util/Environment.js

@@ -0,0 +1,10 @@
+export class Environment {
+    static isNode() {
+        return (typeof process !== "undefined" &&
+            process.versions &&
+            !!process.versions.node);
+    }
+    static isBrowser() {
+        return !this.isNode();
+    }
+}

package/Util/TypedEventTarget.d.ts

@@ -0,0 +1,5 @@
+export declare class TypedEventTarget<T extends Record<string, any>> extends EventTarget {
+    addEventListener<K extends keyof T>(type: K, listener: ((event: CustomEvent<T[K]>) => void) | EventListenerObject | null, options?: AddEventListenerOptions): void;
+    removeEventListener<K extends keyof T>(type: K, listener: ((event: CustomEvent<T[K]>) => void) | EventListenerObject | null): void;
+    dispatch<K extends keyof T>(type: K, detail: T[K]): boolean;
+}

package/Util/TypedEventTarget.js

@@ -0,0 +1,12 @@
+export class TypedEventTarget extends EventTarget {
+    addEventListener(type, listener, options) {
+        super.addEventListener(type, listener, options);
+    }
+    removeEventListener(type, listener) {
+        super.removeEventListener(type, listener);
+    }
+    dispatch(type, detail) {
+        super.dispatchEvent(new CustomEvent(type, { detail }));
+        return true;
+    }
+}

package/Util/Util.types.d.ts

@@ -1,5 +1,3 @@
-import { CompassDirectionNames } from "../Math/Math.types";
-export type DirectionNames = "up" | "down" | Exclude<CompassDirectionNames, "north-west" | "north-east" | "south-west" | "south-east">;
 export type RecursivePartial<T> = {
     [P in keyof T]?: RecursivePartial<T[P]>;
 };

package/{Data → Voxels}/Cursor/VoxelCursor.d.ts

@@ -1,10 +1,10 @@
-import { PaintVoxelData } from "../../Data/Types/WorldData.types";
-import { VoxelCursorInterface } from "./Interfaces/VoxelCursor.interface";
-import { RawVoxelData } from "../../Voxels/Voxel.types";
+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[];

package/{Data/Cursor/Interfaces → Voxels/Cursor}/VoxelCursor.interface.d.ts

@@ -1,6 +1,7 @@
-import { VoxelStruct } from "../../Structs/VoxelStruct";
-import { DataTool } from "../../../Tools/Data/DataTool";
-import { RawVoxelData } from "../../../Voxels/Voxel.types";
+import { VoxelLightData } from "./VoxelLightData";
+import { VoxelStruct } from "../Structs/VoxelStruct";
+import { RawVoxelData } from "../Types/Voxel.types";
+import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool";
 interface WritableArrayLike<T> {
     length: number;
     [index: number]: T;
@@ -14,9 +15,12 @@ export declare abstract class VoxelCursorInterface {
     _index: number;
     abstract ids: WritableArrayLike<number>;
     abstract light: WritableArrayLike<number>;
+    abstract level: WritableArrayLike<number>;
     abstract state: WritableArrayLike<number>;
     abstract secondary: WritableArrayLike<number>;
     abstract mod: WritableArrayLike<number>;
+    _lightData: VoxelLightData;
+    _substanceData: SubstanceDataTool;
     process(): void;
     abstract loadIn(): void;
     setSecondary(enable: boolean): this;
@@ -24,7 +28,11 @@ export declare abstract class VoxelCursorInterface {
     getRenderedMaterialStringId(): string;
     getMaterial(): number;
     getMaterialStringId(): string;
+    checkCollisions(): boolean;
+    getCollider(): number;
+    getColliderStringId(): string | null;
     getSubstance(): number;
+    getSubstanceData(): SubstanceDataTool;
     getSubstanceStringId(): string;
     isOpaque(): boolean;
     getMod(): number;
@@ -33,8 +41,8 @@ export declare abstract class VoxelCursorInterface {
     setLevel(level: number): this;
     getLevelState(): number;
     setLevelState(state: number): this;
-    getShapeState(): number;
-    setShapeState(state: number): this;
+    getState(): number;
+    setState(state: number): this;
     hasSecondaryVoxel(): boolean;
     canHaveSecondaryVoxel(): boolean;
     hasRGBLight(): boolean;
@@ -47,14 +55,13 @@ export declare abstract class VoxelCursorInterface {
     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;
+    isSameVoxel(voxel: VoxelCursorInterface): boolean;
     copy(cursor: VoxelCursorInterface): this;
     copyRaw(raw: RawVoxelData): this;
     getRaw(): RawVoxelData;

package/{Data/Cursor/Interfaces → Voxels/Cursor}/VoxelCursor.interface.js

@@ -1,19 +1,23 @@
-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";
+import { VoxelStructIds } from "../Types/Voxel.types";
+import { VoxelLightData } from "./VoxelLightData";
+import { MappedDataRegister } from "../../Data/Register/MappedDataRegister";
+import { VoxelStruct } from "../Structs/VoxelStruct";
+import { VoxelStateReader } from "../VoxelStateReader";
+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";
 export class VoxelCursorInterface {
     _loadedId = 0;
     id = 0;
     secondaryId = 0;
     __struct;
     __secondary = false;
-    // private _chunk: Chunk;
+    // private _section: Section;
     _index = 0;
+    _lightData = new VoxelLightData();
+    _substanceData = new SubstanceDataTool();
     process() {
         if (!this.__struct)
             this.__struct = VoxelStruct.clone();
@@ -51,9 +55,21 @@ export class VoxelCursorInterface {
     getMaterialStringId() {
         return MaterialPalette.id.stringFromNumber(this.__struct[VoxelStructIds.voxelMaterial]);
     }
+    checkCollisions() {
+        return this.__struct[VoxelStructIds.checkCollisions] == 1;
+    }
+    getCollider() {
+        return this.__struct[VoxelStructIds.colliderID];
+    }
+    getColliderStringId() {
+        return MappedDataRegister.stringMaps.get("voxel", VoxelStructIds.colliderID, this.__struct[VoxelStructIds.colliderID]);
+    }
     getSubstance() {
         return this.__struct[VoxelStructIds.substance];
     }
+    getSubstanceData() {
+        return this._substanceData.setSubstance(this.getSubstance());
+    }
     getSubstanceStringId() {
         return SubstancePalette.id.stringFromNumber(this.getSubstance());
     }
@@ -68,24 +84,24 @@ export class VoxelCursorInterface {
         return this;
     }
     getLevel() {
-        return VoxelStateReader.getLevel(this.state[this._index]);
+        return VoxelStateReader.getLevel(this.level[this._index]);
     }
     setLevel(level) {
-        this.state[this._index] = VoxelStateReader.setLevel(this.state[this._index], level);
+        this.level[this._index] = VoxelStateReader.setLevel(this.level[this._index], level);
         return this;
     }
     getLevelState() {
-        return VoxelStateReader.getLevelState(this.state[this._index]);
+        return VoxelStateReader.getLevelState(this.level[this._index]);
     }
     setLevelState(state) {
-        this.state[this._index] = VoxelStateReader.setLevelState(this.state[this._index], state);
+        this.level[this._index] = VoxelStateReader.setLevelState(this.level[this._index], state);
         return this;
     }
-    getShapeState() {
-        return VoxelStateReader.getShapeState(this.state[this._index]);
+    getState() {
+        return this.state[this._index];
     }
-    setShapeState(state) {
-        this.state[this._index] = VoxelStateReader.setShapeState(this.state[this._index], state);
+    setState(state) {
+        this.state[this._index] = state;
         return this;
     }
     hasSecondaryVoxel() {
@@ -98,20 +114,17 @@ export class VoxelCursorInterface {
         const light = this.getLight();
         if (light <= 0)
             false;
-        return LightData.hasRGBLight(light);
+        return this._lightData.hasRGBLight(light);
     }
     hasSunLight() {
         const light = this.getLight();
         if (light <= 0)
             false;
-        return LightData.hasSunLight(light);
+        return this._lightData.hasSunLight(light);
     }
     getLight() {
-        const vID = this._loadedId;
-        if (vID == 0)
+        if (this._loadedId == 0)
             return this.light[this._index];
-        if (vID < 2)
-            return -1;
         const lightValue = this.__struct[VoxelStructIds.lightValue];
         if (this.isOpaque()) {
             if (this.isLightSource() && lightValue) {
@@ -122,7 +135,7 @@ export class VoxelCursorInterface {
             }
         }
         if (this.isLightSource() && lightValue) {
-            return LightData.mixLight(this.light[this._index], lightValue);
+            return this._lightData.mixLight(this.light[this._index], lightValue);
         }
         return this.light[this._index];
     }
@@ -131,29 +144,28 @@ export class VoxelCursorInterface {
         return this;
     }
     isLightSource() {
-        const vID = this._loadedId;
-        if (vID < 2)
+        if (this._loadedId <= 0)
             return false;
         return VoxelTagStates.isRegistered(this._loadedId, VoxelStructIds.isLightSource)
-            ? VoxelTagStates.getValue(this._loadedId, VoxelStructIds.isLightSource, this.getShapeState()) === true
+            ? VoxelTagStates.getValue(this._loadedId, VoxelStructIds.isLightSource, this.getState()) === true
             : this.__struct[VoxelStructIds.isLightSource] == 1;
     }
     getLightSourceValue() {
-        const vID = this._loadedId;
-        if (vID < 2)
+        if (this._loadedId <= 0)
             return 0;
         return this.__struct[VoxelStructIds.lightValue];
     }
     noAO() {
-        const vID = this._loadedId;
-        if (vID < 2)
+        if (this._loadedId <= 0)
             return false;
         return this.__struct[VoxelStructIds.noAO] == 1;
     }
     isRenderable() {
-        if (this.id < 2 && this.secondaryId < 2)
-            return false;
-        return true;
+        if (this.id > 0)
+            return true;
+        if (this.canHaveSecondaryVoxel() && this.secondary[this._index] > 0)
+            return true;
+        return false;
     }
     isAir() {
         return 0 == this.ids[this._index];
@@ -162,9 +174,6 @@ export class VoxelCursorInterface {
         this.ids[0] = 0;
         return this;
     }
-    isBarrier() {
-        return 1 == this.ids[this._index];
-    }
     getId() {
         if (this.__secondary) {
             return this.secondaryId;
@@ -200,34 +209,38 @@ export class VoxelCursorInterface {
     copy(cursor) {
         this.ids[this._index] = cursor.ids[cursor._index];
         this.light[this._index] = cursor.light[cursor._index];
+        this.level[this._index] = cursor.level[cursor._index];
         this.state[this._index] = cursor.state[cursor._index];
-        this.secondary[this._index] = cursor.secondary[cursor._index];
         this.mod[this._index] = cursor.mod[cursor._index];
+        this.secondary[this._index] = cursor.secondary[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];
+        this.level[this._index] = raw[2];
+        this.state[this._index] = raw[3];
+        this.secondary[this._index] = raw[4];
+        this.mod[this._index] = raw[5];
         return this;
     }
     getRaw() {
         return [
             this.ids[this._index],
             this.light[this._index],
+            this.level[this._index],
             this.state[this._index],
-            this.secondary[this._index],
             this.mod[this._index],
+            this.secondary[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[2] = this.level[this._index];
+        raw[3] = this.state[this._index];
         raw[4] = this.mod[this._index];
+        raw[5] = this.secondary[this._index];
         return raw;
     }
 }