@divinevoxel/vlox 0.0.0

package/Archive/Functions/ImportColumn.js

@@ -0,0 +1,213 @@
+import { VoxelPalette } from "../../Data/Voxel/VoxelPalette";
+import { Chunk, Column, } from "../../Data/World/Classes";
+import { VoxelStruct } from "../../Data/Voxel/VoxelStruct";
+import { VoxelTagIDs } from "../../Data/Constants/VoxelTagIds";
+import { NumberPalette } from "../../Interfaces/Data/NumberPalette";
+import { StringPalette } from "../../Interfaces/Data/StringPalette";
+import { getPaletteArray } from "./Palettes";
+let columnStructInstance;
+let chunkStructInstance;
+const updateChunkBuffers = (column, chunk) => {
+    if ((column.palettes.id.length <= 15 ||
+        (chunk.palettes.id && chunk.palettes.id.length <= 15)) &&
+        ArrayBuffer.isView(chunk.buffers.id)) {
+        chunk.buffers.id = getPaletteArray(Math.min(chunk.palettes.id?.length || Infinity, column.palettes.id?.length || 0), chunk.buffers.id);
+    }
+    if (((chunk.palettes.light && chunk.palettes.light.length <= 15) ||
+        (column.palettes.light && column.palettes.light.length <= 15)) &&
+        ArrayBuffer.isView(chunk.buffers.light)) {
+        chunk.buffers.light = getPaletteArray(Math.min(chunk.palettes.light?.length || Infinity, column.palettes.light?.length || 0), chunk.buffers.light);
+    }
+    if (((chunk.palettes.state && chunk.palettes.state.length <= 15) ||
+        (column.palettes.state && column.palettes.state.length <= 15)) &&
+        ArrayBuffer.isView(chunk.buffers.state)) {
+        chunk.buffers.state = getPaletteArray(Math.min(chunk.palettes.state?.length || Infinity, column.palettes.state?.length || 0), chunk.buffers.state);
+    }
+    if (((chunk.palettes.mod && chunk.palettes.mod.length <= 15) ||
+        (column.palettes.mod && column.palettes.mod.length <= 15)) &&
+        ArrayBuffer.isView(chunk.buffers.mod)) {
+        chunk.buffers.mod = getPaletteArray(Math.min(chunk.palettes.mod?.length || Infinity, column.palettes.mod?.length || 0), chunk.buffers.mod);
+    }
+    if (((chunk.palettes.secondaryState &&
+        chunk.palettes.secondaryState.length <= 15) ||
+        (column.palettes.secondaryState &&
+            column.palettes.secondaryState.length <= 15)) &&
+        ((chunk.palettes.secondaryId && chunk.palettes.secondaryId.length <= 15) ||
+            (column.palettes.secondaryId &&
+                column.palettes.secondaryId.length <= 15)) &&
+        ArrayBuffer.isView(chunk.buffers.secondary)) {
+        chunk.buffers.secondary = getPaletteArray(Math.max(Math.min(chunk.palettes.secondaryId?.length || Infinity, column.palettes.secondaryId?.length || 0), Math.min(chunk.palettes.secondaryState?.length || Infinity, column.palettes.secondaryState?.length || 0)), chunk.buffers.secondary);
+    }
+};
+const getImportedColumnData = (column) => {
+    return {
+        column,
+        idPalette: new StringPalette(column.palettes.id),
+        secondaryId: column.palettes.secondaryId
+            ? new StringPalette(column.palettes.secondaryId)
+            : undefined,
+        lightPalette: column.palettes.light
+            ? new NumberPalette(column.palettes.light)
+            : undefined,
+        statePalette: column.palettes.state
+            ? new NumberPalette(column.palettes.state)
+            : undefined,
+        modPalette: column.palettes.mod
+            ? new NumberPalette(column.palettes.mod)
+            : undefined,
+        secondaryState: column.palettes.secondaryState
+            ? new NumberPalette(column.palettes.secondaryState)
+            : undefined,
+    };
+};
+const getImportedChunkData = (chunk) => {
+    return {
+        chunk,
+        idPalette: chunk.palettes.id
+            ? new NumberPalette(chunk.palettes.id)
+            : undefined,
+        lightPalette: chunk.palettes.light
+            ? new NumberPalette(chunk.palettes.light)
+            : undefined,
+        statePalette: chunk.palettes.state
+            ? new NumberPalette(chunk.palettes.state)
+            : undefined,
+        modPalette: chunk.palettes.mod
+            ? new NumberPalette(chunk.palettes.mod)
+            : undefined,
+        secondaryState: chunk.palettes.secondaryState
+            ? new NumberPalette(chunk.palettes.secondaryState)
+            : undefined,
+        secondaryId: chunk.palettes.secondaryId
+            ? new NumberPalette(chunk.palettes.secondaryId)
+            : undefined,
+    };
+};
+const getId = (value, importedColumn, importedChunk) => {
+    if (importedChunk.chunk.buffers.state instanceof Uint16Array)
+        return value;
+    if (typeof importedChunk.chunk.buffers.id == "number") {
+        return VoxelPalette.ids.getNumberId(importedColumn.column.palettes.id[importedChunk.chunk.buffers.id]);
+    }
+    if (importedChunk.idPalette) {
+        return VoxelPalette.ids.getNumberId(importedColumn.idPalette.getStringId(importedChunk.idPalette.getValue(value)));
+    }
+    return VoxelPalette.ids.getNumberId(importedColumn.idPalette.getStringId(value));
+};
+const getLight = (value, importedColumn, importedChunk) => {
+    if (importedChunk.chunk.buffers.light instanceof Uint16Array)
+        return value;
+    if (typeof importedChunk.chunk.buffers.light == "number") {
+        return value;
+    }
+    if (importedChunk.lightPalette && importedColumn.lightPalette) {
+        return importedColumn.lightPalette.getValue(importedChunk.lightPalette.getValue(value));
+    }
+    if (importedColumn.lightPalette) {
+        return importedColumn.lightPalette.getValue(value);
+    }
+    return value;
+};
+const getState = (value, importedColumn, importedChunk) => {
+    if (importedChunk.chunk.buffers.state instanceof Uint16Array)
+        return value;
+    if (typeof importedChunk.chunk.buffers.state == "number") {
+        return value;
+    }
+    if (importedChunk.statePalette && importedColumn.statePalette) {
+        return importedColumn.statePalette.getValue(importedChunk.statePalette.getValue(value));
+    }
+    if (importedColumn.statePalette) {
+        return importedColumn.statePalette.getValue(value);
+    }
+    return value;
+};
+const getMod = (value, importedColumn, importedChunk) => {
+    if (importedChunk.chunk.buffers.mod instanceof Uint16Array)
+        return value;
+    if (typeof importedChunk.chunk.buffers.mod == "number") {
+        return value;
+    }
+    if (importedChunk.modPalette && importedColumn.modPalette) {
+        return importedColumn.modPalette.getValue(importedChunk.modPalette.getValue(value));
+    }
+    if (importedColumn.modPalette) {
+        return importedColumn.modPalette.getValue(value);
+    }
+    return value;
+};
+const getSecondary = (voxelId, value, importedColumn, importedChunk) => {
+    if (importedChunk.chunk.buffers.state instanceof Uint16Array)
+        return value;
+    VoxelStruct.setVoxel(voxelId);
+    if (VoxelStruct.instance[VoxelTagIDs.canHaveSecondary] == 1) {
+        if (typeof importedChunk.chunk.buffers.secondary == "number") {
+            return VoxelPalette.ids.getNumberId(importedColumn.column.palettes.secondaryId[importedChunk.chunk.buffers.secondary]);
+        }
+        if (importedChunk.secondaryId) {
+            return VoxelPalette.ids.getNumberId(importedColumn.secondaryId.getStringId(importedChunk.secondaryId.getValue(value)));
+        }
+        return VoxelPalette.ids.getNumberId(importedColumn.column.palettes.secondaryId[value]);
+    }
+    if (typeof importedChunk.chunk.buffers.secondary == "number") {
+        return value;
+    }
+    if (importedChunk.secondaryState && importedColumn.secondaryState) {
+        return importedColumn.secondaryState.getValue(importedChunk.secondaryState.getValue(value));
+    }
+    if (importedColumn.secondaryState) {
+        return importedColumn.secondaryState.getId(value);
+    }
+    return value;
+};
+export default function ImportColumn(column, archiveData) {
+    if (!columnStructInstance)
+        columnStructInstance = Column.StateStruct.instantiate();
+    if (!chunkStructInstance)
+        chunkStructInstance = Chunk.StateStruct.instantiate();
+    const newColumn = Column.CreateNew({});
+    if (!archiveData.loadColumnState) {
+        columnStructInstance.setBuffer(newColumn.stateBuffer);
+        columnStructInstance.deserialize(column.columnState);
+    }
+    else {
+        archiveData.loadColumnState(column.columnState, newColumn);
+    }
+    const importedColumn = getImportedColumnData(column);
+    for (let chunkIndex = 0; chunkIndex < column.chunks.length; chunkIndex++) {
+        const chunk = column.chunks[chunkIndex];
+        const importedChunk = getImportedChunkData(chunk);
+        const newChunk = Chunk.CreateNew();
+        const chunkState = {};
+        for (let i = 0; i < column.keys.chunkState.length; i++) {
+            chunkState[column.keys.chunkState[i]] = chunk.state[i];
+        }
+        updateChunkBuffers(column, chunk);
+        if (!archiveData.loadChunkState) {
+            chunkStructInstance.setBuffer(newChunk.stateBuffer);
+            chunkStructInstance.deserialize(chunkState);
+        }
+        else {
+            archiveData.loadChunkState(column.keys.chunkState, chunk.state, newChunk);
+        }
+        for (let i = 0; i < newChunk.ids.length; i++) {
+            newChunk.ids[i] = getId(typeof chunk.buffers.id == "number"
+                ? chunk.buffers.id
+                : chunk.buffers.id[i], importedColumn, importedChunk);
+            newChunk.state[i] = getState(typeof chunk.buffers.state == "number"
+                ? chunk.buffers.state
+                : chunk.buffers.state[i], importedColumn, importedChunk);
+            newChunk.mod[i] = getMod(typeof chunk.buffers.mod == "number"
+                ? chunk.buffers.mod
+                : chunk.buffers.mod[i], importedColumn, importedChunk);
+            newChunk.light[i] = getLight(typeof chunk.buffers.light == "number"
+                ? chunk.buffers.light
+                : chunk.buffers.light[i], importedColumn, importedChunk);
+            newChunk.secondary[i] = getSecondary(newChunk.ids[i], typeof chunk.buffers.secondary == "number"
+                ? chunk.buffers.secondary
+                : chunk.buffers.secondary[i], importedColumn, importedChunk);
+        }
+        newColumn.chunks[chunkIndex] = newChunk;
+    }
+    return newColumn;
+}

