@divinevoxel/vlox 0.0.0

package/Contexts/Render/DVERenderThreads.d.ts

@@ -0,0 +1,11 @@
+import { ThreadManager } from "../../Interfaces/Classes/ThreadManager";
+export declare class DVERenderThreads extends ThreadManager {
+    nexus: import("@amodx/threads").Thread;
+    richWorld: import("@amodx/threads").Thread;
+    dataLoader: import("@amodx/threads").Thread;
+    state: any;
+    construcotrs: import("@amodx/threads").ThreadPool;
+    parent: import("@amodx/threads").Thread;
+    world: import("@amodx/threads").Thread;
+    constructor();
+}

package/Contexts/Render/DVERenderThreads.js

@@ -0,0 +1,47 @@
+import { Threads } from "@amodx/threads";
+import { ThreadManager } from "../../Interfaces/Classes/ThreadManager";
+export class DVERenderThreads extends ThreadManager {
+    nexus = Threads.createThread("nexus");
+    richWorld = Threads.createThread("rich-world");
+    dataLoader = Threads.createThread("data-loader");
+    state = {};
+    construcotrs = Threads.createThreadPool({
+        name: "constructor",
+        onPortSet(port, commName) { },
+    });
+    parent = Threads.parent;
+    world = Threads.createThread("world");
+    constructor() {
+        super();
+        this.addThread(this.construcotrs);
+        this.addThread(this.parent);
+        this.addThread(this.world);
+        this.pipelines.setPorts.regiser("render", (threads) => {
+            for (const comm of this.construcotrs.getThreads()) {
+                this.world.connectToThread(comm);
+            }
+            return threads;
+        });
+        this.nexus.onSetPort(() => {
+            this.addThread(this.nexus);
+            this.pipelines.setPorts.regiser("nexus", (data) => {
+                this.world.connectToThread(this.nexus);
+                return data;
+            });
+        });
+        this.dataLoader.onSetPort(() => {
+            this.addThread(this.dataLoader);
+            this.pipelines.setPorts.regiser("dataloader", (data) => {
+                this.world.connectToThread(this.dataLoader);
+                return data;
+            });
+        });
+        this.richWorld.onSetPort(() => {
+            this.addThread(this.richWorld);
+            this.pipelines.setPorts.regiser("richworld", (data) => {
+                this.world.connectToThread(this.richWorld);
+                return data;
+            });
+        });
+    }
+}

package/Contexts/Render/DivineVoxelEngineRender.d.ts

