@divinevoxel/vlox 0.0.0

package/Data/World/WorldRegister.js

@@ -0,0 +1,220 @@
+import { DataHooks } from "../../Data/DataHooks.js";
+import { Chunk, Column, Dimension, Region, } from "./Classes/";
+import { WorldBounds } from "../../Data/World/WorldBounds.js";
+import { DimensionsRegister } from "./DimensionsRegister.js";
+import { WorldSpaces } from "../../Data/World/WorldSpaces.js";
+import { ColumnDataTool } from "../../Tools/Data/WorldData/ColumnDataTool.js";
+import { RegionDataTool } from "../../Tools/Data/WorldData/RegionDataTool.js";
+import { WorldRegisterCache } from "./WorldRegisterCache.js";
+class WorldRegisterDimensions {
+    _register;
+    constructor(_register) {
+        this._register = _register;
+    }
+    add(id) {
+        id = this._register._dimensionRegister.getDimensionStringId(id);
+        const dimesnion = Dimension.CreateNew(id);
+        this._register._dimensions.set(id, dimesnion);
+        return dimesnion;
+    }
+    get(id) {
+        id = this._register._dimensionRegister.getDimensionStringId(id);
+        return this._register._dimensions.get(id);
+    }
+}
+class WorldRegisterRegions {
+    _register;
+    constructor(_register) {
+        this._register = _register;
+    }
+    add(x, y, z, region) {
+        let dimension = this._register.dimensions.get(this._register._currentDimension);
+        if (!dimension) {
+            dimension = this._register.dimensions.add(this._register._currentDimension);
+        }
+        const newRegion = Region.toObject(region);
+        const regionPOS = WorldSpaces.region.getPositionXYZ(x, y, z);
+        this._register.regionTool.setRegion(newRegion);
+        this._register.regionTool.setPositionData(regionPOS.x, regionPOS.y, regionPOS.z);
+        dimension.set(WorldSpaces.region.getKeyXYZ(x, y, z), newRegion);
+        return newRegion;
+    }
+    get(x, y, z) {
+        const dimension = this._register.dimensions.get(this._register._currentDimension);
+        if (!dimension)
+            return false;
+        const region = dimension.get(WorldSpaces.region.getKeyXYZ(x, y, z));
+        if (!region)
+            return false;
+        return region;
+    }
+    remove(x, y, z) {
+        const dimension = this._register.dimensions.get(this._register._currentDimension);
+        if (!dimension)
+            return false;
+        const key = WorldSpaces.region.getKeyXYZ(x, y, z);
+        const region = dimension.get(key);
+        if (!region)
+            return false;
+        dimension.delete(key);
+        return true;
+    }
+}
+class WorldRegisterColumns {
+    _register;
+    constructor(_register) {
+        this._register = _register;
+    }
+    add(x, y, z, column) {
+        let region = this._register.region.get(x, y, z);
+        if (!region) {
+            let newRegion = DataHooks.region.onGetSync.pipe({
+                location: [this._register._currentDimension, x, y, z],
+                region: null,
+            });
+            if (!newRegion.region)
+                return;
+            region = this._register.region.add(x, y, z, newRegion.region);
+            DataHooks.region.onNew.notify([
+                this._register._currentDimension,
+                x,
+                y,
+                z,
+            ]);
+        }
+        const newColumn = Column.toObject(column);
+        region.columns.set(region.getColumnIndex(x, y, z), newColumn);
+        return newColumn;
+    }
+    get(x, y, z) {
+        const columnKey = this._register.cache.getColumnIndex(x, y, z);
+        let addColumn = false;
+        if (this._register._cacheOn) {
+            const column = this._register.cache.getColumn(columnKey);
+            if (column)
+                return column;
+            addColumn = true;
+        }
+        const region = this._register.region.get(x, y, z);
+        if (!region)
+            return false;
+        const column = region.columns.get(WorldSpaces.column.getIndexXYZ(x, y, z));
+        if (!column)
+            return false;
+        if (addColumn) {
+            this._register.cache.addColumn(columnKey, column);
+        }
+        return column;
+    }
+    remove(x, y, z) {
+        const region = this._register.region.get(x, y, z);
+        if (!region)
+            return false;
+        const index = WorldSpaces.column.getIndexXYZ(x, y, z);
+        const column = region.columns.get(index);
+        if (!column)
+            return false;
+        region.columns.delete(index);
+        return true;
+    }
+    fill(x, y, z) {
+        for (let cy = WorldBounds.bounds.MinY; cy < WorldBounds.bounds.MaxY; cy += WorldSpaces.chunk._bounds.y) {
+            let y = cy;
+            if (!this._register.chunk.get(x, y, z)) {
+                const newChunk = DataHooks.chunk.onGetSync.pipe({
+                    location: [this._register._currentDimension, x, y, z],
+                    chunk: null,
+                });
+                if (!newChunk.chunk)
+                    continue;
+                this._register.chunk.add(x, y, z, newChunk.chunk);
+            }
+        }
+    }
+}
+class WorldRegisterChunks {
+    _register;
+    constructor(_register) {
+        this._register = _register;
+    }
+    add(x, y, z, chunk) {
+        let column = this._register.column.get(x, y, z);
+        if (!column) {
+            let newColumn = DataHooks.column.onGetSync.pipe({
+                location: [this._register._currentDimension, x, y, z],
+                column: null,
+            });
+            if (!newColumn.column)
+                return;
+            column = this._register.column.add(x, y, z, newColumn.column);
+            DataHooks.column.onNew.notify([
+                this._register._currentDimension,
+                x,
+                y,
+                z,
+            ]);
+        }
+        if (!column)
+            return;
+        const newChunk = Chunk.toObject(chunk);
+        column.chunks[WorldSpaces.chunk.getIndexXYZ(x, y, z)] = newChunk;
+        DataHooks.chunk.onNew.notify([this._register._currentDimension, x, y, z]);
+        return newChunk;
+    }
+    get(x, y, z) {
+        const chunkKey = this._register.cache.getChunkIndex(x, y, z);
+        let addChunk = false;
+        if (this._register._cacheOn) {
+            const chunk = this._register.cache.getChunk(chunkKey);
+            if (chunk)
+                return chunk;
+            addChunk = true;
+        }
+        const column = this._register.column.get(x, y, z);
+        if (!column)
+            return false;
+        const chunk = column.chunks[WorldSpaces.chunk.getIndexXYZ(x, y, z)];
+        if (!chunk)
+            return;
+        if (addChunk) {
+            this._register.cache.addChunk(chunkKey, chunk);
+        }
+        return chunk;
+    }
+    remove(x, y, z) {
+        const column = this._register.column.get(x, y, z);
+        if (!column)
+            return false;
+        const index = WorldSpaces.chunk.getIndexXYZ(x, y, z);
+        const chunk = column.chunks[index];
+        if (!chunk)
+            return false;
+        delete column.chunks[index];
+        return true;
+    }
+}
+export class WorldRegister {
+    static instance;
+    columnTool = new ColumnDataTool();
+    regionTool = new RegionDataTool();
+    _dimensions = new Map();
+    _cacheOn = false;
+    _dimensionRegister = new DimensionsRegister();
+    constructor() {
+        if (WorldRegister.instance)
+            return WorldRegister.instance;
+        WorldRegister.instance = this;
+    }
+    cache = new WorldRegisterCache();
+    dimensions = new WorldRegisterDimensions(this);
+    region = new WorldRegisterRegions(this);
+    column = new WorldRegisterColumns(this);
+    chunk = new WorldRegisterChunks(this);
+    _currentDimension = "main";
+    setDimension(dimension) {
+        this._currentDimension = dimension;
+    }
+    clearAll() {
+        this._dimensions.clear();
+    }
+}