package/Archive/Functions/Palettes.d.ts

@@ -0,0 +1,5 @@
+import { BitArray } from "@amodx/binary/Arrays/BitArray";
+import { HalfNibbleArray } from "@amodx/binary/Arrays/HalfNibbleArray";
+import { NibbleArray } from "@amodx/binary/Arrays/NibbleArray";
+export declare const convertToPaletteBuffer: (paletteSize: number, data: Uint16Array, sharedMemory?: boolean) => Uint16Array | Uint8Array;
+export declare const getPaletteArray: (size: number, buffer: ArrayBufferLike) => ArrayBuffer | NibbleArray | HalfNibbleArray | BitArray;

package/Archive/Functions/Palettes.js

@@ -0,0 +1,46 @@
+import { BitArray } from "@amodx/binary/Arrays/BitArray";
+import { HalfNibbleArray } from "@amodx/binary/Arrays/HalfNibbleArray";
+import { NibbleArray } from "@amodx/binary/Arrays/NibbleArray";
+export const convertToPaletteBuffer = (paletteSize, data, sharedMemory = false) => {
+    let buffer = data;
+    if (paletteSize > 15 && paletteSize <= 255) {
+        buffer = Uint8Array.from(data);
+    }
+    else if (paletteSize > 4 && paletteSize <= 15) {
+        buffer = new Uint8Array(data.length / 2);
+        const nibbleArray = new NibbleArray(buffer);
+        for (let i = 0; i < data.length; i++) {
+            nibbleArray[i] = data[i];
+        }
+    }
+    else if (paletteSize > 2 && paletteSize <= 4) {
+        buffer = new Uint8Array(data.length / 4);
+        const halfNibbleArray = new HalfNibbleArray(buffer);
+        for (let i = 0; i < data.length; i++) {
+            halfNibbleArray[i] = data[i];
+        }
+    }
+    else if (paletteSize == 2) {
+        buffer = new Uint8Array(data.length / 8);
+        const bitArray = new BitArray(buffer);
+        for (let i = 0; i < data.length; i++) {
+            bitArray[i] = data[i];
+        }
+    }
+    if (sharedMemory && !(buffer.buffer instanceof SharedArrayBuffer)) {
+        const sharedBuffer = new SharedArrayBuffer(buffer.byteLength);
+        const sharedView = new Uint8Array(sharedBuffer);
+        sharedView.set(buffer);
+        return sharedView;
+    }
+    return buffer;
+};
+export const getPaletteArray = (size, buffer) => {
+    if (size == 2)
+        return new BitArray(buffer);
+    if (size > 2 && size <= 4)
+        return new HalfNibbleArray(buffer);
+    if (size > 4 && size <= 15)
+        return new NibbleArray(buffer);
+    return buffer;
+};