@@ -0,0 +1,70 @@
+import { EngineSettings } from "../../Data/Settings/EngineSettings.js";
+import { Threads } from "@amodx/threads/";
+import type { EngineSettingsData } from "../../Types/EngineSettings.types.js";
+import type { RecursivePartial } from "../../Types/Util.types";
+import { DVERenderer } from "../../Interfaces/Render/DVERenderer.js";
+import { MeshManager } from "./Scene/MeshManager.js";
+import { DVEFDataCore } from "../../Data/DVEFDataCore";
+import { DVERenderThreads } from "./DVERenderThreads.js";
+type PartialEngineSettings = RecursivePartial<EngineSettingsData>;
+export interface DVERInitData extends PartialEngineSettings {
+    worldWorker: Worker;
+    constructorWorkers: Worker[];
+    renderer: DVERenderer;
+    nexusWorker?: Worker;
+    richWorldWorker?: Worker;
+}
+export declare class DivineVoxelEngineRender {
+    static instance: DivineVoxelEngineRender;
+    static initialized: boolean;
+    TC: typeof Threads;
+    settings: typeof EngineSettings;
+    meshManager: typeof MeshManager;
+    meshRegister: {
+        _dimensions: import("./Scene/MeshRegister.types.js").MeshRegisterDimensions;
+        $INIT(): void;
+        clearAll(): void;
+        dimensions: {
+            add(id: string): Map<any, any>;
+            get(id: string): Map<string, import("./Scene/MeshRegister.types.js").MushRegisterRegion> | undefined;
+            getAllMeshes(id: string): Generator<[location: import("../../Math/index.js").LocationData, substance: string, mesh: import("@amodx/uri/Meshes/URIMesh.js").URIMesh]>;
+            remove(id: string): boolean;
+        };
+        region: {
+            add(location: import("../../Math/index.js").LocationData): import("./Scene/MeshRegister.types.js").MushRegisterRegion;
+            remove(location: import("../../Math/index.js").LocationData): boolean;
+            _getRegionData(): import("./Scene/MeshRegister.types.js").MushRegisterRegion;
+            get(location: import("../../Math/index.js").LocationData): false | import("./Scene/MeshRegister.types.js").MushRegisterRegion;
+        };
+        column: {
+            add(location: import("../../Math/index.js").LocationData): import("./Scene/MeshRegister.types.js").MeshRegisterColumn;
+            remove(location: import("../../Math/index.js").LocationData): false | import("./Scene/MeshRegister.types.js").MeshRegisterColumn;
+            _getColumnData(location: import("../../Math/index.js").LocationData): import("./Scene/MeshRegister.types.js").MeshRegisterColumn;
+            get(location: import("../../Math/index.js").LocationData): false | import("./Scene/MeshRegister.types.js").MeshRegisterColumn | undefined;
+        };
+        chunk: {
+            add(location: import("../../Math/index.js").LocationData, mesh: import("@amodx/uri/Meshes/URIMesh.js").URIMesh, substance: string): Map<string, import("./Scene/MeshRegister.types.js").MeshRegisterChunk>;
+            _getChunkData(mesh: import("@amodx/uri/Meshes/URIMesh.js").URIMesh): import("./Scene/MeshRegister.types.js").MeshRegisterChunk;
+            remove(location: import("../../Math/index.js").LocationData, substance: string): false | import("@amodx/uri/Meshes/URIMesh.js").URIMesh<import("@amodx/uri/Scenes/URIScene.js").URIScene<unknown>, unknown>;
+            get(location: import("../../Math/index.js").LocationData, substance: string): false | import("./Scene/MeshRegister.types.js").MeshRegisterChunk;
+        };
+    };
+    renderer: DVERenderer;
+    tasks: {
+        setChunk: void;
+        removeChunk: void;
+        removeColumn: void;
+        clearAll: void;
+        removeColumnsOutsideRadius: void;
+    };
+    threads: DVERenderThreads;
+    data: DVEFDataCore;
+    constructor();
+    init(props: DVERInitData): Promise<void>;
+    /**# clearAll
+     *---
+     * Clear all world data and meshes.
+     */
+    clearAll(): Promise<void>;
+}
+export {};

package/Contexts/Render/DivineVoxelEngineRender.js

@@ -0,0 +1,54 @@
+//objects
+import { EngineSettings } from "../../Data/Settings/EngineSettings.js";
+import { RenderTasks } from "./Tasks/RenderTasks.js";
+import { Threads } from "@amodx/threads/";
+//functions
+import InitThreads from "./InitThreads.js";
+import { MeshManager } from "./Scene/MeshManager.js";
+import { MeshRegister } from "./Scene/MeshRegister.js";
+import { DVEFDataCore } from "../../Data/DVEFDataCore";
+import { DVERenderThreads } from "./DVERenderThreads.js";
+export class DivineVoxelEngineRender {
+    static instance;
+    static initialized = false;
+    TC = Threads;
+    settings = EngineSettings;
+    meshManager = MeshManager;
+    meshRegister = MeshRegister;
+    renderer;
+    tasks = RenderTasks;
+    threads = new DVERenderThreads();
+    data = new DVEFDataCore();
+    constructor() {
+        if (DivineVoxelEngineRender.instance)
+            return DivineVoxelEngineRender.instance;
+        DivineVoxelEngineRender.instance = this;
+    }
+    async init(props) {
+        if (DivineVoxelEngineRender.initialized)
+            return;
+        DivineVoxelEngineRender.initialized = true;
+        this.renderer = props.renderer;
+        if (props.nexusWorker) {
+            this.threads.nexus.setPort(props.nexusWorker);
+            this.threads.addThread(this.threads.nexus);
+        }
+        if (props.richWorldWorker) {
+            this.threads.richWorld.setPort(props.richWorldWorker);
+            this.threads.addThread(this.threads.richWorld);
+        }
+        await InitThreads(this, props);
+        await this.renderer.init(this);
+    }
+    /**# clearAll
+     *---
+     * Clear all world data and meshes.
+     */
+    async clearAll() {
+        this.meshRegister.clearAll();
+        await this.threads.world.runAsyncTasks("clear-all", "", []);
+        await Promise.all(this.threads.construcotrs
+            .getThreads()
+            .map((_) => _.runAsyncTasks("clear-all", "")));
+    }
+}

