@divinevoxel/vlox 0.0.0

package/DataLoader/Node/Tools/NodeRegionTool.js

@@ -0,0 +1,134 @@
+import { DVED } from "../DivineVoxelEngineData.js";
+import { System } from "../System/System.js";
+import { RegionSystem } from "../System/RegionSystem.js";
+import { RegionData } from "../Util/DVED.util.js";
+import { SystemPath } from "../System/SystemPath.js";
+export class NodeRegionTool {
+    location = ["main", 0, 0, 0];
+    dimension = "";
+    previousDimension = "";
+    path = "";
+    fileName = "";
+    dataType = "world-data";
+    setDataType(dataTypes) {
+        this.dataType = dataTypes;
+        this._setFileName();
+        return this;
+    }
+    setLocation(location) {
+        this.location = location;
+        this.dimension = location[0];
+        this.path = SystemPath.getDataDirectory();
+        this._setFileName();
+        if (location[0] != this.previousDimension) {
+            System.mkdirs([
+                this._dimensionPath(),
+                this._getDataPath("world-data"),
+                this._getDataPath("rich-data"),
+                this._getDataPath("entities"),
+                this._getDataPath("dbo"),
+            ]);
+        }
+        return this;
+    }
+    getCurrentPath() {
+        return this._getDataPath(this.dataType, this.fileName);
+    }
+    _getSwapPath() {
+        return this._getDataPath(this.dataType, "swap-" + this.fileName);
+    }
+    _dimensionPath(dataPath = "") {
+        return `${this.path}/${this.dimension}/${dataPath}`;
+    }
+    _getDataPath(dataType, fileName = "") {
+        return this._dimensionPath(`${dataType}/${fileName}`);
+    }
+    _setFileName() {
+        const regionPOS = DVED.spaces.region.getPositionXYZ(this.location[1], this.location[2], this.location[3]);
+        this.fileName = `region_${this.dataType.replace("-", "_")}_${this.dimension}_${regionPOS.x}_${regionPOS.y}_${regionPOS.z}.dved`;
+    }
+    regionExists() {
+        const file = System.sync.openFile(this.getCurrentPath());
+        if (file)
+            file.close();
+        return Boolean(file);
+    }
+    createRegion() {
+        return System.sync.createFile(this.getCurrentPath(), RegionData.headByteSize);
+    }
+    regionHasColumn() {
+        const timeStamp = this.getColumnTimestamp();
+        return Number(timeStamp) > 0;
+    }
+    getAllColumns() {
+        const file = System.sync.openFile(this.getCurrentPath());
+        if (!file)
+            return false;
+        return RegionSystem._getAllColumns(file);
+    }
+    copyToNewfile() {
+        const swapFile = System.sync.createAndOpenFile(this._getSwapPath(), RegionData.headByteSize);
+        if (!swapFile)
+            return;
+        const columns = this.getAllColumns();
+        if (!columns)
+            return;
+        for (const column of columns) {
+            RegionSystem.saveColumn(swapFile, column[0], column[1]);
+        }
+    }
+    getColumnTimestamp() {
+        const file = System.sync.openFile(this.getCurrentPath());
+        if (!file)
+            return false;
+        const timeStamp = RegionSystem.timeStamp.get(file, RegionSystem._getIndex(this.location));
+        file.close();
+        return !timeStamp ? 0 : timeStamp;
+    }
+    getSectorIndex() {
+        const file = System.sync.openFile(this.getCurrentPath());
+        if (!file)
+            return false;
+        const index = RegionSystem.sectorIndex.get(file, RegionSystem._getIndex(this.location));
+        file.close();
+        return !index ? 0 : index;
+    }
+    getColumnDataLength() {
+        const file = System.sync.openFile(this.getCurrentPath());
+        if (!file)
+            return false;
+        const length = RegionSystem.columnLength.get(file, RegionSystem._getIndex(this.location));
+        file.close();
+        return !length ? 0 : length;
+    }
+    getHeader() {
+        if (!this.regionExists()) {
+            this.createRegion();
+        }
+        const file = System.sync.openFile(this.getCurrentPath());
+        if (!file)
+            return false;
+        const buffer = RegionSystem.getHeader(file);
+        file.close();
+        return buffer;
+    }
+    loadColumn() {
+        const file = System.sync.openFile(this.getCurrentPath());
+        if (!file)
+            return false;
+        const data = RegionSystem.loadColumn(file, this.location);
+        file.close();
+        return data;
+    }
+    saveColumn(buffer) {
+        if (!this.regionExists()) {
+            this.createRegion();
+        }
+        const file = System.sync.openFile(this.getCurrentPath());
+        if (!file)
+            return false;
+        RegionSystem.saveColumn(file, this.location, buffer);
+        file.close();
+        return true;
+    }
+}