package/Data/World/WorldRegisterCache.d.ts

@@ -0,0 +1,23 @@
+import { Chunk, Column } from "./Classes/index.js";
+import { Vector3Like } from "@amodx/math";
+export declare class WorldRegisterCache {
+    _cacheOn: boolean;
+    _chunkCache: Chunk[];
+    _columnCache: Column[];
+    worldSize: Vector3Like;
+    chunkSize: Vector3Like;
+    chunkSizePower: Vector3Like;
+    columnSize: Vector3Like;
+    columnSizePower: Vector3Like;
+    constructor();
+    symcSettings(): void;
+    enable(): void;
+    disable(): void;
+    addChunk(key: number, data: Chunk): void;
+    addColumn(key: number, data: Column): void;
+    getChunk(key: number): Chunk;
+    getColumn(key: number): Column;
+    getChunkIndex(x: number, y: number, z: number): number;
+    getColumnIndex(x: number, y: number, z: number): number;
+    clear(): void;
+}

package/Data/World/WorldRegisterCache.js

@@ -0,0 +1,68 @@
+import { WorldBounds } from "../../Data/World/WorldBounds.js";
+import { Vector3Like } from "@amodx/math";
+import { EngineSettings } from "../../Data/Settings/EngineSettings.js";
+export class WorldRegisterCache {
+    _cacheOn = false;
+    _chunkCache = [];
+    _columnCache = [];
+    worldSize = Vector3Like.Create();
+    chunkSize = Vector3Like.Create();
+    chunkSizePower = Vector3Like.Create();
+    columnSize = Vector3Like.Create();
+    columnSizePower = Vector3Like.Create();
+    constructor() {
+        this.symcSettings();
+        EngineSettings.observers.updated.subscribe("WorldRegisterCache", () => {
+            this.symcSettings();
+        });
+    }
+    symcSettings() {
+        const size = WorldBounds.getWorldDimensions();
+        this.chunkSize.x = 2 ** EngineSettings.settings.chunks.chunkXPow2;
+        this.chunkSize.y = 2 ** EngineSettings.settings.chunks.chunkYPow2;
+        this.chunkSize.z = 2 ** EngineSettings.settings.chunks.chunkZPow2;
+        this.chunkSizePower = Vector3Like.Create(EngineSettings.settings.chunks.chunkXPow2 - 1, EngineSettings.settings.chunks.chunkYPow2 - 1, EngineSettings.settings.chunks.chunkZPow2 - 1);
+        this.columnSizePower = Vector3Like.Create(EngineSettings.settings.chunks.chunkXPow2 - 1, EngineSettings.settings.regions.regionYPow2 - 1, EngineSettings.settings.chunks.chunkZPow2 - 1);
+        this.worldSize = Vector3Like.Create(size.width, size.height, size.depth);
+        this.columnSize.x = 2 ** EngineSettings.settings.chunks.chunkXPow2;
+        this.columnSize.y = 2 ** EngineSettings.settings.regions.regionYPow2;
+        this.columnSize.z = 2 ** EngineSettings.settings.chunks.chunkZPow2;
+    }
+    enable() {
+        this._cacheOn = true;
+        this._chunkCache.length = 0;
+        this._columnCache.length = 0;
+    }
+    disable() {
+        this._cacheOn = false;
+        this._chunkCache.length = 0;
+        this._columnCache.length = 0;
+    }
+    addChunk(key, data) {
+        this._chunkCache[key] = data;
+    }
+    addColumn(key, data) {
+        this._columnCache[key] = data;
+    }
+    getChunk(key) {
+        return this._chunkCache[key];
+    }
+    getColumn(key) {
+        return this._columnCache[key];
+    }
+    getChunkIndex(x, y, z) {
+        return Vector3Like.HashXYZ(((x >> this.chunkSizePower.x) << this.chunkSizePower.x) /
+            this.chunkSize.x, ((y >> this.chunkSizePower.y) << this.chunkSizePower.y) /
+            this.chunkSize.y, ((z >> this.chunkSizePower.z) << this.chunkSizePower.z) / this.chunkSize.z);
+    }
+    getColumnIndex(x, y, z) {
+        return Vector3Like.HashXYZ(((x >> this.columnSizePower.x) << this.columnSizePower.x) /
+            this.columnSize.x, ((y >> this.columnSizePower.y) << this.columnSizePower.y) /
+            this.columnSize.y, ((z >> this.columnSizePower.z) << this.columnSizePower.z) /
+            this.columnSize.z);
+    }
+    clear() {
+        this._chunkCache.length = 0;
+        this._columnCache.length = 0;
+    }
+}