package/Contexts/Render/InitThreads.d.ts

@@ -0,0 +1,2 @@
+import type { DivineVoxelEngineRender, DVERInitData } from "./DivineVoxelEngineRender.js";
+export default function (DVER: DivineVoxelEngineRender, initData: DVERInitData): Promise<void>;

package/Contexts/Render/InitThreads.js

@@ -0,0 +1,53 @@
+import { EngineSettings } from "../../Data/Settings/EngineSettings.js";
+import { Thread, ThreadPool } from "@amodx/threads/";
+export default async function (DVER, initData) {
+    DVER.settings.syncSettings(initData);
+    await DVER.TC.init("render", "global");
+    if (!(initData.worldWorker instanceof Worker)) {
+        throw Error("Supplied data for World Worker is not correct. Must be path to worker or a worker.");
+    }
+    DVER.threads.setThreadPort(DVER.threads.world.name, initData.worldWorker);
+    if (Array.isArray(initData.constructorWorkers) &&
+        initData.constructorWorkers[0] instanceof Worker) {
+        DVER.threads.setThreadPort(DVER.threads.construcotrs.name, initData.constructorWorkers);
+    }
+    else {
+        throw Error("Supplied data for the Constructor Workers is not correct. Must be path to worker or an array workers.");
+    }
+    for (const thread of DVER.threads.construcotrs.getThreads()) {
+        await thread.waitTillTasksExist("thread-ready");
+    }
+    await DVER.threads.pipelines.setPorts.pipe(DVER.threads);
+    for (const thread of DVER.threads.comms) {
+        if (thread instanceof ThreadPool) {
+            for (const com of thread.getThreads()) {
+                await com.waitTillTasksExist("sync-settings");
+                com.runTasks("sync-settings", EngineSettings.getSettingsCopy());
+            }
+        }
+        if (thread instanceof Thread) {
+            if (thread == DVER.threads.parent)
+                continue;
+            await thread.waitTillTasksExist("sync-settings");
+            thread.runTasks("sync-settings", EngineSettings.getSettingsCopy());
+        }
+    }
+    const proms = [];
+    for (const com of DVER.threads.construcotrs.getThreads()) {
+        proms.push(com.waitTillTasksExist("ready"));
+    }
+    await Promise.all(proms);
+    await DVER.threads.world.waitTillTasksExist("sync-all-data");
+    DVER.threads.world.runTasks("sync-all-data", true);
+    await DVER.threads.pipelines.init.pipe(DVER.threads);
+    window.addEventListener("beforeunload", () => {
+        for (const thread of DVER.threads.comms) {
+            if (thread instanceof ThreadPool) {
+                thread.destroyAll();
+            }
+            if (thread instanceof Thread) {
+                thread.destroy();
+            }
+        }
+    });
+}

package/Contexts/Render/Scene/MeshManager.d.ts