package/DataLoader/Node/Util/DVED.util.d.ts

@@ -0,0 +1,17 @@
+export declare const SecotrData: {
+    byteSize: number;
+    maxSectors: number;
+    getSectorsNeeded(byteLength: number): number;
+    getTotalSectorsInFile(byteLength: number): number;
+    getSectorByteIndex(index: number): number;
+    getTotalBytesNeeded(byteLength: number): number;
+};
+export declare const RegionData: {
+    headByteSize: number;
+    numColumns: number;
+};
+export declare const RegionTagIds: {
+    sectorIndex: string;
+    columnLength: string;
+    timeStamp: string;
+};

package/DataLoader/Node/Util/DVED.util.js

@@ -0,0 +1,25 @@
+export const SecotrData = {
+    byteSize: 0,
+    maxSectors: 16,
+    getSectorsNeeded(byteLength) {
+        return Math.ceil(byteLength / SecotrData.byteSize);
+    },
+    getTotalSectorsInFile(byteLength) {
+        return Math.ceil(Math.abs(byteLength - RegionData.headByteSize) / SecotrData.byteSize);
+    },
+    getSectorByteIndex(index) {
+        return index * this.byteSize + RegionData.headByteSize;
+    },
+    getTotalBytesNeeded(byteLength) {
+        return this.getSectorsNeeded(byteLength) * this.byteSize;
+    },
+};
+export const RegionData = {
+    headByteSize: 0,
+    numColumns: 0
+};
+export const RegionTagIds = {
+    sectorIndex: "#dved-column-sector-index",
+    columnLength: "#dved-column-legnth-index",
+    timeStamp: "#dved-column-save-timestamp",
+};

package/DataLoader/Node/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./DivineVoxelEngineData.js";
+export * from "./Tools/NodeRegionTool.js";
+export * from "./System/RegionSystem.js";

package/DataLoader/Node/index.js

@@ -0,0 +1,3 @@
+export * from "./DivineVoxelEngineData.js";
+export * from "./Tools/NodeRegionTool.js";
+export * from "./System/RegionSystem.js";

package/DataLoader/Types/DVED.types.d.ts

@@ -0,0 +1,13 @@
+export type DVEDDataTypes = "world-data" | "rich-data" | "entities" | "dbo";
+export type DVEDSyncFile = {
+    getSize(): number;
+    clear(byteStart: number, byteLength: number): boolean;
+    write(byteStart: number, data: ArrayBuffer): boolean;
+    read(byteStart: number, byteLength: number): ArrayBuffer | false;
+    close(): void;
+    rename(newPath: string): boolean;
+    move(newPath: string): boolean;
+    reOpen(): boolean;
+    getPath(): string;
+    delete(): boolean;
+};

package/DataLoader/Types/DVED.types.js

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

package/DataLoader/World/DataHandlerWrapper.d.ts

@@ -0,0 +1,23 @@
+import type { LocationData } from "../../Math";
+import { DVEDataHandler, DataLoaderModes } from "../../Interfaces/DataLoader/DVEDataHandler.js";
+import { RichDataTool } from "../../Tools/Data/RichDataTool.js";
+import { ColumnDataTool } from "../../Tools/Data/WorldData/ColumnDataTool.js";
+import { DataSerializerTool } from "./Tools/DataSerializerTool.js";
+export declare class DataHanlderWrapper {
+    static instance: DataHanlderWrapper;
+    columnDatatool: ColumnDataTool;
+    static mode: DataLoaderModes;
+    handler: DVEDataHandler;
+    richData: RichDataTool;
+    seralizer: DataSerializerTool;
+    constructor();
+    init(handler: DVEDataHandler): void;
+    loadRegionHeader(location: LocationData): Promise<boolean>;
+    saveColumn(location: LocationData): Promise<boolean | undefined>;
+    loadColumn(location: LocationData): Promise<boolean>;
+    unLoadColumn(location: LocationData): Promise<true | undefined>;
+    setPath(id: string): Promise<boolean>;
+    columnExists(location: LocationData): Promise<boolean>;
+    columnExistsBatch(location: LocationData[]): Promise<false | Record<string, boolean>>;
+    columnTimestamp(location: LocationData): Promise<number>;
+}