package/Data/World/WorldSpaces.d.ts

@@ -0,0 +1,4 @@
+import { VoxelSpaces } from "../../Math/Spaces/VoxelSpaces.js";
+import type { EngineSettingsData } from "../../Types/EngineSettings.types.js";
+export declare const WorldSpaces: VoxelSpaces;
+export declare function InitWorldSpaces(settings: EngineSettingsData): void;

package/Data/World/WorldSpaces.js

@@ -0,0 +1,23 @@
+//types
+import { VoxelSpaces } from "../../Math/Spaces/VoxelSpaces.js";
+//Objects
+export const WorldSpaces = new VoxelSpaces();
+export function InitWorldSpaces(settings) {
+    WorldSpaces.setDimensions({
+        regions: {
+            x: settings.regions.regionXPow2,
+            y: settings.regions.regionYPow2,
+            z: settings.regions.regionZPow2,
+        },
+        columns: {
+            x: settings.chunks.chunkXPow2,
+            y: settings.regions.regionYPow2,
+            z: settings.chunks.chunkZPow2,
+        },
+        chunks: {
+            x: settings.chunks.chunkXPow2,
+            y: settings.chunks.chunkYPow2,
+            z: settings.chunks.chunkZPow2,
+        },
+    });
+}

package/DataLoader/Broswer/DataHandler.d.ts

