@divinevoxel/vlox 0.0.2 → 0.0.3

package/Contexts/Base/Remote/Sync/DataSync.types.d.ts

@@ -0,0 +1,34 @@
+import { LocationData } from "Math/index.js";
+import { BinaryStructData } from "@amodx/binary";
+import { EngineSettingsData } from "../../../../Settings/EngineSettings.types";
+import { CachedVoxelModelData } from "../../../../Cache/Cache.types";
+export type DataSyncMapsData = {
+    stringMaps: Record<string, string[]>;
+    objectMaps: Record<string, any[]>;
+};
+export type DataSyncStringPaletteData = {
+    palette: string[];
+};
+export type DataSyncData = {
+    settings: EngineSettingsData;
+    modelData?: CachedVoxelModelData;
+    threads: {
+        nexus: boolean;
+    };
+    worldData: {
+        chunkStruct: BinaryStructData;
+        columnStruct: BinaryStructData;
+        regionStruct: BinaryStructData;
+    };
+    voxel: {
+        struct: BinaryStructData;
+        index: Uint16Array;
+        nameToIdMap: Record<string, string>;
+        idToNameMap: Record<string, string>;
+    } & DataSyncMapsData & DataSyncStringPaletteData;
+    substance: {
+        struct: BinaryStructData;
+    } & DataSyncMapsData & DataSyncStringPaletteData;
+    materials: {} & DataSyncStringPaletteData;
+};
+export type WorldDataSync = [location: LocationData, buffer: SharedArrayBuffer];

package/Contexts/Base/Remote/Sync/InitDataSync.d.ts

@@ -0,0 +1,4 @@
+import { DataSyncData } from "./DataSync.types";
+export default function InitDataSync(props: {
+    onSync(data: DataSyncData): void;
+}): void;

package/Contexts/Base/Remote/Sync/InitDataSync.js

@@ -0,0 +1,43 @@
+import { Threads } from "@amodx/threads/";
+import { VoxelPalette } from "../../../../Data/Palettes/VoxelPalette";
+import { SubstancePalette } from "../../../../Data/Palettes/SubstancePalette";
+import { MappedDataRegister } from "../../../../Data/Register/MappedDataRegister";
+import { VoxelStruct } from "../../../../Data/Structs/VoxelStruct";
+import { SubstanceStruct } from "../../../../Data/Structs/SubstanceStruct";
+import { EngineSettings } from "../../../../Settings/EngineSettings";
+//objects
+import { MaterialPalette } from "../../../../Data/Palettes/MaterialPalette";
+import { Column, Chunk, Region } from "../../../../Data/World/Classes/index.js";
+export default function InitDataSync(props) {
+    Threads.registerTasks("sync-data", (data) => {
+        EngineSettings.syncSettings(data.settings);
+        MaterialPalette.setPalette(data.materials.palette);
+        //voxels
+        VoxelPalette.loadIn(data.voxel.palette, data.voxel.nameToIdMap, data.voxel.idToNameMap);
+        const voxelStringMaps = MappedDataRegister.stringMaps.getSegment("voxel");
+        for (const key in data.voxel.stringMaps) {
+            voxelStringMaps.add(key, data.voxel.stringMaps[key]);
+        }
+        const voxelObjectMaps = MappedDataRegister.objectMaps.getSegment("voxel");
+        for (const key in data.voxel.objectMaps) {
+            voxelObjectMaps.add(key, data.voxel.objectMaps[key]);
+        }
+        VoxelStruct.init(data.voxel.struct);
+        VoxelStruct.sync(data.voxel.index);
+        //substances
+        SubstancePalette.setPalette(data.substance.palette);
+        const substanceStringMaps = MappedDataRegister.stringMaps.getSegment("substance");
+        for (const key in data.substance.stringMaps) {
+            substanceStringMaps.add(key, data.substance.stringMaps[key]);
+        }
+        const substanceObjectMaps = MappedDataRegister.objectMaps.getSegment("substance");
+        for (const key in data.substance.objectMaps) {
+            substanceObjectMaps.add(key, data.substance.objectMaps[key]);
+        }
+        SubstanceStruct.init(data.substance.struct);
+        Chunk.StateStruct.init(data.worldData.chunkStruct);
+        Column.StateStruct.init(data.worldData.columnStruct);
+        Region.StateStruct.init(data.worldData.regionStruct);
+        props.onSync(data);
+    });
+}

