@divinevoxel/vlox 0.0.0

package/Contexts/Constructor/InitWorker.js

@@ -0,0 +1,20 @@
+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/TasksRequest.d.ts

@@ -0,0 +1,141 @@
+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

@@ -0,0 +1,218 @@
+import { ConstructorRemoteThreadTasks } from "../../../Contexts/Constructor/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());
+    },
+};

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

@@ -0,0 +1,4 @@
+import { UpdateTasks, VoxelUpdateTasks } from "Types/Tasks.types";
+export declare function EreaseAndUpdate(data: UpdateTasks): Promise<boolean>;
+export declare function PaintAndUpdate(data: VoxelUpdateTasks): Promise<false | undefined>;
+export declare function VoxelUpdate(data: VoxelUpdateTasks): Promise<false | undefined>;

package/Contexts/Constructor/Tasks/VoxelUpdate.js

@@ -0,0 +1,151 @@
+import { EngineSettings as ES } from "../../../Data/Settings/EngineSettings.js";
+import { $3dCardinalNeighbors } from "../../../Math/Constants/CardinalNeighbors.js";
+import { TasksRequest } from "./TasksRequest.js";
+import { BrushTool } from "../../../Tools/Brush/Brush.js";
+import { DataTool } from "../../../Tools/Data/DataTool.js";
+import { Propagation } from "../../../Propagation/Propagation.js";
+const dataTool = new DataTool();
+const nDataTool = new DataTool();
+const brushTool = new BrushTool();
+const updateLightTask = (tasks) => {
+    let doRGB = ES.doRGBPropagation();
+    let doSun = ES.doSunPropagation();
+    const [dimension, x, y, z] = tasks.origin;
+    nDataTool.setDimension(dimension);
+    for (const n of $3dCardinalNeighbors) {
+        const nx = n[0] + x;
+        const ny = n[1] + y;
+        const nz = n[2] + z;
+        if (!nDataTool.loadInAt(nx, ny, nz))
+            continue;
+        if (doRGB) {
+            if (nDataTool.hasRGBLight()) {
+                tasks.queues.rgb.update.push(nx, ny, nz);
+            }
+        }
+        if (doSun) {
+            if (nDataTool.hasSunLight()) {
+                tasks.queues.sun.update.push(nx, ny, nz);
+            }
+        }
+    }
+};
+export async function EreaseAndUpdate(data) {
+    if (!dataTool.setLocation(data[0]).loadIn())
+        return false;
+    const [dimension, x, y, z] = data[0];
+    const tasks = TasksRequest.getVoxelUpdateRequests(data[0], data[1], data[2]);
+    tasks.setPriority(0).start().setBuldMode("sync").addToRebuildQueue(x, y, z);
+    tasks.setBuldMode("async").addNeighborsToRebuildQueue(x, y, z);
+    if (ES.doFlow() && dataTool.isRenderable()) {
+        if (dataTool.getSubstnaceData().isLiquid()) {
+            await Propagation.instance.flowRemove(tasks);
+            tasks.stop();
+            return true;
+        }
+    }
+    const light = dataTool.getLight();
+    const isLightSource = dataTool.isLightSource();
+    dataTool
+        .setLight(light > 0 ? light : 0)
+        .setAir()
+        .commit(2);
+    if (ES.doLight()) {
+        if (ES.doRGBPropagation() && isLightSource) {
+            tasks.queues.rgb.remove.push(x, y, z);
+            Propagation.instance.rgbRemove(tasks);
+        }
+        updateLightTask(tasks);
+        if (ES.doRGBPropagation()) {
+            Propagation.instance.rgbUpdate(tasks);
+        }
+        if (ES.doSunPropagation()) {
+            Propagation.instance.sunUpdate(tasks);
+        }
+    }
+    tasks.runRebuildQueue();
+    tasks.stop();
+    return true;
+}
+export async function PaintAndUpdate(data) {
+    if (!dataTool.setLocation(data[0]).loadIn())
+        return false;
+    const [dimension, x, y, z] = data[0];
+    const raw = data[1];
+    const tasks = TasksRequest.getVoxelUpdateRequests(data[0], data[2], data[3]);
+    tasks.start().setPriority(0).setBuldMode("sync").addToRebuildQueue(x, y, z);
+    tasks.setBuldMode("async").addNeighborsToRebuildQueue(x, y, z);
+    brushTool.setLocation(data[0]).setRaw(raw);
+    nDataTool.loadInRaw(raw);
+    const isOpaque = nDataTool.isOpaque();
+    let doRGB = ES.doRGBPropagation();
+    let doSun = ES.doSunPropagation();
+    lighttest: if (ES.doLight()) {
+        const light = dataTool.getLight();
+        if (light <= 0)
+            break lighttest;
+        if (doSun) {
+            if (dataTool.hasSunLight()) {
+                tasks.queues.sun.remove.push(x, y, z);
+                Propagation.instance.sunRemove(tasks);
+            }
+        }
+        if (doRGB) {
+            if (dataTool.hasRGBLight() && isOpaque) {
+                tasks.queues.rgb.remove.push(x, y, z);
+                Propagation.instance.rgbRemove(tasks);
+            }
+        }
+    }
+    brushTool.paint();
+    if (ES.doLight()) {
+        updateLightTask(tasks);
+        if (doRGB) {
+            tasks.queues.rgb.update.push(x, y, z);
+            Propagation.instance.rgbUpdate(tasks);
+        }
+        if (doSun) {
+            Propagation.instance.sunUpdate(tasks);
+        }
+    }
+    if (ES.doFlow()) {
+        nDataTool.loadInRaw(raw);
+        const substanceData = nDataTool.getSubstnaceData();
+        if (substanceData.isLiquid()) {
+            Propagation.instance.flowUpdate(tasks);
+        }
+    }
+    tasks.runRebuildQueue();
+    tasks.stop();
+    return;
+}
+export async function VoxelUpdate(data) {
+    if (!dataTool.setLocation(data[0]).loadIn())
+        return false;
+    const [dimension, x, y, z] = data[0];
+    const tasks = TasksRequest.getVoxelUpdateRequests(data[0], data[2], data[3]);
+    tasks.setPriority(0).start().setBuldMode("sync").addToRebuildQueue(x, y, z);
+    tasks.setBuldMode("async").addNeighborsToRebuildQueue(x, y, z);
+    dataTool.loadInRaw(data[1]);
+    dataTool.commit();
+    let doRGB = ES.doRGBPropagation();
+    let doSun = ES.doSunPropagation();
+    if (ES.doLight()) {
+        updateLightTask(tasks);
+        if (doRGB) {
+            tasks.queues.rgb.update.push(x, y, z);
+            Propagation.instance.rgbUpdate(tasks);
+        }
+        if (doSun) {
+            Propagation.instance.sunUpdate(tasks);
+        }
+    }
+    if (ES.doFlow()) {
+        if (dataTool.getSubstnaceData().isLiquid()) {
+            Propagation.instance.flowUpdate(tasks);
+        }
+    }
+    tasks.runRebuildQueue();
+    tasks.stop();
+    return;
+}