@@ -0,0 +1,15 @@
+import { RemoveChunkMeshTasks, SetChunkMeshTask } from "../Tasks/RenderTasks.types.js";
+import { LocationData } from "../../../Math/index.js";
+import { DVENodeMeshAttributes } from "../../../Interfaces/Render/Nodes/DVERenderNode.types.js";
+export declare class MeshManager {
+    static runningUpdate: boolean;
+    private static columnSquare;
+    private static renderCircle;
+    static removeColumnsOutsideRadius(origion: LocationData, radius: number): void;
+    static chunks: {
+        remove(data: RemoveChunkMeshTasks): false | undefined;
+        add(location: LocationData, substance: string, meshData: DVENodeMeshAttributes): void;
+        update(data: SetChunkMeshTask): void;
+        removeColumn(data: LocationData): false | undefined;
+    };
+}

package/Contexts/Render/Scene/MeshManager.js

@@ -0,0 +1,105 @@
+import { MeshRegister } from "./MeshRegister.js";
+import { DivineVoxelEngineRender } from "../../Render/DivineVoxelEngineRender.js";
+import { Square, Circle } from "@amodx/math/Shapes";
+import { Vector2Like } from "@amodx/math";
+import { WorldSpaces } from "../../../Data/World/WorldSpaces.js";
+export class MeshManager {
+    static runningUpdate = false;
+    static columnSquare = new Square(Vector2Like.Create(1, 1), 16);
+    static renderCircle = new Circle(Vector2Like.Create(0.1, 1), 10);
+    static removeColumnsOutsideRadius(origion, radius) {
+        const [dimesnionId, x, y, z] = origion;
+        const dimension = MeshRegister.dimensions.get(dimesnionId);
+        if (!dimension)
+            return;
+        this.columnSquare.sideLength = WorldSpaces.column._bounds.x;
+        this.renderCircle.radius = radius;
+        this.renderCircle.center.x = origion[1];
+        this.renderCircle.center.y = origion[3];
+        dimension.forEach((region) => {
+            region.columns.forEach((column) => {
+                const location = column.location;
+                this.columnSquare.center.x = location[1];
+                this.columnSquare.center.y = location[3];
+                if (!Circle.IsSquareInsideOrTouchingCircle(this.columnSquare, this.renderCircle)) {
+                    setTimeout(() => this.chunks.removeColumn(location), 100);
+                }
+            });
+        });
+    }
+    static chunks = {
+        remove(data) {
+            const [location, substance] = data;
+            const mesh = MeshRegister.chunk.remove(location, substance);
+            if (!mesh)
+                return false;
+            DivineVoxelEngineRender.instance.renderer.nodes.meshes
+                .get(substance)
+                .returnMesh(mesh);
+        },
+        add(location, substance, meshData) {
+            let chunk = MeshRegister.chunk.get(location, substance);
+            let mesh;
+            if (!chunk) {
+                mesh = DivineVoxelEngineRender.instance.renderer.nodes.meshes
+                    .get(substance)
+                    .createMesh([location[1], location[2], location[3]], meshData);
+                mesh.type = "chunk";
+                MeshRegister.chunk.add(location, mesh, substance);
+                mesh.setEnabled(true);
+                mesh.isVisible = true;
+            }
+            else {
+                mesh = chunk.mesh;
+                DivineVoxelEngineRender.instance.renderer.nodes.meshes
+                    .get(substance)
+                    .updateVertexData([location[1], location[2], location[3]], meshData, mesh);
+            }
+        },
+        update(data) {
+            const [location, chunks] = data;
+            let i = chunks.length;
+            while (i--) {
+                const chunkData = chunks[i];
+                const substance = chunkData[0];
+                const remove = !chunkData[1];
+                if (remove) {
+                    const mesh = MeshRegister.chunk.remove(location, substance);
+                    if (mesh) {
+                        DivineVoxelEngineRender.instance.renderer.nodes.meshes
+                            .get(substance)
+                            .returnMesh(mesh);
+                    }
+                    continue;
+                }
+                let chunk = MeshRegister.chunk.get(location, substance);
+                let mesh;
+                if (!chunk) {
+                    mesh = DivineVoxelEngineRender.instance.renderer.nodes.meshes
+                        .get(substance)
+                        .createMesh([location[1], location[2], location[3]], chunkData[1][1]);
+                    mesh.type = "chunk";
+                    MeshRegister.chunk.add(location, mesh, substance);
+                }
+                else {
+                    mesh = chunk.mesh;
+                    DivineVoxelEngineRender.instance.renderer.nodes.meshes
+                        .get(substance)
+                        .updateVertexData([location[1], location[2], location[3]], chunkData[1][1], mesh);
+                }
+            }
+        },
+        removeColumn(data) {
+            const column = MeshRegister.column.remove(data);
+            if (!column)
+                return false;
+            for (const [key, chunk] of column.chunks) {
+                for (const [substance, mesh] of chunk) {
+                    DivineVoxelEngineRender.instance.renderer.nodes.meshes
+                        .get(substance)
+                        .returnMesh(mesh.mesh);
+                }
+            }
+        },
+    };
+}