package/DataLoader/World/DataHandlerWrapper.js

@@ -0,0 +1,179 @@
+//objects
+import { WorldRegister } from "../../Data/World/WorldRegister.js";
+import { DataHooks } from "../../Data/DataHooks.js";
+import { RichDataTool } from "../../Tools/Data/RichDataTool.js";
+import { ColumnDataTool } from "../../Tools/Data/WorldData/ColumnDataTool.js";
+import { arrayBufferToSharedArrayBuffer } from "@amodx/core/Buffers/arrayBufferToSharedArrayBuffer.js";
+import { DataSerializerTool } from "./Tools/DataSerializerTool.js";
+import { DivineVoxelEngineWorld } from "Contexts/World";
+export class DataHanlderWrapper {
+    static instance;
+    columnDatatool = new ColumnDataTool();
+    static mode = "indexdb";
+    handler;
+    richData;
+    seralizer = new DataSerializerTool();
+    constructor() {
+        if (DataHanlderWrapper.instance)
+            return DataHanlderWrapper.instance;
+        DataHanlderWrapper.instance = this;
+    }
+    init(handler) {
+        this.handler = handler;
+        this.richData = new RichDataTool();
+    }
+    async loadRegionHeader(location) {
+        this.handler.setDataType("world-data");
+        try {
+            const headerBuffer = await this.handler.getRegionHeader(location);
+            if (!headerBuffer)
+                return false;
+            const sab = arrayBufferToSharedArrayBuffer(headerBuffer);
+            DivineVoxelEngineWorld.instance.tasks.loadRegionHeader(location, sab);
+            this.handler.setDataType("world-data");
+            return true;
+        }
+        catch (error) {
+            console.error(`Problem getting region header at ${location.toString()}`);
+            console.error(error);
+            return false;
+        }
+    }
+    async saveColumn(location) {
+        this.handler.setDataType("world-data");
+        if (this.columnDatatool.setLocation(location).loadIn()) {
+            try {
+                if (this.columnDatatool.isStored())
+                    return true;
+                this.columnDatatool.markAsStored();
+                const column = await this.seralizer.serializeColumnAsync(location);
+                if (!column)
+                    return false;
+                this.handler.setDataType("world-data");
+                const success = await this.handler.saveColumn(location, column);
+                if (!success) {
+                    this.columnDatatool.markAsNotStored();
+                    throw new Error(`Could not store column at ${location.toString()}`);
+                }
+                if (this.richData._enabled) {
+                    const column = await this.richData
+                        .setLocation(location)
+                        .getColumnAsync();
+                    if (column) {
+                        this.handler.setDataType("rich-data");
+                        const success = await this.handler.saveColumn(location, column);
+                        if (!success) {
+                            this.columnDatatool.markAsNotStored();
+                            throw new Error(`Rich data could not store column at ${location.toString()}`);
+                        }
+                    }
+                }
+                this.handler.setDataType("world-data");
+            }
+            catch (error) {
+                console.error(`Problem storing column at ${location.toString()}`);
+                console.error(error);
+            }
+        }
+    }
+    async loadColumn(location) {
+        this.handler.setDataType("world-data");
+        try {
+            WorldRegister.instance.setDimension(location[0]);
+            if (WorldRegister.instance.column.get(location[1], location[2], location[3]))
+                return true;
+            this.handler.setDataType("world-data");
+            const column = await this.handler.getColumn(location);
+            const data = await this.seralizer.deSerializeColumnAsync(column);
+            DivineVoxelEngineWorld.instance.tasks.loadColumn(location, data);
+            if (this.richData._enabled && this.columnDatatool.hasRichData()) {
+                this.handler.setDataType("rich-data");
+                const richColumn = await this.handler.getColumn(location);
+                if (!richColumn)
+                    return false;
+                await this.richData.setLocation(location).setColumnAsync(richColumn);
+            }
+            this.handler.setDataType("world-data");
+            return true;
+        }
+        catch (error) {
+            console.error(`Problem loading column at ${location.toString()}`);
+            console.error(error);
+            return false;
+        }
+    }
+    async unLoadColumn(location) {
+        this.handler.setDataType("world-data");
+        if (this.columnDatatool.setLocation(location).loadIn()) {
+            try {
+                if (!this.columnDatatool.isStored()) {
+                    await this.saveColumn(location);
+                }
+                if (this.richData._enabled &&
+                    (await this.richData.setLocation(location).columnHasDataAsync())) {
+                    await this.richData.removeColumnAsync();
+                }
+                this.handler.setDataType("world-data");
+                DivineVoxelEngineWorld.instance.tasks.unLoadColumn(location);
+            }
+            catch (error) {
+                console.error(`Problem storing column at ${location.toString()}`);
+                console.error(error);
+            }
+        }
+        else {
+            return true;
+        }
+    }
+    async setPath(id) {
+        this.handler.setDataType("world-data");
+        try {
+            await this.handler.setPath(id);
+            return true;
+        }
+        catch (error) {
+            console.error(`Problem setting path to ${id}`);
+            console.error(error);
+            return false;
+        }
+    }
+    async columnExists(location) {
+        this.handler.setDataType("world-data");
+        try {
+            WorldRegister.instance.setDimension(location[0]);
+            if (WorldRegister.instance.column.get(location[1], location[2], location[3]))
+                return true;
+            return await this.handler.columnExists(location);
+        }
+        catch (error) {
+            console.error(`Problem checking if column exists at ${location.toString()}`);
+            console.error(error);
+            return false;
+        }
+    }
+    async columnExistsBatch(location) {
+        this.handler.setDataType("world-data");
+        try {
+            return await this.handler.columnExistsBatch(location);
+        }
+        catch (error) {
+            console.error(`Problem checking if column batch exists at ${location.toString()}`);
+            console.error(error);
+            return false;
+        }
+    }
+    async columnTimestamp(location) {
+        this.handler.setDataType("world-data");
+        try {
+            return await this.handler.columnTimestamp(location);
+        }
+        catch (error) {
+            console.error(`Problem getting column timestamp at ${location.toString()}`);
+            console.error(error);
+            return 0;
+        }
+    }
+}
+DataHooks.settingsSynced.subscribe("data-handler-wrapper", (data) => {
+    DataHanlderWrapper.mode = data.data.mode;
+});

