@divinevoxel/vlox 0.0.2 → 0.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@divinevoxel/vlox",
-  "version": "0.0.02",
+  "version": "0.0.03",
   "description": "Vlox a block style voxel engine.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -20,12 +20,15 @@
     "url": "https://github.com/Divine-Star-Software/DivineVoxelEngine/issues"
   },
   "dependencies": {
-    "@amodx/uri": "^0.0.11",
-    "@amodx/meshing": "^0.0.01",
-    "@amodx/math": "^0.0.01",
-    "@amodx/binary": "^0.0.11",
-    "@amodx/threads": "^0.0.01",
-    "@amodx/indexdb": "^0.0.11"
+    "@amodx/meshing": "latest",
+    "@dvegames/vlox": "latest",
+    "@dvegames/vlox-tools": "latest",
+    "@amodx/math": "latest",
+    "@amodx/binary": "latest",
+    "@amodx/threads": "latest",
+    "@amodx/indexdb": "latest",
+    "@amodx/controls": "latest",
+    "@amodx/rng": "latest"
   },
   "publishConfig": {
     "access": "public"

package/Analyzer/Analyzer.d.ts

@@ -1,18 +0,0 @@
-import type { AnaylzerTask } from "../Types/Tasks.types.js";
-import type { LocationData } from "../Math";
-import { DivineVoxelEngineConstructor } from "../Contexts/Constructor/DivineVoxelEngineConstructor.js";
-import { DVEAnaylzer } from "../Interfaces/Anaylzer/DVEAnaylzer.js";
-export declare class Analyzer extends DVEAnaylzer {
-    updater: {
-        _voxels: Map<string, (locaton: LocationData, deltaTime: number, anayzer: Analyzer, DVEC: DivineVoxelEngineConstructor) => void>;
-        registerVoxel(id: string, run: (locaton: LocationData, deltaTime: number, anayzer: Analyzer, DVEC: DivineVoxelEngineConstructor) => void): void;
-        getVoxel(id: string): false | ((locaton: LocationData, deltaTime: number, anayzer: Analyzer, DVEC: DivineVoxelEngineConstructor) => void);
-    };
-    processor: {
-        columnTool: import("../Tools/Data/WorldData/ColumnDataTool.js").ColumnDataTool;
-        goThroughColumn<T>(location: LocationData, run: (x: number, y: number, z: number, column: import("../Tools/Data/WorldData/ColumnDataTool.js").ColumnDataTool) => void): void;
-    };
-    _flowChecks: number[][];
-    runPropagation(data: AnaylzerTask): Promise<void>;
-    runUpdate(data: AnaylzerTask): Promise<void>;
-}

package/Analyzer/Analyzer.js

@@ -1,91 +0,0 @@
-//objects
-import { EngineSettings } from "../Data/Settings/EngineSettings.js";
-import { DivineVoxelEngineConstructor } from "../Contexts/Constructor/DivineVoxelEngineConstructor.js";
-import { AnalyzerProcessor } from "./AnalyzerProcessor.js";
-import { AnalyzerUpdater } from "./AnalyzerUpdater.js";
-import { DVEAnaylzer } from "../Interfaces/Anaylzer/DVEAnaylzer.js";
-import { DataTool } from "../Tools/Data/DataTool.js";
-import { TasksRequest } from "../Contexts/Constructor/Tasks/TasksRequest.js";
-import { Propagation } from "../Propagation/Propagation.js";
-//tools
-const mainDT = new DataTool();
-const secondaryDT = new DataTool();
-export class Analyzer extends DVEAnaylzer {
-    updater = AnalyzerUpdater;
-    processor = AnalyzerProcessor;
-    _flowChecks = [
-        [0, -1, 0],
-        [1, 0, 0],
-        [-1, 0, 0],
-        [0, 0, 1],
-        [0, 0, -1],
-    ];
-    async runPropagation(data) {
-        let t = {};
-        const options = {
-            light: EngineSettings.doLight(),
-            flow: EngineSettings.doFlow(),
-        };
-        mainDT.setDimension(data[0][0]);
-        secondaryDT.setDimension(data[0][0]);
-        const tasks = TasksRequest.getVoxelUpdateRequests(data[0], "none", "self");
-        tasks.start();
-        this.processor.goThroughColumn(data[0], (x, y, z) => {
-            if (!mainDT.loadInAt(x, y, z) || mainDT.isAir())
-                return;
-            if (options.light) {
-                if (mainDT.isLightSource()) {
-                    tasks.queues.rgb.update.push(x, y, z);
-                }
-            }
-            if (options.flow) {
-                t = {
-                    id: mainDT.getStringId(),
-                    sustance: mainDT.getSubstance(),
-                    substanceStringId: mainDT.getSubstanceStringId(),
-                };
-                if (mainDT.getSubstnaceData().isLiquid()) {
-                    let add = false;
-                    for (const check of this._flowChecks) {
-                        if (secondaryDT.loadInAt(x + check[0], y + check[1], z + check[2])) {
-                            if (secondaryDT.isAir()) {
-                                add = true;
-                                break;
-                            }
-                        }
-                    }
-                    if (add) {
-                        tasks.queues.flow.update.queue.push([x, y, z]);
-                    }
-                }
-            }
-        });
-        Propagation.instance.rgbUpdate(tasks);
-        const dimension = data[0][0];
-        for (const flowUpdate of tasks.queues.flow.update.queue) {
-            const [x, y, z] = flowUpdate;
-            if (!mainDT.loadInAt(x, y, z))
-                continue;
-            await Propagation.instance.flowUpdate(TasksRequest.getFlowUpdateRequest([dimension, x, y, z], "none", "self"), false);
-        }
-        tasks.stop();
-    }
-    async runUpdate(data) {
-        if (!this.processor.columnTool.setLocation(data[0]).loadIn())
-            return;
-        const deltaTime = Date.now() - this.processor.columnTool.getLastAnalyzerUpdateTimestamp();
-        const location = [...data[0]];
-        this.processor.goThroughColumn(data[0], (x, y, z) => {
-            if (!mainDT.loadInAt(x, y, z))
-                return;
-            location[1] = x;
-            location[2] = y;
-            location[3] = z;
-            const run = this.updater.getVoxel(mainDT.getStringId());
-            if (!run)
-                return;
-            run(location, deltaTime, this, DivineVoxelEngineConstructor.instance);
-        });
-        this.processor.columnTool.setLastAnalyzerUpdateTimestamp();
-    }
-}

package/Analyzer/AnalyzerProcessor.d.ts

@@ -1,6 +0,0 @@
-import type { LocationData } from "../Math";
-import { ColumnDataTool } from "../Tools/Data/WorldData/ColumnDataTool.js";
-export declare const AnalyzerProcessor: {
-    columnTool: ColumnDataTool;
-    goThroughColumn<T>(location: LocationData, run: (x: number, y: number, z: number, column: ColumnDataTool) => void): void;
-};

package/Analyzer/AnalyzerProcessor.js

@@ -1,39 +0,0 @@
-import { WorldSpaces } from "../Data/World/WorldSpaces.js";
-import { ColumnDataTool } from "../Tools/Data/WorldData/ColumnDataTool.js";
-import { HeightMapTool } from "../Tools/Data/WorldData/HeightMapTool.js";
-import { WorldRegister } from "../Data/World/WorldRegister.js";
-const columnTool = new ColumnDataTool();
-const heightMapTool = new HeightMapTool();
-export const AnalyzerProcessor = {
-    columnTool: columnTool,
-    goThroughColumn(location, run) {
-        if (!columnTool.setLocation(location).loadIn())
-            return;
-        WorldRegister.instance.cache.enable();
-        const column = columnTool.getColumn();
-        let maxX = WorldSpaces.chunk._bounds.x + location[1];
-        let maxZ = WorldSpaces.chunk._bounds.z + location[3];
-        for (let i = 0; i < column.chunks.length; i++) {
-            const chunk = column.chunks[i];
-            if (!chunk)
-                continue;
-            heightMapTool.chunk.setChunk(chunk);
-            const [cx, cy, cz] = [
-                location[1],
-                location[2] + i * WorldSpaces.chunk.getHeight(),
-                location[3],
-            ];
-            let [minY, maxY] = heightMapTool.chunk.getMinMax();
-            minY += cy;
-            maxY += cy + 1;
-            for (let y = minY; y < maxY; y += 1) {
-                for (let z = cz; z < maxZ; z += 1) {
-                    for (let x = cx; x < maxX; x += 1) {
-                        run(x, y, z, columnTool);
-                    }
-                }
-            }
-        }
-        WorldRegister.instance.cache.disable();
-    },
-};

package/Contexts/Constructor/InitWorker.d.ts

@@ -1,2 +0,0 @@
-import { DivineVoxelEngineConstructor } from "./DivineVoxelEngineConstructor.js";
-export default function (DVEC: DivineVoxelEngineConstructor): Promise<void>;

package/Contexts/Constructor/InitWorker.js

@@ -1,20 +0,0 @@
-import { DivineVoxelEngineConstructor } from "./DivineVoxelEngineConstructor.js";
-import { Threads } from "@amodx/threads/";
-import { CreatePromiseCheck } from "@amodx/core/Intervals/CreatePromiseCheck.js";
-export default async function (DVEC) {
-    let parent = "render";
-    if (DivineVoxelEngineConstructor.environment == "node") {
-        parent = "server";
-    }
-    await Threads.init("constructor", parent);
-    DVEC.TC.registerTasks("thread-ready", () => { });
-    DVEC.mesher.init();
-    await CreatePromiseCheck({
-        check: () => {
-            return DVEC.threads.state.isReady();
-        },
-        onReady() { },
-        checkInterval: 1,
-    });
-    DVEC.TC.registerTasks("ready", () => { });
-}

package/Contexts/Constructor/Tasks/ConstructorTasks.d.ts

@@ -1,2 +0,0 @@
-import { DivineVoxelEngineConstructor } from "../DivineVoxelEngineConstructor.js";
-export default function (DVEC: DivineVoxelEngineConstructor): void;

package/Contexts/Constructor/Tasks/ConstructorTasks.js

@@ -1,82 +0,0 @@
-import { ConstructorTasksIds } from "./ConstructorTasksIds.js";
-import { Threads } from "@amodx/threads/";
-import { WorldRegister } from "../../../Data/World/WorldRegister.js";
-import { WorldSpaces } from "../../../Data/World/WorldSpaces.js";
-import { EreaseAndUpdate, PaintAndUpdate, VoxelUpdate, } from "../Tasks/VoxelUpdate.js";
-import { TasksRequest } from "../Tasks/TasksRequest.js";
-import { Propagation } from "../../../Propagation";
-import { Analyzer } from "../../../Analyzer/Analyzer";
-export default function (DVEC) {
-    Threads.registerTasks("clear-all", () => {
-        WorldRegister.instance.clearAll();
-    });
-    const propagation = new Propagation();
-    const analyzer = new Analyzer();
-    Threads.registerTasks(ConstructorTasksIds.VoxelUpdate, async (data, onDone) => {
-        await VoxelUpdate(data);
-        if (onDone)
-            onDone();
-    }, "deferred");
-    Threads.registerTasks(ConstructorTasksIds.VoxelErease, async (data, onDone) => {
-        await EreaseAndUpdate(data);
-        if (onDone)
-            onDone();
-    }, "deferred");
-    Threads.registerTasks(ConstructorTasksIds.VoxelPaint, async (data, onDone) => {
-        await PaintAndUpdate(data);
-        if (onDone)
-            onDone();
-    }, "deferred");
-    Threads.registerTasks(ConstructorTasksIds.Explosion, async (data) => {
-        await propagation.explosion(TasksRequest.getExplosionRequests(data[0], data[1], data[2], data[3]));
-    });
-    Threads.registerTasks(ConstructorTasksIds.WorldSun, (data, onDone) => {
-        propagation.worldSun(TasksRequest.getWorldSunRequests(data[0], data[1]));
-        if (onDone)
-            onDone();
-    }, "deferred");
-    Threads.registerTasks(ConstructorTasksIds.AnalyzerPropagation, async (data, onDone) => {
-        await analyzer.runPropagation(data);
-        if (onDone)
-            onDone();
-    }, "deferred");
-    Threads.registerTasks(ConstructorTasksIds.AnalyzerUpdate, async (data, onDone) => {
-        await analyzer.runUpdate(data);
-        if (onDone)
-            onDone();
-    }, "deferred");
-    Threads.registerTasks(ConstructorTasksIds.BuildChunk, async (buildData, onDone) => {
-        WorldRegister.instance.cache.enable();
-        const location = buildData.data[0];
-        await DVEC.mesher.meshChunk(location, buildData.data[1], 0);
-        if (onDone)
-            onDone();
-        WorldRegister.instance.cache.disable();
-    });
-    Threads.registerTasks(ConstructorTasksIds.BuildColumn, async (data, onDone) => {
-        WorldRegister.instance.setDimension(data[0][0]);
-        const column = WorldRegister.instance.column.get(data[0][1], data[0][2], data[0][2]);
-        if (!column) {
-            console.warn("Tried building a column that does not exists.", data);
-            return false;
-        }
-        if (column.chunks.length == 0)
-            return false;
-        const location = data[0];
-        WorldRegister.instance.cache.enable();
-        for (let i = 0; i < column.chunks.length; i++) {
-            const chunk = column.chunks[i];
-            if (!chunk)
-                continue;
-            DVEC.mesher.meshChunk([
-                location[0],
-                location[1],
-                location[2] + i * WorldSpaces.chunk.getHeight(),
-                location[3],
-            ], 1, 100);
-        }
-        if (onDone)
-            onDone();
-        WorldRegister.instance.cache.disable();
-    }, "deferred");
-}

package/Contexts/Constructor/Tasks/ConstructorTasksIds.js

@@ -1,22 +0,0 @@
-export var ConstructorTasksIds;
-(function (ConstructorTasksIds) {
-    ConstructorTasksIds[ConstructorTasksIds["BuildChunk"] = 0] = "BuildChunk";
-    ConstructorTasksIds[ConstructorTasksIds["BuildColumn"] = 1] = "BuildColumn";
-    ConstructorTasksIds[ConstructorTasksIds["Generate"] = 2] = "Generate";
-    ConstructorTasksIds[ConstructorTasksIds["Decorate"] = 3] = "Decorate";
-    ConstructorTasksIds[ConstructorTasksIds["RGBlightUpdate"] = 4] = "RGBlightUpdate";
-    ConstructorTasksIds[ConstructorTasksIds["RGBlightRemove"] = 5] = "RGBlightRemove";
-    ConstructorTasksIds[ConstructorTasksIds["WorldSun"] = 6] = "WorldSun";
-    ConstructorTasksIds[ConstructorTasksIds["SunLightUpdate"] = 7] = "SunLightUpdate";
-    ConstructorTasksIds[ConstructorTasksIds["SunLightRemove"] = 8] = "SunLightRemove";
-    ConstructorTasksIds[ConstructorTasksIds["AnalyzerPropagation"] = 9] = "AnalyzerPropagation";
-    ConstructorTasksIds[ConstructorTasksIds["AnalyzerUpdate"] = 10] = "AnalyzerUpdate";
-    ConstructorTasksIds[ConstructorTasksIds["FlowUpdate"] = 11] = "FlowUpdate";
-    ConstructorTasksIds[ConstructorTasksIds["FlowRemove"] = 12] = "FlowRemove";
-    ConstructorTasksIds[ConstructorTasksIds["ConstructEntity"] = 13] = "ConstructEntity";
-    ConstructorTasksIds[ConstructorTasksIds["ConstructItem"] = 14] = "ConstructItem";
-    ConstructorTasksIds[ConstructorTasksIds["Explosion"] = 15] = "Explosion";
-    ConstructorTasksIds[ConstructorTasksIds["VoxelErease"] = 16] = "VoxelErease";
-    ConstructorTasksIds[ConstructorTasksIds["VoxelPaint"] = 17] = "VoxelPaint";
-    ConstructorTasksIds[ConstructorTasksIds["VoxelUpdate"] = 18] = "VoxelUpdate";
-})(ConstructorTasksIds || (ConstructorTasksIds = {}));

package/Contexts/Constructor/Tasks/TasksRequest.d.ts

@@ -1,141 +0,0 @@
-import type { LocationData } from "../../../Math";
-import type { AddToRebuildQueue, BuildTasks, Priorities, PriorityTask } from "../../../Types/Tasks.types";
-import { Thread } from "@amodx/threads/";
-import { VisitedMap } from "../../../Util/VisistedMap";
-import { Vec3Array } from "@amodx/math";
-type RebuildModes = "sync" | "async";
-declare class Request<T, Q> {
-    tasksType: string;
-    origin: LocationData;
-    data: T;
-    buildQueue: string;
-    originThread: string;
-    queues: Q;
-    rebuildQueMap: Map<string, boolean>;
-    comm: Thread;
-    priority: Priorities;
-    LOD: number;
-    syncQueue: LocationData[];
-    aSyncQueue: LocationData[];
-    buildMode: RebuildModes;
-    buildTasks: PriorityTask<BuildTasks>;
-    trackedChunks: Map<string, Vec3Array>;
-    keepTrackOfChunks: boolean;
-    rebuildTasks: AddToRebuildQueue;
-    constructor(tasksType: string, origin: LocationData, data: T, buildQueue: string, originThread: string, queues: Q);
-    start(): this;
-    stop(): this;
-    setPriority(priority: Priorities): this;
-    getData(): T;
-    getOriginThread(): LocationData;
-    getBuildQueue(): string;
-    getOrigin(): LocationData;
-    needsRebuild(): boolean;
-    needsToUpdateOriginThread(): boolean;
-    clearBuildQueue(): void;
-    setBuldMode(mode: RebuildModes): this;
-    addToRebuildQueue(x: number, y: number, z: number): boolean;
-    addNeighborsToRebuildQueue(x: number, y: number, z: number): false | this | undefined;
-    runRebuildQueue(): this;
-    clear(): void;
-}
-type ArrayOfVec3Arrays = [x: number, y: number, z: number][];
-type FlowVec3Array = number[][];
-export declare const TasksRequest: {
-    getLightUpdateRequest(origin: LocationData, buildQueue?: string, originThread?: string): Request<any, {
-        rgb: {
-            update: number[];
-            remove: number[];
-            map: VisitedMap;
-        };
-        sun: {
-            update: number[];
-            remove: number[];
-            updateMap: VisitedMap;
-            remvoeMap: VisitedMap;
-        };
-    }>;
-    getFlowUpdateRequest(origin: LocationData, buildQueue?: string, originThread?: string): Request<null, {
-        flow: {
-            update: {
-                queue: FlowVec3Array;
-                map: VisitedMap;
-            };
-            remove: {
-                queue: FlowVec3Array;
-                map: VisitedMap;
-                noRemoveMap: VisitedMap;
-            };
-        };
-        rgb: {
-            update: number[];
-            remove: number[];
-            map: VisitedMap;
-        };
-        sun: {
-            update: number[];
-            remove: number[];
-            updateMap: VisitedMap;
-            remvoeMap: VisitedMap;
-        };
-    }>;
-    getVoxelUpdateRequests(origin: LocationData, buildQueue?: string, originThread?: string): Request<null, {
-        flow: {
-            update: {
-                queue: FlowVec3Array;
-                map: VisitedMap;
-            };
-            remove: {
-                queue: FlowVec3Array;
-                map: VisitedMap;
-                noRemoveMap: VisitedMap;
-            };
-        };
-        rgb: {
-            update: number[];
-            remove: number[];
-            map: VisitedMap;
-        };
-        sun: {
-            update: number[];
-            remove: number[];
-            updateMap: VisitedMap;
-            remvoeMap: VisitedMap;
-        };
-    }>;
-    getWorldSunRequests(origin: LocationData, buildQueue?: string, originThread?: string): Request<null, {
-        sun: number[];
-    }>;
-    getExplosionRequests(origin: LocationData, radius: number, buildQueue?: string, originThread?: string): Request<number, {
-        flow: {
-            update: {
-                queue: FlowVec3Array;
-                map: VisitedMap;
-            };
-            remove: {
-                queue: FlowVec3Array;
-                map: VisitedMap;
-                noRemoveMap: VisitedMap;
-            };
-        };
-        rgb: {
-            update: number[];
-            remove: number[];
-            map: VisitedMap;
-        };
-        sun: {
-            update: number[];
-            remove: number[];
-            updateMap: VisitedMap;
-            remvoeMap: VisitedMap;
-        };
-        queue: ArrayOfVec3Arrays;
-        map: VisitedMap;
-    }>;
-};
-export type ExplosionTaskRequests = ReturnType<typeof TasksRequest.getExplosionRequests>;
-export type VoxelUpdateTaskRequest = ReturnType<typeof TasksRequest.getVoxelUpdateRequests>;
-export type FlowTaskRequests = ReturnType<typeof TasksRequest.getFlowUpdateRequest>;
-export type LightTaskRequest = ReturnType<typeof TasksRequest.getLightUpdateRequest>;
-export type WorldSunTaskRequest = ReturnType<typeof TasksRequest.getWorldSunRequests>;
-export {};

package/Contexts/Constructor/Tasks/TasksRequest.js

@@ -1,218 +0,0 @@
-import { ConstructorRemoteThreadTasks } from "./ConstructorRemoteThreadTasks";
-import { EngineSettings } from "../../../Data/Settings/EngineSettings.js";
-import { Threads } from "@amodx/threads/";
-import { $3dMooreNeighborhood } from "../../../Math/Constants/CardinalNeighbors.js";
-import { WorldSpaces } from "../../../Data/World/WorldSpaces";
-import { WorldRegister } from "../../../Data/World/WorldRegister.js";
-import { ChunkDataTool } from "../../../Tools/Data/WorldData/ChunkDataTool";
-import { VisitedMap } from "../../../Util/VisistedMap";
-import { DivineVoxelEngineConstructor } from "../../../Contexts/Constructor/DivineVoxelEngineConstructor";
-const chunkTool = new ChunkDataTool();
-class Request {
-    tasksType;
-    origin;
-    data;
-    buildQueue;
-    originThread;
-    queues;
-    rebuildQueMap = new Map();
-    comm;
-    priority = 2;
-    LOD = 0;
-    syncQueue = [];
-    aSyncQueue = [];
-    buildMode = "sync";
-    buildTasks = {
-        data: [["main", 0, 0, 0], 1],
-        priority: 0,
-    };
-    trackedChunks = new Map();
-    keepTrackOfChunks = false;
-    rebuildTasks;
-    constructor(tasksType, origin, data, buildQueue = "none", originThread = "self", queues) {
-        this.tasksType = tasksType;
-        this.origin = origin;
-        this.data = data;
-        this.buildQueue = buildQueue;
-        this.originThread = originThread;
-        this.queues = queues;
-        if (originThread != "self") {
-            this.comm = Threads.getThread(originThread);
-        }
-        this.rebuildTasks = [this.origin, this.buildQueue, this.priority];
-        return this;
-    }
-    start() {
-        WorldRegister.instance.cache.enable();
-        return this;
-    }
-    stop() {
-        WorldRegister.instance.cache.disable();
-        return this;
-    }
-    setPriority(priority) {
-        this.priority = priority;
-        return this;
-    }
-    getData() {
-        return this.data;
-    }
-    getOriginThread() {
-        return this.origin;
-    }
-    getBuildQueue() {
-        return this.buildQueue;
-    }
-    getOrigin() {
-        return this.origin;
-    }
-    needsRebuild() {
-        return this.buildQueue != "none";
-    }
-    needsToUpdateOriginThread() {
-        return this.originThread != "self";
-    }
-    clearBuildQueue() {
-        this.trackedChunks.clear();
-        this.rebuildQueMap.clear();
-        this.aSyncQueue = [];
-        this.syncQueue = [];
-    }
-    setBuldMode(mode) {
-        this.buildMode = mode;
-        return this;
-    }
-    addToRebuildQueue(x, y, z) {
-        if (EngineSettings.isServer())
-            return false;
-        if (!this.needsRebuild() && !this.keepTrackOfChunks)
-            return false;
-        if (!chunkTool.setDimension(this.origin[0]).loadInAt(x, y, z))
-            return false;
-        const chunkKey = WorldSpaces.chunk.getKeyXYZ(x, y, z);
-        if (this.rebuildQueMap.has(chunkKey))
-            return false;
-        this.rebuildQueMap.set(chunkKey, true);
-        const chunkPOS = WorldSpaces.chunk.getPosition();
-        if (this.keepTrackOfChunks) {
-            !this.trackedChunks.has(chunkKey) &&
-                this.trackedChunks.set(chunkKey, [chunkPOS.x, chunkPOS.y, chunkPOS.z]);
-        }
-        if (this.needsRebuild()) {
-            if (this.buildMode == "async") {
-                this.aSyncQueue.push([
-                    this.origin[0],
-                    chunkPOS.x,
-                    chunkPOS.y,
-                    chunkPOS.z,
-                ]);
-                return true;
-            }
-            this.syncQueue.push([this.origin[0], chunkPOS.x, chunkPOS.y, chunkPOS.z]);
-            return true;
-        }
-        return false;
-    }
-    addNeighborsToRebuildQueue(x, y, z) {
-        if (!this.needsRebuild() && !this.keepTrackOfChunks)
-            return false;
-        const voxelPOS = WorldSpaces.voxel.getPositionXYZ(x, y, z);
-        if (voxelPOS.x == 0 ||
-            voxelPOS.x == WorldSpaces.chunk._bounds.x - 1 ||
-            voxelPOS.y == 0 ||
-            voxelPOS.y == WorldSpaces.chunk._bounds.y - 1 ||
-            voxelPOS.z == 0 ||
-            voxelPOS.z == WorldSpaces.chunk._bounds.z - 1) {
-            let i = $3dMooreNeighborhood.length;
-            while (i--) {
-                this.addToRebuildQueue(x + $3dMooreNeighborhood[i][0], y + $3dMooreNeighborhood[i][1], z + $3dMooreNeighborhood[i][2]);
-            }
-            return;
-        }
-        this.addToRebuildQueue(x, y, z);
-        return this;
-    }
-    runRebuildQueue() {
-        while (this.aSyncQueue.length !== 0) {
-            const node = this.aSyncQueue.shift();
-            this.buildTasks.priority = this.priority;
-            if (!node)
-                break;
-            this.buildTasks.data[0] = node;
-            this.comm.runTasks(ConstructorRemoteThreadTasks.BuildChunk, this.buildTasks);
-        }
-        while (this.syncQueue.length !== 0) {
-            const node = this.syncQueue.shift();
-            if (!node)
-                break;
-            DivineVoxelEngineConstructor.instance.mesher.meshChunk(node, 1, 0);
-        }
-        this.rebuildQueMap.clear();
-        return this;
-    }
-    clear() {
-        this.buildTasks.priority = 0;
-        this.syncQueue = [];
-        this.aSyncQueue = [];
-        this.rebuildQueMap.clear();
-        this.buildMode = "sync";
-    }
-}
-const getLightQueues = () => {
-    return {
-        rgb: {
-            update: [],
-            remove: [],
-            map: new VisitedMap(),
-        },
-        sun: {
-            update: [],
-            remove: [],
-            updateMap: new VisitedMap(),
-            remvoeMap: new VisitedMap(),
-        },
-    };
-};
-const getFlowQueues = () => {
-    return {
-        update: {
-            queue: [],
-            map: new VisitedMap(),
-        },
-        remove: {
-            queue: [],
-            map: new VisitedMap(),
-            noRemoveMap: new VisitedMap(),
-        },
-    };
-};
-const getVoxelUpdateQueueData = () => {
-    return { ...getLightQueues(), flow: getFlowQueues() };
-};
-const getExplosionQueuesData = () => {
-    return {
-        queue: [],
-        map: new VisitedMap(),
-        ...getLightQueues(),
-        flow: getFlowQueues(),
-    };
-};
-export const TasksRequest = {
-    getLightUpdateRequest(origin, buildQueue = "none", originThread = "self") {
-        return new Request("light-update", origin, null, buildQueue, originThread, getLightQueues());
-    },
-    getFlowUpdateRequest(origin, buildQueue = "none", originThread = "self") {
-        return new Request("flow-update", origin, null, buildQueue, originThread, getVoxelUpdateQueueData());
-    },
-    getVoxelUpdateRequests(origin, buildQueue = "none", originThread = "self") {
-        return new Request("voxel-update", origin, null, buildQueue, originThread, getVoxelUpdateQueueData());
-    },
-    getWorldSunRequests(origin, buildQueue = "none", originThread = "self") {
-        return new Request("world-sun", origin, null, buildQueue, originThread, {
-            sun: [],
-        });
-    },
-    getExplosionRequests(origin, radius, buildQueue = "none", originThread = "self") {
-        return new Request("voxel-update", origin, radius, buildQueue, originThread, getExplosionQueuesData());
-    },
-};