@@ -0,0 +1,20 @@
+import { WorldDataTool } from "./WorldDataTool";
+import { LocationData } from "../../Math";
+import { DVEDataHandler } from "../../Interfaces/DataLoader/DVEDataHandler";
+import { WorldDataBase } from "./WorldDataBase";
+export declare class DefaultDataHandler extends DVEDataHandler {
+    static instance: DefaultDataHandler;
+    worldDataTool: WorldDataTool;
+    worldData: WorldDataBase;
+    constructor();
+    init(): Promise<void>;
+    openWorldDataBae(id: string, dimension?: string): Promise<void>;
+    getRegionHeader(location: LocationData): Promise<ArrayBuffer>;
+    getColumn(location: LocationData): Promise<ArrayBufferLike>;
+    saveColumn(location: LocationData, buffer: ArrayBuffer): Promise<boolean>;
+    setPath(id: string): Promise<boolean>;
+    columnExists(location: LocationData): Promise<boolean>;
+    columnExistsBatch(location: LocationData[]): Promise<Record<string, boolean>>;
+    columnTimestamp(location: LocationData): Promise<number>;
+    columnHasSegment(location: LocationData, segment: "rich-data" | "dbo" | "entities"): Promise<boolean>;
+}

package/DataLoader/Broswer/DataHandler.js