package/Contexts/Constructor/index.d.ts

@@ -0,0 +1 @@
+export * from "./DivineVoxelEngineConstructor.js";

package/Contexts/Constructor/index.js

@@ -0,0 +1 @@
+export * from "./DivineVoxelEngineConstructor.js";

package/Contexts/Nexus/DivineVoxelEngineNexus.d.ts

@@ -0,0 +1,19 @@
+import { Threads } from "@amodx/threads/";
+import { DataTool } from "../../Tools/Data/DataTool.js";
+import { DVEDataCore } from "../../Interfaces/Data/DVEDataCore.js";
+import { RichDataTool } from "../../Tools/Data/RichDataTool.js";
+import { NexusThreads } from "./Threads/NexusTheads.js";
+export type DivineVoxelEngineNexusInitData = {
+    data: DVEDataCore;
+};
+export declare class DivineVoxelEngineNexus {
+    static instance: DivineVoxelEngineNexus;
+    environment: "node" | "browser";
+    TC: typeof Threads;
+    data: DVEDataCore;
+    threads: NexusThreads;
+    constructor(data: DivineVoxelEngineNexusInitData);
+    init(): Promise<void>;
+    getRichDataTool(): RichDataTool;
+    getDataTool(): DataTool;
+}

package/Contexts/Nexus/DivineVoxelEngineNexus.js