package/Archive/Functions/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ArchiveArea";
+export * from "./ArchiveColumn";
+export * from "./ImportColumn";

package/Archive/Functions/index.js

@@ -0,0 +1,3 @@
+export * from "./ArchiveArea";
+export * from "./ArchiveColumn";
+export * from "./ImportColumn";

package/Archive/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Functions/index";
+export * from "./Archive.types";

package/Archive/index.js

@@ -0,0 +1,2 @@
+export * from "./Functions/index";
+export * from "./Archive.types";

package/Contexts/Constructor/ConstrcutorTheads.d.ts

@@ -0,0 +1,9 @@
+import { ConstructorThreadState } from "./ConstructorThreadState";
+import { ThreadManager } from "Interfaces/Classes/ThreadManager";
+export declare class ConstructorThreadManager extends ThreadManager {
+    static instnace: ConstructorThreadManager;
+    state: ConstructorThreadState;
+    parent: import("@amodx/threads/").Thread;
+    world: import("@amodx/threads/").Thread;
+    constructor();
+}

package/Contexts/Constructor/ConstrcutorTheads.js

@@ -0,0 +1,22 @@
+import { Threads } from "@amodx/threads/";
+import { ConstructorThreadState } from "./ConstructorThreadState";
+import { EngineSettings } from "../../Data/Settings/EngineSettings";
+import { ThreadManager } from "Interfaces/Classes/ThreadManager";
+const world = Threads.createThread("world");
+export class ConstructorThreadManager extends ThreadManager {
+    static instnace;
+    state;
+    parent = Threads.parent;
+    world = world;
+    constructor() {
+        super();
+        this.state = new ConstructorThreadState(this);
+        ConstructorThreadManager.instnace = this;
+        this.addThread(this.world);
+        this.addThread(this.parent);
+        Threads.registerTasks("sync-settings", (settings) => {
+            EngineSettings.syncSettings(settings);
+            this.state.settingsSynced = true;
+        });
+    }
+}