@@ -0,0 +1,54 @@
+import { DVEDataHandler } from "../../Interfaces/DataLoader/DVEDataHandler";
+import { WorldDataBaseManager } from "./WorldDataBaseManager";
+export class DefaultDataHandler extends DVEDataHandler {
+    static instance;
+    worldDataTool;
+    worldData;
+    constructor() {
+        super();
+        if (DefaultDataHandler.instance)
+            return DefaultDataHandler.instance;
+        DefaultDataHandler.instance = this;
+    }
+    async init() {
+        await WorldDataBaseManager.init();
+    }
+    async openWorldDataBae(id, dimension = "main") {
+        const worldDataBase = await WorldDataBaseManager.getWorldDataBase(id);
+        await worldDataBase.setDimension(dimension);
+        this.worldData = worldDataBase;
+        this.worldDataTool = worldDataBase.worldDataTool;
+    }
+    async getRegionHeader(location) {
+        this.worldDataTool.setType(this.dataType);
+        return await this.worldDataTool.loadRegionHeader(location);
+    }
+    async getColumn(location) {
+        this.worldDataTool.setType(this.dataType);
+        return await this.worldDataTool.loadColumn(location);
+    }
+    async saveColumn(location, buffer) {
+        this.worldDataTool.setType(this.dataType);
+        return await this.worldDataTool.saveColumn(location, buffer);
+    }
+    async setPath(id) {
+        this.worldDataTool.setType(this.dataType);
+        return this.worldDataTool.setPath(id);
+    }
+    async columnExists(location) {
+        this.worldDataTool.setType(this.dataType);
+        return await this.worldDataTool.columnExists(location);
+    }
+    async columnExistsBatch(location) {
+        this.worldDataTool.setType(this.dataType);
+        return await this.worldDataTool.columnExistsBatch(location);
+    }
+    async columnTimestamp(location) {
+        this.worldDataTool.setType(this.dataType);
+        return await this.worldDataTool.columnTimestamp(location);
+    }
+    async columnHasSegment(location, segment) {
+        this.worldDataTool.setType(segment);
+        return await this.worldDataTool.columnExists(location);
+    }
+}

package/DataLoader/Broswer/WorldDataBase.d.ts

@@ -0,0 +1,26 @@
+import type { DataBase, ObjectStore } from "@amodx/indexdb/";
+import type { DVEDDataTypes } from "../Types/DVED.types";
+import { WorldDataTool } from "./WorldDataTool";
+export declare class WorldDataBase {
+    database: DataBase;
+    dimension: string;
+    typeStores: Record<DVEDDataTypes, ObjectStore<any>>;
+    worldDataTool: WorldDataTool;
+    constructor(database: DataBase);
+    setDimension(dimensionId: string): Promise<void>;
+    regionHeader: {
+        set: (key: string, type: DVEDDataTypes, data: ArrayBuffer) => Promise<void>;
+        get: (key: string, type: DVEDDataTypes) => Promise<ArrayBuffer | false>;
+        getKey(key: string, type: DVEDDataTypes): string;
+    };
+    column: {
+        set: (key: string, type: DVEDDataTypes, data: ArrayBuffer) => Promise<void>;
+        get: (key: string, type: DVEDDataTypes) => Promise<false | ArrayBuffer>;
+        getKey(key: string, type: DVEDDataTypes): string;
+    };
+    columnTimestamp: {
+        set: (key: string, type: DVEDDataTypes, timeStamp: number) => Promise<void>;
+        get: (key: string, type: DVEDDataTypes) => Promise<number | false>;
+        getKey: (key: string, type: DVEDDataTypes) => string;
+    };
+}

package/DataLoader/Broswer/WorldDataBase.js