package/Contexts/Render/Scene/MeshRegister.d.ts

@@ -0,0 +1,32 @@
+import type { MeshRegisterChunk, MeshRegisterDimensions, MushRegisterRegion, MeshRegisterColumn } from "../Scene/MeshRegister.types.js";
+import { type LocationData } from "../../../Math/index.js";
+import { URIMesh } from "@amodx/uri/Meshes/URIMesh.js";
+export declare const MeshRegister: {
+    _dimensions: MeshRegisterDimensions;
+    $INIT(): void;
+    clearAll(): void;
+    dimensions: {
+        add(id: string): Map<any, any>;
+        get(id: string): Map<string, MushRegisterRegion> | undefined;
+        getAllMeshes(id: string): Generator<[location: LocationData, substance: string, mesh: URIMesh]>;
+        remove(id: string): boolean;
+    };
+    region: {
+        add(location: LocationData): MushRegisterRegion;
+        remove(location: LocationData): boolean;
+        _getRegionData(): MushRegisterRegion;
+        get(location: LocationData): false | MushRegisterRegion;
+    };
+    column: {
+        add(location: LocationData): MeshRegisterColumn;
+        remove(location: LocationData): false | MeshRegisterColumn;
+        _getColumnData(location: LocationData): MeshRegisterColumn;
+        get(location: LocationData): false | MeshRegisterColumn | undefined;
+    };
+    chunk: {
+        add(location: LocationData, mesh: URIMesh, substance: string): Map<string, MeshRegisterChunk>;
+        _getChunkData(mesh: URIMesh): MeshRegisterChunk;
+        remove(location: LocationData, substance: string): false | URIMesh<import("@amodx/uri/Scenes/URIScene.js").URIScene<unknown>, unknown>;
+        get(location: LocationData, substance: string): false | MeshRegisterChunk;
+    };
+};

package/Contexts/Render/Scene/MeshRegister.js