package/Contexts/Constructor/ConstructorRemoteThreadTasks.d.ts

@@ -0,0 +1,7 @@
+export declare enum ConstructorRemoteThreadTasks {
+    SyncShapeMap = -1,
+    AddToRebuildQue = 0,
+    RunRebuildQue = 1,
+    AddToRGBLightUpdateQue = 2,
+    BuildChunk = 3
+}

package/Contexts/Constructor/ConstructorRemoteThreadTasks.js

@@ -0,0 +1,8 @@
+export var ConstructorRemoteThreadTasks;
+(function (ConstructorRemoteThreadTasks) {
+    ConstructorRemoteThreadTasks[ConstructorRemoteThreadTasks["SyncShapeMap"] = -1] = "SyncShapeMap";
+    ConstructorRemoteThreadTasks[ConstructorRemoteThreadTasks["AddToRebuildQue"] = 0] = "AddToRebuildQue";
+    ConstructorRemoteThreadTasks[ConstructorRemoteThreadTasks["RunRebuildQue"] = 1] = "RunRebuildQue";
+    ConstructorRemoteThreadTasks[ConstructorRemoteThreadTasks["AddToRGBLightUpdateQue"] = 2] = "AddToRGBLightUpdateQue";
+    ConstructorRemoteThreadTasks[ConstructorRemoteThreadTasks["BuildChunk"] = 3] = "BuildChunk";
+})(ConstructorRemoteThreadTasks || (ConstructorRemoteThreadTasks = {}));