@@ -0,0 +1,81 @@
+import { WorldDataTool } from "./WorldDataTool";
+export class WorldDataBase {
+    database;
+    dimension = "";
+    typeStores;
+    worldDataTool;
+    constructor(database) {
+        this.database = database;
+        this.worldDataTool = new WorldDataTool(this);
+    }
+    async setDimension(dimensionId) {
+        if (this.dimension != dimensionId) {
+            const worldDataId = `${dimensionId}-world-data`;
+            const richDataId = `${dimensionId}-rich-data`;
+            const entitiesId = `${dimensionId}-entities`;
+            const dboId = `${dimensionId}-dbo`;
+            this.database.close();
+            await this.database.addObjectStore({
+                name: worldDataId,
+                schema: [],
+            }, {
+                name: richDataId,
+                schema: [],
+            }, {
+                name: entitiesId,
+                schema: [],
+            }, {
+                name: dboId,
+                schema: [],
+            });
+            this.typeStores = {};
+            this.typeStores["world-data"] = await this.database.getObjectStore(worldDataId);
+            this.typeStores["rich-data"] = await this.database.getObjectStore(richDataId);
+            this.typeStores["entities"] = await this.database.getObjectStore(entitiesId);
+            this.typeStores["dbo"] = await this.database.getObjectStore(dboId);
+        }
+        this.dimension = dimensionId;
+    }
+    regionHeader = {
+        set: async (key, type, data) => {
+            await this.typeStores[type].set(this.regionHeader.getKey(key, type), data);
+        },
+        get: async (key, type) => {
+            const buffer = (await this.typeStores[type].get(this.regionHeader.getKey(key, type)));
+            if (!buffer)
+                return false;
+            return buffer;
+        },
+        getKey(key, type) {
+            return `${key}_${type}_region_header`;
+        },
+    };
+    column = {
+        set: async (key, type, data) => {
+            await this.typeStores[type].set(this.column.getKey(key, type), data);
+        },
+        get: async (key, type) => {
+            const buffer = (await this.typeStores[type].get(this.column.getKey(key, type)));
+            if (!buffer)
+                return false;
+            return await buffer;
+        },
+        getKey(key, type) {
+            return `${key}_${type}_column`;
+        },
+    };
+    columnTimestamp = {
+        set: async (key, type, timeStamp) => {
+            await this.typeStores[type].set(this.columnTimestamp.getKey(key, type), timeStamp);
+        },
+        get: async (key, type) => {
+            const timeStamp = (await this.typeStores[type].get(this.columnTimestamp.getKey(key, type)));
+            if (!timeStamp)
+                return false;
+            return Number(timeStamp);
+        },
+        getKey: (key, type) => {
+            return `${key}_${type}_column_timestamp`;
+        },
+    };
+}

package/DataLoader/Broswer/WorldDataBaseManager.d.ts

@@ -0,0 +1,6 @@
+import { WorldDataBase } from "./WorldDataBase";
+export declare class WorldDataBaseManager {
+    static init(): Promise<void>;
+    static getWorldDataBase(dbName: string, dimension?: string): Promise<WorldDataBase>;
+    static deleteWorldDataBase(dbName: string): Promise<void>;
+}

package/DataLoader/Broswer/WorldDataBaseManager.js

@@ -0,0 +1,30 @@
+import { IndexDB } from "@amodx/indexdb/";
+import { WorldDataBase } from "./WorldDataBase";
+export class WorldDataBaseManager {
+    static async init() {
+        await IndexDB.init();
+    }
+    static async getWorldDataBase(dbName, dimension = "main") {
+        let db;
+        const existanceCheck = await IndexDB.databaseExists(dbName);
+        if (!existanceCheck) {
+            db = await IndexDB.createDatabase({
+                databaseName: dbName,
+                objectStores: [
+                    {
+                        name: "world-meta",
+                        schema: [],
+                    },
+                ],
+            });
+            return new WorldDataBase(db);
+        }
+        else {
+            db = await IndexDB.getDatabase(dbName);
+            return new WorldDataBase(db);
+        }
+    }
+    static async deleteWorldDataBase(dbName) {
+        await IndexDB.deleteDatabase(dbName);
+    }
+}

package/DataLoader/Broswer/WorldDataTool.d.ts

@@ -0,0 +1,16 @@
+import { WorldDataBase } from "./WorldDataBase";
+import { LocationData } from "../../Math";
+import { DataLoaderSegments } from "Interfaces/DataLoader/DVEDataHandler";
+export declare class WorldDataTool {
+    worldDataBase: WorldDataBase;
+    setPath(id: string): Promise<boolean>;
+    constructor(worldDataBase: WorldDataBase);
+    dataType: DataLoaderSegments;
+    setType(data: DataLoaderSegments): void;
+    columnExists(location: LocationData): Promise<boolean>;
+    columnExistsBatch(locations: LocationData[]): Promise<Record<string, boolean>>;
+    columnTimestamp(location: LocationData): Promise<number>;
+    loadRegionHeader(location: LocationData): Promise<ArrayBuffer>;
+    loadColumn(location: LocationData): Promise<ArrayBufferLike>;
+    saveColumn(location: LocationData, buffer: ArrayBuffer): Promise<boolean>;
+}

package/DataLoader/Broswer/WorldDataTool.js