package/Contexts/Base/Remote/Sync/InitWorldDataSync.js

@@ -0,0 +1,37 @@
+import { Threads } from "@amodx/threads/";
+import { DVEFDataSyncIds } from "../../../../Data/Constants/DVEFDataSyncIds.js";
+import { WorldRegister } from "../../../../Data/World/WorldRegister.js";
+import { DimensionsRegister } from "../../../../Data/World/DimensionsRegister.js";
+import { RegionHeaderRegister } from "../../../../Data/World/RegionHeaderRegister.js";
+export default function () {
+    const register = new WorldRegister();
+    Threads.onDataSync(DVEFDataSyncIds.Dimesnion, (data) => {
+        DimensionsRegister.instance.registerDimension(data.id, data.options);
+    });
+    Threads.onDataSync(DVEFDataSyncIds.Chunk, (data) => {
+        register.setDimension(data[0][0]);
+        register.chunk.add(data[0][1], data[0][2], data[0][3], data[1]);
+    }, (data) => {
+        register.setDimension(data[0]);
+        register.chunk.remove(data[1], data[2], data[3]);
+    });
+    Threads.onDataSync(DVEFDataSyncIds.Column, (data) => {
+        register.setDimension(data[0][0]);
+        register.column.add(data[0][1], data[0][2], data[0][3], data[1]);
+    }, (data) => {
+        register.setDimension(data[0]);
+        register.column.remove(data[1], data[2], data[3]);
+    });
+    Threads.onDataSync(DVEFDataSyncIds.Region, (data) => {
+        register.setDimension(data[0][0]);
+        register.region.add(data[0][1], data[0][2], data[0][3], data[1]);
+    }, (data) => {
+        register.setDimension(data[0]);
+        register.region.remove(data[1], data[2], data[3]);
+    });
+    Threads.onDataSync(DVEFDataSyncIds.RegionHeader, (data) => {
+        RegionHeaderRegister.add(data[0], data[1]);
+    }, (data) => {
+        RegionHeaderRegister.remove(data);
+    });
+}

package/{Interfaces/Classes → Contexts/Base}/ThreadManager.d.ts

@@ -1,14 +1,12 @@
 import { Thread, ThreadPool, CommPortTypes } from "@amodx/threads";