package/Contexts/Constructor/ConstructorTasks.d.ts

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

package/Contexts/Constructor/ConstructorTasks.js

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

@@ -0,0 +1,21 @@
+export declare enum ConstructorTasksIds {
+    BuildChunk = 0,
+    BuildColumn = 1,
+    Generate = 2,
+    Decorate = 3,
+    RGBlightUpdate = 4,
+    RGBlightRemove = 5,
+    WorldSun = 6,
+    SunLightUpdate = 7,
+    SunLightRemove = 8,
+    AnalyzerPropagation = 9,
+    AnalyzerUpdate = 10,
+    FlowUpdate = 11,
+    FlowRemove = 12,
+    ConstructEntity = 13,
+    ConstructItem = 14,
+    Explosion = 15,
+    VoxelErease = 16,
+    VoxelPaint = 17,
+    VoxelUpdate = 18
+}

package/Contexts/Constructor/ConstructorTasksIds.js

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

@@ -0,0 +1,5 @@
+import { ThreadState } from "../../Interfaces/Classes/ThreadState";
+export declare class ConstructorThreadState extends ThreadState {
+    environment: string;
+    isReady(): boolean;
+}

package/Contexts/Constructor/ConstructorThreadState.js

@@ -0,0 +1,16 @@
+import { Environment } from "@amodx/core/Environment/Environment.js";
+import { ConstructorThreadManager } from "./ConstrcutorTheads";
+import { ThreadState } from "../../Interfaces/Classes/ThreadState";
+export class ConstructorThreadState extends ThreadState {
+    environment = Environment.nodeJS.isNode ? "node" : "brwoser";
+    isReady() {
+        if (this.environment == "node") {
+            return (ConstructorThreadManager.instnace.world.isPortSet() &&
+                this.settingsSynced);
+        }
+        else {
+            return (ConstructorThreadManager.instnace.world.isPortSet() &&
+                this.settingsSynced);
+        }
+    }
+}

package/Contexts/Constructor/DVEConstructorTasksQueues.d.ts

@@ -0,0 +1,27 @@
+import { ThreadPool } from "@amodx/threads";
+import { QueueManager } from "@amodx/threads/Queue/QueueManager";
+import { Observable } from "@amodx/core/Observers/Observable.js";
+export declare class DVEConstructorTasksQueues {
+    constructors: ThreadPool;
+    static instance: DVEConstructorTasksQueues;
+    static onCreated: Observable<DVEConstructorTasksQueues>;
+    constructor(constructors: ThreadPool);
+    _queueMap: Map<string | number, number>;
+    addQueue(queueKey: string | number): boolean;
+    removeQueue(queueKey: string | number): boolean;
+    /**# Filter Queues
+     * ---
+     * Go through each current queue. IF the passed fucntion returns false it will remove that queue.
+     * @param filter
+     */
+    filterQueues(filter: (queueKey: string | number) => boolean): void;
+    /**# Filter Old Queues
+     * ---
+     * Will remove queues older then 10 minutes.
+     * @param maxTime Max time in miliseconds.
+     */
+    filterOldQueues(maxTime?: number): void;
+    registerTasks(id: string, tasksId: number | string): void;
+    getTasks(id: string): QueueManager<any>;
+    _tasks: Map<string, QueueManager<any>>;
+}

package/Contexts/Constructor/DVEConstructorTasksQueues.js