@@ -0,0 +1,195 @@
+import { Vector3Like } from "@amodx/math";
+import { WorldSpaces } from "../../../Data/World/WorldSpaces.js";
+export const MeshRegister = {
+    _dimensions: new Map(),
+    $INIT() {
+        this._dimensions.set("main", new Map());
+    },
+    clearAll() {
+        for (const [dkey, dim] of this._dimensions) {
+            this.dimensions.remove(dkey);
+        }
+        this._dimensions.set("main", new Map());
+    },
+    dimensions: {
+        add(id) {
+            const dimesnion = new Map();
+            MeshRegister._dimensions.set(id, dimesnion);
+            return dimesnion;
+        },
+        get(id) {
+            return MeshRegister._dimensions.get(id);
+        },
+        *getAllMeshes(id) {
+            const dimension = MeshRegister._dimensions.get(id);
+            if (!dimension)
+                return false;
+            for (const [key, region] of dimension) {
+                for (const [columnKey, column] of region.columns) {
+                    for (const [chunkKey, chunk] of column.chunks) {
+                        for (const [substance, mesh] of chunk) {
+                            yield [
+                                [
+                                    column.location[0],
+                                    column.location[1],
+                                    column.location[2] + chunkKey * WorldSpaces.chunk._bounds.y,
+                                    column.location[3],
+                                ],
+                                substance,
+                                mesh.mesh,
+                            ];
+                        }
+                    }
+                }
+            }
+        },
+        remove(id) {
+            const dimension = MeshRegister._dimensions.get(id);
+            if (!dimension)
+                return false;
+            dimension.forEach((region) => {
+                region.columns.forEach((column) => {
+                    column.chunks.forEach((chunk) => {
+                        chunk.forEach((chunkMeshes) => {
+                            chunkMeshes.mesh.dispose();
+                        });
+                    });
+                });
+            });
+            MeshRegister._dimensions.delete(id);
+            return true;
+        },
+    },
+    region: {
+        add(location) {
+            let dimension = MeshRegister.dimensions.get(location[0]);
+            if (!dimension) {
+                dimension = MeshRegister.dimensions.add(location[0]);
+            }
+            const region = this._getRegionData();
+            dimension.set(WorldSpaces.region.getKeyXYZ(location[1], location[2], location[3]), region);
+            return region;
+        },
+        remove(location) {
+            const region = MeshRegister.region.get(location);
+            if (!region)
+                return false;
+            const dimension = MeshRegister.dimensions.get(location[0]);
+            if (!dimension)
+                return false;
+            dimension.delete(WorldSpaces.region.getKeyXYZ(location[1], location[2], location[3]));
+            region.columns.forEach((column) => {
+                column.chunks.forEach((chunk) => {
+                    chunk.forEach((chunkMeshes) => {
+                        chunkMeshes.mesh.dispose();
+                    });
+                });
+            });
+            return true;
+        },
+        _getRegionData() {
+            return {
+                columns: new Map(),
+            };
+        },
+        get(location) {
+            const dimension = MeshRegister.dimensions.get(location[0]);
+            if (!dimension)
+                return false;
+            const region = dimension.get(WorldSpaces.region.getKeyXYZ(location[1], location[2], location[3]));
+            if (!region)
+                return false;
+            return region;
+        },
+    },
+    column: {
+        add(location) {
+            let region = MeshRegister.region.get(location);
+            if (!region) {
+                region = MeshRegister.region.add(location);
+            }
+            const column = this._getColumnData(location);
+            region.columns.set(WorldSpaces.column.getIndexXYZ(location[1], location[2], location[3]), column);
+            return column;
+        },
+        remove(location) {
+            let region = MeshRegister.region.get(location);
+            if (!region)
+                return false;
+            const index = WorldSpaces.column.getIndexXYZ(location[1], location[2], location[3]);
+            const column = region.columns.get(index);
+            if (!column)
+                return false;
+            region.columns.delete(index);
+            if (region.columns.size == 0) {
+                MeshRegister.region.remove(location);
+            }
+            return column;
+        },
+        _getColumnData(location) {
+            return {
+                location: [
+                    location[0],
+                    ...Vector3Like.ToArray(WorldSpaces.column.getPositionXYZ(location[1], location[2], location[3])),
+                ],
+                chunks: new Map(),
+            };
+        },
+        get(location) {
+            const region = MeshRegister.region.get(location);
+            if (!region)
+                return false;
+            return region.columns.get(WorldSpaces.column.getIndexXYZ(location[1], location[2], location[3]));
+        },
+    },
+    chunk: {
+        add(location, mesh, substance) {
+            let column = MeshRegister.column.get(location);
+            if (!column) {
+                column = MeshRegister.column.add(location);
+            }
+            const index = WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[2]);
+            let chunk = column.chunks.get(index);
+            if (!chunk) {
+                chunk = new Map();
+                column.chunks.set(index, chunk);
+            }
+            chunk.set(substance, this._getChunkData(mesh));
+            return chunk;
+        },
+        _getChunkData(mesh) {
+            return {
+                mesh: mesh,
+            };
+        },
+        remove(location, substance) {
+            const column = MeshRegister.column.get(location);
+            if (!column)
+                return false;
+            const index = WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]);
+            const chunk = column.chunks.get(index);
+            if (!chunk)
+                return false;
+            const chunkMesh = chunk.get(substance);
+            if (!chunkMesh)
+                return false;
+            chunk.delete(substance);
+            if (chunk.size == 0) {
+                column.chunks.delete(index);
+            }
+            return chunkMesh.mesh;
+        },
+        get(location, substance) {
+            const column = MeshRegister.column.get(location);
+            if (!column)
+                return false;
+            const chunk = column.chunks.get(WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]));
+            if (!chunk)
+                return false;
+            const chunkMesh = chunk.get(substance);
+            if (!chunkMesh)
+                return false;
+            return chunkMesh;
+        },
+    },
+};