-import { AsyncPipeline } from "@amodx/core/Pipelines";
-import { ThreadState } from "./ThreadState";
+import { Pipeline } from "@amodx/core/Pipelines";
 export declare abstract class ThreadManager {
     pipelines: {
-        setPorts: AsyncPipeline<ThreadManager>;
-        init: AsyncPipeline<ThreadManager>;
+        setPorts: Pipeline<ThreadManager>;
+        init: Pipeline<ThreadManager>;
     };
     commMap: Map<string, Thread | ThreadPool>;
     comms: (Thread | ThreadPool)[];
-    abstract state: ThreadState;
     init(): Promise<void>;
     setThreadPort(id: string, ports: CommPortTypes | CommPortTypes[]): void;
     addThread(comm: Thread | ThreadPool): void;

package/{Interfaces/Classes → Contexts/Base}/ThreadManager.js

@@ -1,9 +1,9 @@
 import { Thread, ThreadPool } from "@amodx/threads";
-import { AsyncPipeline } from "@amodx/core/Pipelines";
+import { Pipeline } from "@amodx/core/Pipelines";
 export class ThreadManager {
     pipelines = {
-        setPorts: new AsyncPipeline(),
-        init: new AsyncPipeline(),
+        setPorts: new Pipeline(),
+        init: new Pipeline(),
     };
     commMap = new Map();
     comms = [];

package/Contexts/Constructor/{Threads/ConstrcutorTheads.d.ts → ConstrcutorTheads.d.ts}

@@ -1,8 +1,6 @@
-import { ConstructorThreadState } from "./ConstructorThreadState";
-import { ThreadManager } from "../../../Interfaces/Classes/ThreadManager";
+import { ThreadManager } from "../Base/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,14 @@
+import { Threads } from "@amodx/threads/";
+import { ThreadManager } from "../Base/ThreadManager";
+const world = Threads.createThread("world");
+export class ConstructorThreadManager extends ThreadManager {
+    static instnace;
+    parent = Threads.parent;
+    world = world;
+    constructor() {
+        super();
+        ConstructorThreadManager.instnace = this;
+        this.addThread(this.world);
+        this.addThread(this.parent);
+    }
+}

package/Contexts/Constructor/DivineVoxelEngineConstructor.d.ts

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

package/Contexts/Constructor/DivineVoxelEngineConstructor.js

@@ -1,30 +1,16 @@
 //threadcomm
 import { Threads } from "@amodx/threads/";
-//functions
-import InitWorker from "./InitWorker.js";
-import { Environment } from "@amodx/core/Environment/Environment.js";
-import { DVEDataCore } from "../../Data/DVEDataCore.js";
-import ConstructorTasks from "./Tasks/ConstructorTasks.js";
-import { ConstructorThreadManager } from "./Threads/ConstrcutorTheads.js";
+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 DVEDataCore();
-    mesher;
-    constructor(data) {
+    mesher = new DVEMesher();
+    constructor() {
         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/Tasks/DVEConstructorTasksQueues.js

@@ -1,6 +1,5 @@
-//objects
-import { ConstructorTasksIds } from "./ConstructorTasksIds.js";
 import { Observable } from "@amodx/core/Observers/Observable.js";
+import { TasksIds } from "../../../Tasks/TasksIds";
 export class DVEConstructorTasksQueues {
     constructors;
     static instance;
@@ -9,7 +8,7 @@ export class DVEConstructorTasksQueues {
         this.constructors = constructors;
         if (!DVEConstructorTasksQueues.instance)
             DVEConstructorTasksQueues.instance = this;
-        this.registerTasks("build-chunk", ConstructorTasksIds.BuildChunk);
+        this.registerTasks("build-chunk", TasksIds.BuildChunk);
         DVEConstructorTasksQueues.onCreated.notify(this);
         this.addQueue("main");
     }

package/Contexts/Nexus/DivineVoxelEngineNexus.d.ts

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

package/Contexts/Nexus/DivineVoxelEngineNexus.js

@@ -1,27 +1,17 @@
 //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";
+import { NexusThreads } from "./NexusTheads.js";
 export class DivineVoxelEngineNexus {
+    static environment = "browser";
     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/{Threads/NexusTheads.d.ts → NexusTheads.d.ts}

@@ -1,10 +1,8 @@
-import { NexusThreadState } from "./NexusThreadState.js";
-import { ThreadManager } from "../../../Interfaces/Classes/ThreadManager.js";
+import { ThreadManager } from "../Base/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;

package/Contexts/Nexus/NexusTheads.js

@@ -0,0 +1,15 @@
+import { Threads } from "@amodx/threads/";
+import { ThreadManager } from "../Base/ThreadManager.js";
+export const parent = Threads.parent;
+export const Richworld = Threads.createThread("rich-world");
+export const world = Threads.createThread("world");
+export class NexusThreads extends ThreadManager {
+    parent = Threads.parent;
+    world = Threads.createThread("world");
+    NexusComm = Threads.createThread("nexus");
+    DataComm = Threads.createThread("data-loader");
+    ConstructorComm = Threads.createThreadPool({
+        name: "constructor",
+        onPortSet() { },
+    });
+}

package/Contexts/Render/DVERenderThreads.d.ts

@@ -1,4 +1,4 @@
-import { ThreadManager } from "../../Interfaces/Classes/ThreadManager";
+import { ThreadManager } from "../Base/ThreadManager";
 export declare class DVERenderThreads extends ThreadManager {
     nexus: import("@amodx/threads").Thread;
     richWorld: import("@amodx/threads").Thread;

package/Contexts/Render/DVERenderThreads.js

@@ -1,5 +1,5 @@
 import { Threads } from "@amodx/threads";
-import { ThreadManager } from "../../Interfaces/Classes/ThreadManager";
+import { ThreadManager } from "../Base/ThreadManager";
 export class DVERenderThreads extends ThreadManager {
     nexus = Threads.createThread("nexus");
     richWorld = Threads.createThread("rich-world");
@@ -16,32 +16,5 @@ export class DVERenderThreads extends ThreadManager {
         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

@@ -1,10 +1,10 @@
-import { EngineSettings } from "../../Data/Settings/EngineSettings.js";
+import { EngineSettings } from "../../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 { DVEDataCore } from "../../Data/DVEDataCore.js";
+import type { EngineSettingsData } from "../../Settings/EngineSettings.types.js";
+import type { RecursivePartial } from "../../Util/Util.types.js";
+import { DVERenderer } from "../../Renderer/DVERenderer.js";
+import { MeshManager } from "../../Renderer/MeshManager.js";
+import { MeshRegister } from "../../Renderer/MeshRegister.js";
 import { DVERenderThreads } from "./DVERenderThreads.js";
 type PartialEngineSettings = RecursivePartial<EngineSettingsData>;
 export interface DVERInitData extends PartialEngineSettings {
@@ -12,7 +12,6 @@ export interface DVERInitData extends PartialEngineSettings {
     constructorWorkers: Worker[];
     renderer: DVERenderer;
     nexusWorker?: Worker;
-    richWorldWorker?: Worker;
 }
 export declare class DivineVoxelEngineRender {
     static instance: DivineVoxelEngineRender;
@@ -20,35 +19,7 @@ export declare class DivineVoxelEngineRender {
     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;
-        };
-    };
+    meshRegister: typeof MeshRegister;
     renderer: DVERenderer;
     tasks: {
         setChunk: void;
@@ -58,9 +29,7 @@ export declare class DivineVoxelEngineRender {
         removeColumnsOutsideRadius: void;
     };
     threads: DVERenderThreads;
-    data: DVEDataCore;
     constructor();
-    init(props: DVERInitData): Promise<void>;
     /**# clearAll
      *---
      * Clear all world data and meshes.

package/Contexts/Render/DivineVoxelEngineRender.js

@@ -1,12 +1,9 @@
 //objects
-import { EngineSettings } from "../../Data/Settings/EngineSettings.js";
+import { EngineSettings } from "../../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 { DVEDataCore } from "../../Data/DVEDataCore.js";
+import { MeshManager } from "../../Renderer/MeshManager.js";
+import { MeshRegister } from "../../Renderer/MeshRegister.js";
 import { DVERenderThreads } from "./DVERenderThreads.js";
 export class DivineVoxelEngineRender {
     static instance;
@@ -18,28 +15,11 @@ export class DivineVoxelEngineRender {
     renderer;
     tasks = RenderTasks;
     threads = new DVERenderThreads();
-    data = new DVEDataCore();
     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.

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

@@ -1,32 +1,39 @@
-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;
-    };
-};
+import { MushRegisterRegion } from "../../../Renderer/Classes/MushRegisterRegion.js";
+import { MeshRegisterColumn } from "../../../Renderer/Classes/MeshRegisterColumn.js";
+import { ChunkMesh } from "../../../Renderer/Classes/ChunkMesh.js";
+import { ChunkMeshInterface } from "../../../Renderer/DVEChunkMeshInterface.js";
+export type MeshRegisterDimensions = Map<string, Map<string, MushRegisterRegion>>;
+declare class Chunk {
+    static addMesh(location: LocationData, mesh: ChunkMeshInterface, substance: string): ChunkMesh;
+    static add(location: LocationData): ChunkMesh;
+    static removeMesh(location: LocationData, substance: string): false | ChunkMeshInterface;
+    static getMesh(location: LocationData, substance: string): false | ChunkMeshInterface;
+    static remove(location: LocationData): false | ChunkMesh;
+    static get(location: LocationData): false | ChunkMesh;
+}
+declare class Column {
+    static add(location: LocationData): MeshRegisterColumn;
+    static remove(location: LocationData): false | MeshRegisterColumn;
+    static get(location: LocationData): false | MeshRegisterColumn | undefined;
+}
+declare class Region {
+    static add(location: LocationData): MushRegisterRegion;
+    static remove(location: LocationData): boolean;
+    static get(location: LocationData): false | MushRegisterRegion;
+}
+declare class Dimensions {
+    static add(id: string): Map<any, any>;
+    static get(id: string): Map<string, MushRegisterRegion> | undefined;
+    static getAllMeshes(id: string): Generator<[location: LocationData, substance: string, mesh: ChunkMeshInterface]>;
+    static remove(id: string): boolean;
+}
+export declare class MeshRegister {
+    static _dimensions: MeshRegisterDimensions;
+    static dimensions: typeof Dimensions;
+    static region: typeof Region;
+    static column: typeof Column;
+    static chunk: typeof Chunk;
+    static clearAll(): void;
+}
+export {};