@@ -0,0 +1,73 @@
+//objects
+import { ConstructorTasksIds } from "./ConstructorTasksIds.js";
+import { Observable } from "@amodx/core/Observers/Observable.js";
+export class DVEConstructorTasksQueues {
+    constructors;
+    static instance;
+    static onCreated = new Observable();
+    constructor(constructors) {
+        this.constructors = constructors;
+        if (!DVEConstructorTasksQueues.instance)
+            DVEConstructorTasksQueues.instance = this;
+        this.registerTasks("build-chunk", ConstructorTasksIds.BuildChunk);
+        DVEConstructorTasksQueues.onCreated.notify(this);
+        this.addQueue("main");
+    }
+    _queueMap = new Map();
+    addQueue(queueKey) {
+        if (this._queueMap.has(queueKey)) {
+            this._queueMap.set(queueKey, Date.now());
+            return false;
+        }
+        for (const [key, queue] of this._tasks) {
+            queue.addQueue(queueKey);
+        }
+        this._queueMap.set(queueKey, Date.now());
+        return true;
+    }
+    removeQueue(queueKey) {
+        if (!this._queueMap.has(queueKey))
+            return false;
+        for (const [key, queue] of this._tasks) {
+            queue.removeQueue(queueKey);
+        }
+        this._queueMap.delete(queueKey);
+        return true;
+    }
+    /**# Filter Queues
+     * ---
+     * Go through each current queue. IF the passed fucntion returns false it will remove that queue.
+     * @param filter
+     */
+    filterQueues(filter) {
+        this._queueMap.forEach((v, key) => {
+            if (!filter(key)) {
+                this.removeQueue(key);
+            }
+        });
+    }
+    /**# Filter Old Queues
+     * ---
+     * Will remove queues older then 10 minutes.
+     * @param maxTime Max time in miliseconds.
+     */
+    filterOldQueues(maxTime = 600000) {
+        const t = Date.now();
+        this._queueMap.forEach((v, key) => {
+            if (t - v > maxTime) {
+                this.removeQueue(key);
+            }
+        });
+    }
+    registerTasks(id, tasksId) {
+        const newTasks = this.constructors.addQueue(id, tasksId);
+        this._tasks.set(id, newTasks);
+    }
+    getTasks(id) {
+        const tasks = this._tasks.get(id);
+        if (!tasks)
+            throw new Error(`The queue with the ${id} does not exist`);
+        return tasks;
+    }
+    _tasks = new Map();
+}

package/Contexts/Constructor/DivineVoxelEngineConstructor.d.ts

@@ -0,0 +1,17 @@
+import { Threads } from "@amodx/threads/";
+import { DVEFDataCore } from "../../Data/DVEFDataCore.js";
+import { ConstructorThreadManager } from "./ConstrcutorTheads.js";
+import { DVEMesher, DVEMesherInitData } from "Mesher/Mesher.js";
+export type DivineVoxelEngineConstructorInitData = {
+    mesherData: DVEMesherInitData;
+};
+export declare class DivineVoxelEngineConstructor {
+    static environment: "node" | "browser";
+    static instance: DivineVoxelEngineConstructor;
+    TC: typeof Threads;
+    threads: ConstructorThreadManager;
+    data: DVEFDataCore;
+    mesher: DVEMesher;
+    constructor(data: DivineVoxelEngineConstructorInitData);
+    init(): Promise<void>;
+}

package/Contexts/Constructor/DivineVoxelEngineConstructor.js

@@ -0,0 +1,30 @@
+//threadcomm
+import { Threads } from "@amodx/threads/";
+//functions
+import InitWorker from "./InitWorker.js";
+import { Environment } from "@amodx/core/Environment/Environment.js";
+import { DVEFDataCore } from "../../Data/DVEFDataCore.js";
+import ConstructorTasks from "./ConstructorTasks";
+import { ConstructorThreadManager } from "./ConstrcutorTheads.js";
+import { DVEMesher } from "Mesher/Mesher.js";
+export class DivineVoxelEngineConstructor {
+    static environment = "browser";
+    static instance;
+    TC = Threads;
+    threads = new ConstructorThreadManager();
+    data = new DVEFDataCore();
+    mesher;
+    constructor(data) {
+        if (DivineVoxelEngineConstructor.instance)
+            return DivineVoxelEngineConstructor.instance;
+        DivineVoxelEngineConstructor.instance = this;
+        this.mesher = new DVEMesher(data.mesherData);
+        ConstructorTasks(this);
+    }
+    async init() {
+        await InitWorker(this);
+    }
+}
+DivineVoxelEngineConstructor.environment = Environment.nodeJS.isNode
+    ? "node"
+    : "browser";

package/Contexts/Constructor/InitWorker.d.ts

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