package/Contexts/Render/Scene/MeshRegister.types.d.ts

@@ -0,0 +1,13 @@
+import { URIMesh } from "@amodx/uri/Meshes/URIMesh";
+import type { LocationData } from "Math/index.js";
+export type MeshRegisterChunk = {
+    mesh: URIMesh;
+};
+export type MeshRegisterColumn = {
+    location: LocationData;
+    chunks: Map<number, Map<string, MeshRegisterChunk>>;
+};
+export type MushRegisterRegion = {
+    columns: Map<number, MeshRegisterColumn>;
+};
+export type MeshRegisterDimensions = Map<string, Map<string, MushRegisterRegion>>;

package/Contexts/Render/Scene/MeshRegister.types.js

@@ -0,0 +1 @@
+export {};

package/Contexts/Render/Tasks/RenderTasks.d.ts

@@ -0,0 +1,7 @@
+export declare const RenderTasks: {
+    setChunk: void;
+    removeChunk: void;
+    removeColumn: void;
+    clearAll: void;
+    removeColumnsOutsideRadius: void;
+};

package/Contexts/Render/Tasks/RenderTasks.js

@@ -0,0 +1,24 @@
+import { Threads } from "@amodx/threads/";
+import { MeshManager } from "../Scene/MeshManager.js";
+import { MeshRegister } from "../Scene/MeshRegister.js";
+export const RenderTasks = {
+    setChunk: Threads.registerTasks("set-chunk", (data) => {
+        MeshManager.chunks.update(data);
+        /*   if (data[2] == 0) return MeshManager.chunks.update(data);
+          setTimeout(() => {
+            MeshManager.chunks.update(data);
+          }, 10); */
+    }),
+    removeChunk: Threads.registerTasks("remove-chunk", (data) => {
+        MeshManager.chunks.remove(data);
+    }),
+    removeColumn: Threads.registerTasks("remove-column", (data) => {
+        MeshManager.chunks.removeColumn(data);
+    }),
+    clearAll: Threads.registerTasks("clear-all", (data) => {
+        MeshRegister.clearAll();
+    }),
+    removeColumnsOutsideRadius: Threads.registerTasks("remove-column-outside-radius", (data) => {
+        MeshManager.removeColumnsOutsideRadius(data[0], data[1]);
+    }),
+};

package/Contexts/Render/Tasks/RenderTasks.types.d.ts

@@ -0,0 +1,27 @@
+import { DVENodeMeshAttributes } from "../../../Interfaces/Render/Nodes/DVERenderNode.types";
+import type { LocationData } from "../../../Math/index.js";
+export type SetChunkMeshTask = [
+    location: LocationData,
+    meshes: (ChunkMeshData | RemoveChunkTasks)[],
+    priority: number
+];
+export type ChunkMeshData = [
+    substanceType: string,
+    meshData: [
+        location: LocationData,
+        attributes: DVENodeMeshAttributes
+    ]
+];
+type RemoveChunkTasks = [
+    substanceType: string,
+    removeFlag: false
+];
+export type RemoveChunkMeshTasks = [
+    location: LocationData,
+    substanceType: string
+];
+export type RemoveChunksOutsideDistance = [
+    location: LocationData,
+    distance: number
+];
+export {};

package/Contexts/Render/Tasks/RenderTasks.types.js

@@ -0,0 +1 @@
+export {};