@@ -0,0 +1,64 @@
+import { WorldSpaces } from "../../Data/World/WorldSpaces";
+import { Compressor } from "@amodx/core/Compression/Compression";
+export class WorldDataTool {
+    worldDataBase;
+    async setPath(id) {
+        return true;
+    }
+    constructor(worldDataBase) {
+        this.worldDataBase = worldDataBase;
+    }
+    dataType = "world-data";
+    setType(data) {
+        this.dataType = data;
+    }
+    async columnExists(location) {
+        await this.worldDataBase.setDimension(location[0]);
+        return (await this.columnTimestamp(location)) > 0;
+    }
+    async columnExistsBatch(locations) {
+        await this.worldDataBase.setDimension(locations[0][0]);
+        const existsRecord = {};
+        const transication = await this.worldDataBase.database.getTransaction("readonly", this.worldDataBase.typeStores["world-data"].id);
+        const proms = [];
+        const keys = [];
+        for (const location of locations) {
+            const key = location.toString();
+            keys.push(key);
+            proms.push(transication.get(this.worldDataBase.columnTimestamp.getKey(WorldSpaces.column.getKeyXYZ(location[1], location[2], location[3]), this.dataType)));
+        }
+        const resolved = await Promise.all(proms);
+        for (let i = 0; i < keys.length; i++) {
+            existsRecord[keys[i]] = resolved[i] !== undefined;
+        }
+        return existsRecord;
+    }
+    async columnTimestamp(location) {
+        await this.worldDataBase.setDimension(location[0]);
+        const stamp = await this.worldDataBase.columnTimestamp.get(WorldSpaces.column.getKeyXYZ(location[1], location[2], location[3]), this.dataType);
+        if (!stamp)
+            return 0;
+        return stamp;
+    }
+    async loadRegionHeader(location) {
+        await this.worldDataBase.setDimension(location[0]);
+        const buffer = await this.worldDataBase.regionHeader.get(WorldSpaces.region.getKeyXYZ(location[1], location[2], location[3]), this.dataType);
+        if (!buffer)
+            return new ArrayBuffer(0);
+        return buffer;
+    }
+    async loadColumn(location) {
+        await this.worldDataBase.setDimension(location[0]);
+        const buffer = await this.worldDataBase.column.get(WorldSpaces.column.getKeyXYZ(location[1], location[2], location[3]), this.dataType);
+        if (!buffer)
+            return new ArrayBuffer(0);
+        return await (await Compressor.decompressArray(buffer, "Uint8")).buffer;
+    }
+    async saveColumn(location, buffer) {
+        const compressed = await Compressor.compressArray(new Uint8Array(buffer));
+        await this.worldDataBase.setDimension(location[0]);
+        await this.worldDataBase.column.set(WorldSpaces.column.getKeyXYZ(location[1], location[2], location[3]), this.dataType, compressed.buffer);
+        await this.worldDataBase.columnTimestamp.set(WorldSpaces.column.getKeyXYZ(location[1], location[2], location[3]), this.dataType, Date.now());
+        return true;
+    }
+}

package/DataLoader/Broswer/index.d.ts

@@ -0,0 +1 @@
+export * from "./DataHandler";

package/DataLoader/Broswer/index.js

@@ -0,0 +1 @@
+export * from "./DataHandler";

package/DataLoader/Constructor/DataLoaderTasks.d.ts

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

package/DataLoader/Constructor/DataLoaderTasks.js

@@ -0,0 +1,14 @@
+;
+import { Threads } from "@amodx/threads/";
+export default function (DVEDL) {
+    Threads.registerTasks("serialize-column", async (location, onDone) => {
+        const seralized = DVEDL.serializer.serializeColumn(location);
+        if (!seralized)
+            return onDone ? onDone(false) : false;
+        return onDone ? onDone(seralized, [seralized]) : seralized;
+    }, "deferred");
+    Threads.registerTasks("deserialize-column", async (columnData, onDone) => {
+        const deSeralized = DVEDL.serializer.deSerializeColumn(columnData);
+        return onDone ? onDone(deSeralized) : deSeralized;
+    }, "deferred");
+}