package/DataLoader/World/DataLoaderTasks.d.ts

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

package/DataLoader/World/DataLoaderTasks.js

@@ -0,0 +1,70 @@
+import { Threads } from "@amodx/threads/";
+import { WorldRegister } from "../../Data/World/WorldRegister.js";
+import { SafeInterval } from "@amodx/core/Intervals/SafeInterval.js";
+import { DivineVoxelEngineConstructor } from "../../Contexts/Constructor/DivineVoxelEngineConstructor.js";
+export default function (DVEDL) {
+    const DataHanlderWrapper = DVEDL.dataHandler;
+    Threads.registerTasks("load-region-header", async (data, onDone) => {
+        const success = await DataHanlderWrapper.loadRegionHeader(data);
+        return onDone ? onDone(success) : false;
+    }, "deferred");
+    Threads.registerTasks("save-column", async (data, onDone) => {
+        await DataHanlderWrapper.saveColumn(data);
+        return onDone ? onDone() : false;
+    }, "deferred");
+    Threads.registerTasks("load-column", async (location, onDone) => {
+        WorldRegister.instance.setDimension(location[0]);
+        if (WorldRegister.instance.column.get(location[1], location[2], location[3])) {
+            if (onDone) {
+                onDone();
+            }
+            return;
+        }
+        await DataHanlderWrapper.loadColumn(location);
+        const inte = new SafeInterval().setInterval(1).setOnRun(() => {
+            if (WorldRegister.instance.column.get(location[1], location[2], location[3])) {
+                onDone ? onDone(true) : false;
+                inte.stop();
+            }
+        });
+        inte.start();
+    }, "deferred");
+    Threads.registerTasks("unload-column", async (location, onDone) => {
+        WorldRegister.instance.setDimension(location[0]);
+        if (!WorldRegister.instance.column.get(location[1], location[2], location[3])) {
+            if (onDone)
+                onDone();
+            return;
+        }
+        await DataHanlderWrapper.unLoadColumn(location);
+        DivineVoxelEngineConstructor.instance.threads.world.runPromiseTasks("unload-column", location, [], () => {
+            if (onDone)
+                onDone();
+        });
+    }, "deferred");
+    Threads.registerTasks("set-path", async (data, onDone) => {
+        await DataHanlderWrapper.setPath(data[0]);
+        return onDone ? onDone() : false;
+    }, "deferred");
+    Threads.registerTasks("column-exists", async (location, onDone) => {
+        WorldRegister.instance.setDimension(location[0]);
+        if (WorldRegister.instance.column.get(location[1], location[2], location[3])) {
+            if (onDone) {
+                onDone();
+            }
+            return false;
+        }
+        const exists = await DataHanlderWrapper.columnExists(location);
+        if (onDone) {
+            onDone(exists);
+        }
+        return false;
+    }, "deferred");
+    Threads.registerTasks("column-timestamp", async (data, onDone) => {
+        const time = await DataHanlderWrapper.columnTimestamp(data);
+        if (onDone) {
+            onDone(time);
+        }
+        return 0;
+    }, "deferred");
+}

