@divinevoxel/vlox 0.0.1 → 0.0.3

package/Contexts/Constructor/Tasks/TasksRequest.js

@@ -1,218 +0,0 @@
-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.js

@@ -1,151 +0,0 @@
-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/Nexus/InitWorker.d.ts

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

package/Contexts/Nexus/InitWorker.js

@@ -1,15 +0,0 @@
-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.js

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

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

@@ -1,10 +0,0 @@
-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/Render/InitThreads.d.ts

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

package/Contexts/Render/InitThreads.js

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

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

@@ -1,105 +0,0 @@
-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.types.d.ts

@@ -1,13 +0,0 @@
-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/RichWorld/DivineStarVoxelEngineRichWorld.d.ts

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

package/Contexts/RichWorld/DivineStarVoxelEngineRichWorld.js

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