@@ -0,0 +1,29 @@
+//intercomms
+//functions
+import InitWorker from "./InitWorker.js";
+import { Threads } from "@amodx/threads/";
+import { DataTool } from "../../Tools/Data/DataTool.js";
+import { RichDataTool } from "../../Tools/Data/RichDataTool.js";
+import { NexusThreads } from "./Threads/NexusTheads.js";
+export class DivineVoxelEngineNexus {
+    static instance;
+    environment = "browser";
+    TC = Threads;
+    data;
+    threads = new NexusThreads();
+    constructor(data) {
+        if (DivineVoxelEngineNexus.instance)
+            return DivineVoxelEngineNexus.instance;
+        DivineVoxelEngineNexus.instance = this;
+        this.data = data.data;
+    }
+    async init() {
+        await InitWorker(this);
+    }
+    getRichDataTool() {
+        return new RichDataTool();
+    }
+    getDataTool() {
+        return new DataTool();
+    }
+}

package/Contexts/Nexus/InitWorker.d.ts

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

package/Contexts/Nexus/InitWorker.js

@@ -0,0 +1,15 @@
+import { Threads } from "@amodx/threads/";
+import { CreatePromiseCheck } from "@amodx/core/Intervals/CreatePromiseCheck.js";
+export default async function (DVEN) {
+    let parent = "render";
+    if (DVEN.environment == "node") {
+        parent = "server";
+    }
+    await Threads.init("nexus", parent);
+    await CreatePromiseCheck({
+        check: () => {
+            return DVEN.threads.state.isReady();
+        },
+        checkInterval: 1,
+    });
+}

package/Contexts/Nexus/Threads/NexusTheads.d.ts

@@ -0,0 +1,13 @@
+import { NexusThreadState } from "./NexusThreadState.js";
+import { ThreadManager } from "../../../Interfaces/Classes/ThreadManager.js";
+export declare const parent: import("@amodx/threads/").Thread;
+export declare const Richworld: import("@amodx/threads/").Thread;
+export declare const world: import("@amodx/threads/").Thread;
+export declare class NexusThreads extends ThreadManager {
+    state: NexusThreadState;
+    parent: import("@amodx/threads/").Thread;
+    world: import("@amodx/threads/").Thread;
+    NexusComm: import("@amodx/threads/").Thread;
+    DataComm: import("@amodx/threads/").Thread;
+    ConstructorComm: import("@amodx/threads/").ThreadPool;
+}

package/Contexts/Nexus/Threads/NexusTheads.js

@@ -0,0 +1,25 @@
+import { EngineSettings } from "../../../Data/Settings/EngineSettings.js";
+import { Threads } from "@amodx/threads/";
+import { NexusThreadState } from "./NexusThreadState.js";
+import { DataHooks } from "../../../Data/DataHooks.js";
+import { ThreadManager } from "../../../Interfaces/Classes/ThreadManager.js";
+import { DivineVoxelEngineNexus } from "../DivineVoxelEngineNexus.js";
+export const parent = Threads.parent;
+export const Richworld = Threads.createThread("rich-world");
+export const world = Threads.createThread("world");
+export class NexusThreads extends ThreadManager {
+    state = new NexusThreadState(this);
+    parent = Threads.parent;
+    world = Threads.createThread("world");
+    NexusComm = Threads.createThread("nexus");
+    DataComm = Threads.createThread("data-loader");
+    ConstructorComm = Threads.createThreadPool({
+        name: "constructor",
+        onPortSet() { },
+    });
+}
+Threads.registerTasks("sync-settings", (settings) => {
+    EngineSettings.syncSettings(settings);
+    DivineVoxelEngineNexus.instance.threads.state._settingsSynced = true;
+    DataHooks.settingsSynced.notify(settings);
+});

package/Contexts/Nexus/Threads/NexusThreadState.d.ts

@@ -0,0 +1,7 @@
+import { ThreadState } from "../../../Interfaces/Classes/ThreadState";
+import { NexusThreads } from "./NexusTheads";
+export declare class NexusThreadState extends ThreadState<NexusThreads> {
+    _settingsSynced: boolean;
+    constructor(threads: NexusThreads);
+    isReady(): boolean;
+}

package/Contexts/Nexus/Threads/NexusThreadState.js

@@ -0,0 +1,10 @@
+import { ThreadState } from "../../../Interfaces/Classes/ThreadState";
+export class NexusThreadState extends ThreadState {
+    _settingsSynced = false;
+    constructor(threads) {
+        super(threads);
+    }
+    isReady() {
+        return this.threads.world.isPortSet() && this._settingsSynced;
+    }
+}

package/Contexts/Nexus/index.d.ts

@@ -0,0 +1 @@
+export * from "./DivineVoxelEngineNexus.js";

package/Contexts/Nexus/index.js

@@ -0,0 +1 @@
+export * from "./DivineVoxelEngineNexus.js";