package/DataLoader/World/DivineVoxelEngineDataLoaderWorld.d.ts

@@ -0,0 +1,12 @@
+import { DataHanlderWrapper } from "./DataHandlerWrapper.js";
+import { DVEDataHandler } from "../../Interfaces/DataLoader/DVEDataHandler.js";
+export type DivineVoxelEngineDataLoaderWorldInitData = {
+    dataHanlder: DVEDataHandler;
+};
+export declare class DivineVoxelEngineDataLoaderWorld {
+    static instance: DivineVoxelEngineDataLoaderWorld;
+    environment: "node" | "browser";
+    dataHandler: DataHanlderWrapper;
+    constructor(data: DivineVoxelEngineDataLoaderWorldInitData);
+    init(): Promise<void>;
+}

package/DataLoader/World/DivineVoxelEngineDataLoaderWorld.js

@@ -0,0 +1,17 @@
+//functions
+import DataLoaderTasks from './DataLoaderTasks';
+import { DataHanlderWrapper } from "./DataHandlerWrapper.js";
+export class DivineVoxelEngineDataLoaderWorld {
+    static instance;
+    environment = "browser";
+    dataHandler = new DataHanlderWrapper();
+    constructor(data) {
+        if (DivineVoxelEngineDataLoaderWorld.instance)
+            return DivineVoxelEngineDataLoaderWorld.instance;
+        DivineVoxelEngineDataLoaderWorld.instance = this;
+        this.dataHandler.init(data.dataHanlder);
+    }
+    async init() {
+        DataLoaderTasks(this);
+    }
+}

package/DataLoader/World/Tools/DataLoaderTool.d.ts

@@ -0,0 +1,24 @@
+import type { LocationData } from "../../../Math";
+import { ColumnDataTool } from "../../../Tools/Data/WorldData/ColumnDataTool.js";
+export declare class DataLoaderTool {
+    static columnDataTool: ColumnDataTool;
+    dimension: string;
+    mode: "indexdb" | "server" | "both";
+    _enabled: boolean;
+    constructor();
+    setDimension(dimension: string): void;
+    isEnabled(): boolean;
+    saveColumnIfNotStored(location: LocationData): Promise<boolean>;
+    loadIfExists(location: LocationData): Promise<boolean>;
+    saveColumn(location: LocationData): Promise<void>;
+    loadColumn(location: LocationData): Promise<void>;
+    unLoadColumn(location: LocationData): Promise<false | undefined>;
+    columnExists(location: LocationData): Promise<boolean>;
+    columnExistsBatch(location: LocationData[]): Promise<false | Record<string, boolean>>;
+    columnTimestamp(location: LocationData): Promise<number>;
+    unLoadAllOutsideRadius([, sx, , sz]: LocationData, radius: number, run?: (column: ColumnDataTool) => boolean): Promise<void>;
+    unLoadAllColumns(onDone?: Function): Promise<void>;
+    allColumns(run: (column: ColumnDataTool, location: LocationData) => void): void;
+    allColumnsAsync(run: (column: ColumnDataTool) => Promise<void>): Promise<void>;
+    getAllUnStoredColumns(run: (dimension: string, x: number, y: number, z: number) => void): void;
+}

package/DataLoader/World/Tools/DataLoaderTool.js

@@ -0,0 +1,113 @@
+import { ColumnDataTool } from "../../../Tools/Data/WorldData/ColumnDataTool.js";
+import { WorldRegister } from "../../../Data/World/WorldRegister.js";
+import { Distance3D } from "@amodx/math/Vectors/Functions/Distance3d";
+import { EngineSettings } from "../../../Data/Settings/EngineSettings.js";
+import { DataHooks } from "../../../Data/DataHooks.js";
+import { WorldLock } from "../../../Contexts/World/Lock/WorldLock.js";
+import { DataHanlderWrapper } from "../DataHandlerWrapper.js";
+export class DataLoaderTool {
+    static columnDataTool = new ColumnDataTool();
+    dimension = "main";
+    mode = "server";
+    _enabled = typeof DataHanlderWrapper.instance !== "undefined";
+    constructor() {
+        this.mode = EngineSettings.settings.data.mode;
+        DataHooks.settingsSynced.subscribe("data-loader", (data) => {
+            this.mode = data.data.mode;
+        });
+    }
+    setDimension(dimension) {
+        this.dimension = dimension;
+    }
+    isEnabled() {
+        return !(typeof DataHanlderWrapper.instance?.columnExists === "undefined");
+    }
+    async saveColumnIfNotStored(location) {
+        if (!DataLoaderTool.columnDataTool.setLocation(location).loadIn())
+            return false;
+        if (DataLoaderTool.columnDataTool.isStored())
+            return false;
+        await this.saveColumn(location);
+        return true;
+    }
+    async loadIfExists(location) {
+        const exists = await this.columnExists(location);
+        if (exists) {
+            await this.loadColumn(location);
+        }
+        return false;
+    }
+    async saveColumn(location) {
+        await DataHanlderWrapper.instance.saveColumn(location);
+    }
+    async loadColumn(location) {
+        await DataHanlderWrapper.instance.loadColumn(location);
+    }
+    async unLoadColumn(location) {
+        WorldRegister.instance.setDimension(location[0]);
+        if (WorldLock.isLocked(location) ||
+            !WorldRegister.instance.column.get(location[1], location[2], location[3]))
+            return false;
+        await DataHanlderWrapper.instance.unLoadColumn(location);
+    }
+    async columnExists(location) {
+        return await DataHanlderWrapper.instance.columnExists(location);
+    }
+    async columnExistsBatch(location) {
+        return await DataHanlderWrapper.instance.columnExistsBatch(location);
+    }
+    async columnTimestamp(location) {
+        return await DataHanlderWrapper.instance.columnTimestamp(location);
+    }
+    async unLoadAllOutsideRadius([, sx, , sz], radius, run = (columntool) => true) {
+        const proms = [];
+        this.allColumns((column, location) => {
+            const distnace = Distance3D(location[1], 0, location[3], sx, 0, sz);
+            if (distnace > radius) {
+                if (!run(column))
+                    return;
+                proms.push(this.unLoadColumn(location));
+            }
+        });
+        await Promise.all(proms);
+    }
+    async unLoadAllColumns(onDone) {
+        const proms = [];
+        this.allColumns((column, location) => {
+            proms.push(this.unLoadColumn(location));
+        });
+        await Promise.all(proms);
+    }
+    allColumns(run) {
+        const dim = WorldRegister.instance.dimensions.get(this.dimension);
+        if (!dim)
+            return;
+        for (const [key, region] of dim.regions) {
+            for (const [index, column] of region.columns) {
+                DataLoaderTool.columnDataTool.setColumn(column);
+                run(DataLoaderTool.columnDataTool, [
+                    this.dimension,
+                    ...region.getColumnPosition(index)
+                ]);
+            }
+        }
+    }
+    async allColumnsAsync(run) {
+        const dim = WorldRegister.instance.dimensions.get(this.dimension);
+        if (!dim)
+            return;
+        for (const [key, region] of dim.regions) {
+            for (const column of region.getColumns()) {
+                DataLoaderTool.columnDataTool.setColumn(column);
+                await run(DataLoaderTool.columnDataTool);
+            }
+        }
+    }
+    getAllUnStoredColumns(run) {
+        this.allColumns((column, location) => {
+            if (!column.isStored()) {
+                run(...location);
+            }
+        });
+    }
+}

package/DataLoader/World/Tools/DataSerializerTool.d.ts

@@ -0,0 +1,8 @@
+import { LocationData } from "../../../Math";
+import { ColumnData } from "Data/World/Classes";
+export declare class DataSerializerTool {
+    serializeColumn(location: LocationData, onDone: (buffer: ArrayBuffer | false) => void): void;
+    serializeColumnAsync(location: LocationData): Promise<false | ArrayBuffer>;
+    deSerializeColumn(column: ArrayBuffer, onDone: (columnData: ColumnData) => void): void;
+    deSerializeColumnAsync(column: ArrayBuffer): Promise<ColumnData>;
+}