@divinevoxel/vlox 0.0.0

package/DataLoader/Constructor/DivineVoxelEngineDataLoaderConstructor.d.ts

@@ -0,0 +1,9 @@
+import { WorldDataSerializer } from "./WorldDataSerializer.js";
+export type DivineVoxelEngineDataLoaderConstructorInitData = {};
+export declare class DivineVoxelEngineDataLoaderConstructor {
+    static instance: DivineVoxelEngineDataLoaderConstructor;
+    environment: "node" | "browser";
+    serializer: WorldDataSerializer;
+    constructor(data: DivineVoxelEngineDataLoaderConstructorInitData);
+    init(): Promise<void>;
+}

package/DataLoader/Constructor/DivineVoxelEngineDataLoaderConstructor.js

@@ -0,0 +1,17 @@
+//functions
+import DataLoaderTasks from "./DataLoaderTasks.js";
+import { WorldDataSerializer } from "./WorldDataSerializer.js";
+export class DivineVoxelEngineDataLoaderConstructor {
+    static instance;
+    environment = "browser";
+    serializer;
+    constructor(data) {
+        if (DivineVoxelEngineDataLoaderConstructor.instance)
+            return DivineVoxelEngineDataLoaderConstructor.instance;
+        DivineVoxelEngineDataLoaderConstructor.instance = this;
+        this.serializer = new WorldDataSerializer();
+    }
+    async init() {
+        DataLoaderTasks(this);
+    }
+}

package/DataLoader/Constructor/WorldDataSerializer.d.ts

@@ -0,0 +1,15 @@
+import type { ColumnData } from "../../Data/World/Classes/Column.js";
+import type { LocationData } from "../../Math";
+import { RegionDataTool } from "../../Tools/Data/WorldData/RegionDataTool.js";
+import { ColumnDataTool } from "../../Tools/Data/WorldData/ColumnDataTool.js";
+import { ChunkDataTool } from "../../Tools/Data/WorldData/ChunkDataTool.js";
+export declare class WorldDataSerializer {
+    regions: RegionDataTool;
+    columns: ColumnDataTool;
+    chunks: ChunkDataTool;
+    serializeRegion(location: LocationData): false | [location: LocationData, buffer: ArrayBuffer][];
+    serializeColumn(location: LocationData): false | ArrayBuffer;
+    deSerializeRegion(regionBuffers: ArrayBuffer[] | SharedArrayBuffer[]): void;
+    deSerializeColumn(columnBuffer: ArrayBuffer | SharedArrayBuffer): ColumnData;
+    _readDataIntoBuffer(offset: number, target: Uint8Array, source: ArrayBuffer | SharedArrayBuffer, sourceOffset?: number, sourceLength?: number): number;
+}

package/DataLoader/Constructor/WorldDataSerializer.js

@@ -0,0 +1,54 @@
+//objects
+import { RegionDataTool } from "../../Tools/Data/WorldData/RegionDataTool.js";
+import { ColumnDataTool } from "../../Tools/Data/WorldData/ColumnDataTool.js";
+import { ChunkDataTool } from "../../Tools/Data/WorldData/ChunkDataTool.js";
+import { BinaryObject } from "@amodx/binary";
+export class WorldDataSerializer {
+    regions = new RegionDataTool();
+    columns = new ColumnDataTool();
+    chunks = new ChunkDataTool();
+    serializeRegion(location) {
+        if (!this.regions
+            .setDimension(location[0])
+            .loadInAt(location[1], location[2], location[3]))
+            return false;
+        const region = this.regions.getRegion();
+        const columnBuffers = [];
+        region.columns.forEach((column, index) => {
+            this.columns.setColumn(column);
+            const position = region.getColumnPosition(index);
+            const columnLocation = [location[0], ...position];
+            const columnBuffer = this.serializeColumn(columnLocation);
+            if (columnBuffer)
+                columnBuffers.push([[...columnLocation], columnBuffer]);
+        });
+        return columnBuffers;
+    }
+    serializeColumn(location) {
+        if (!this.columns.setLocation(location).loadIn())
+            return false;
+        const column = this.columns.getColumn();
+        const columnData = column.toJSON();
+        const columnArray = BinaryObject.objectToBuffer(columnData);
+        return columnArray;
+    }
+    deSerializeRegion(regionBuffers) {
+        for (const buffer of regionBuffers) {
+            this.deSerializeColumn(buffer);
+        }
+    }
+    deSerializeColumn(columnBuffer) {
+        BinaryObject.setUseSharedMemory(true);
+        const columnData = BinaryObject.bufferToObject(columnBuffer);
+        BinaryObject.setUseSharedMemory(false);
+        return columnData;
+    }
+    _readDataIntoBuffer(offset, target, source, sourceOffset = 0, sourceLength = -1) {
+        const bufferArray = new Uint8Array(source, sourceOffset, sourceLength == -1 ? source.byteLength : sourceLength);
+        let i = bufferArray.length;
+        while (i--) {
+            target[i + offset] = bufferArray[i];
+        }
+        return bufferArray.length;
+    }
+}

package/DataLoader/Constructor/index.d.ts

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

package/DataLoader/Constructor/index.js

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

package/DataLoader/Node/DivineVoxelEngineData.d.ts

@@ -0,0 +1,48 @@
+import type * as FileSystem from "fs";
+import { NodeRegionTool } from "./Tools/NodeRegionTool.js";
+import { VoxelSpaces } from "../../Math/Spaces/VoxelSpaces.js";
+import { BinaryStruct } from "@amodx/binary/";
+type Vector3 = {
+    x: number;
+    y: number;
+    z: number;
+};
+export declare const DVED: {
+    spaces: VoxelSpaces;
+    regionTags: BinaryStruct;
+    system: {
+        fs: typeof FileSystem;
+        $INIT(fs: typeof FileSystem): void;
+        updateFolder(folder: string): void;
+        mkdirs(paths: string[]): void;
+        sync: {
+            createFile(path: string, size?: number, mode?: number): boolean;
+            createAndOpenFile(path: string, size?: number): false | import("../Types/DVED.types.js").DVEDSyncFile;
+            openFile(filePath: string, showErrors?: boolean): import("../Types/DVED.types.js").DVEDSyncFile | false;
+        };
+    };
+    path: {
+        _dataPath: string;
+        _dataFolder: string;
+        _folder: string;
+        _tempPath: string;
+        setFolder(folder: string): void;
+        getDataPath(): string;
+        getDataDirectory(fileName?: string): string;
+        getDirecoty(fileName?: string): string;
+        getTempPath(fileName?: string): string;
+        $INIT(): void;
+    };
+    $INIT(data: {
+        fs: typeof FileSystem;
+        dataDirecotry: string;
+        sectorSize: number;
+        spaceBounds: {
+            regions: Vector3;
+            columns: Vector3;
+            chunks: Vector3;
+        };
+    }): void;
+    getRegionTool(): NodeRegionTool;
+};
+export {};

package/DataLoader/Node/DivineVoxelEngineData.js

@@ -0,0 +1,47 @@
+import { NodeRegionTool } from "./Tools/NodeRegionTool.js";
+import { RegionData, RegionTagIds, SecotrData } from "./Util/DVED.util.js";
+import { VoxelSpaces } from "../../Math/Spaces/VoxelSpaces.js";
+import { BinaryNumberTypes, BinaryStruct } from "@amodx/binary/";
+import { System } from "./System/System.js";
+import { SystemPath } from "./System/SystemPath.js";
+const voxelSpaces = new VoxelSpaces();
+const regionTagManager = new BinaryStruct("region-tagsx");
+export const DVED = {
+    spaces: voxelSpaces,
+    regionTags: regionTagManager,
+    system: System,
+    path: SystemPath,
+    $INIT(data) {
+        SystemPath.setFolder(data.dataDirecotry);
+        this.spaces = voxelSpaces;
+        SecotrData.byteSize = data.sectorSize;
+        SystemPath._dataFolder = data.dataDirecotry;
+        System.$INIT(data.fs);
+        this.spaces.setDimensions(data.spaceBounds);
+        const numberColumns = this.spaces.region.getColumnVolume();
+        regionTagManager.registerProperty({
+            id: RegionTagIds.sectorIndex,
+            type: "typed-number-array",
+            numberType: BinaryNumberTypes.Uint16,
+            length: numberColumns,
+        });
+        regionTagManager.registerProperty({
+            id: RegionTagIds.columnLength,
+            type: "typed-number-array",
+            numberType: BinaryNumberTypes.Uint16,
+            length: numberColumns,
+        });
+        regionTagManager.registerProperty({
+            id: RegionTagIds.timeStamp,
+            type: "typed-number-array",
+            numberType: BinaryNumberTypes.Uint32,
+            length: numberColumns,
+        });
+        regionTagManager.init();
+        RegionData.headByteSize = regionTagManager.structSize;
+        RegionData.numColumns = numberColumns;
+    },
+    getRegionTool() {
+        return new NodeRegionTool();
+    },
+};

package/DataLoader/Node/System/RegionSystem.d.ts

@@ -0,0 +1,28 @@
+import type { DVEDSyncFile } from "../../Types/DVED.types";
+import type { LocationData } from "../../../Math/";
+export declare const RegionSystem: {
+    _processInput(buffer: ArrayBuffer | string): ArrayBufferLike;
+    _getTagIndex(id: string, index: number): number;
+    _getIndex(index: number | LocationData): number;
+    timeStamp: {
+        get(file: DVEDSyncFile, index: number): number | false;
+        set(file: DVEDSyncFile, index: number, timeStamp?: number): boolean;
+    };
+    sectorIndex: {
+        get(file: DVEDSyncFile, index: number): number | false;
+        set(file: DVEDSyncFile, index: number, sectorIndex: number): boolean;
+    };
+    columnLength: {
+        get(file: DVEDSyncFile, index: number): number | false;
+        set(file: DVEDSyncFile, index: number, length: number): boolean;
+    };
+    sectors: {
+        get(file: DVEDSyncFile, sectorIndex: number, length: number): false | ArrayBuffer;
+        set(file: DVEDSyncFile, sectorIndex: number, data: ArrayBuffer): boolean;
+    };
+    getHeader(file: DVEDSyncFile): false | ArrayBuffer;
+    _rebuild(file: DVEDSyncFile, swapFile: DVEDSyncFile, newColumnIndex: number, newColumnData: ArrayBuffer): void;
+    _getAllColumns(file: DVEDSyncFile): IterableIterator<[number, ArrayBuffer]>;
+    loadColumn(file: DVEDSyncFile, index: number | LocationData): false | ArrayBuffer;
+    saveColumn(file: DVEDSyncFile, index: number | LocationData, data: ArrayBuffer | string): void;
+};

package/DataLoader/Node/System/RegionSystem.js

@@ -0,0 +1,147 @@
+import { RegionData, RegionTagIds, SecotrData } from "../Util/DVED.util.js";
+import { DVED } from "../DivineVoxelEngineData.js";
+import { System } from "./System.js";
+import { SystemPath } from "./SystemPath.js";
+export const RegionSystem = {
+    _processInput(buffer) {
+        if (buffer instanceof ArrayBuffer)
+            return buffer;
+        if (ArrayBuffer.isView(buffer))
+            return buffer.buffer;
+        let newBuf = new ArrayBuffer(buffer.length);
+        const array = new Uint8Array(newBuf);
+        let i = newBuf.byteLength;
+        while (i--) {
+            array[i] = buffer.charCodeAt(i);
+        }
+        return newBuf;
+    },
+    _getTagIndex(id, index) {
+        return DVED.regionTags.getArrayPropertyValue(id, index);
+    },
+    _getIndex(index) {
+        if (Array.isArray(index)) {
+            index = DVED.spaces.column.getIndexXYZ(index[1], index[2], index[3]);
+        }
+        return index;
+    },
+    timeStamp: {
+        get(file, index) {
+            const timeStampData = file.read(RegionSystem._getTagIndex(RegionTagIds.timeStamp, index), 4);
+            if (!timeStampData)
+                return false;
+            return new Uint32Array(timeStampData)[0];
+        },
+        set(file, index, timeStamp = Date.now()) {
+            return file.write(RegionSystem._getTagIndex(RegionTagIds.timeStamp, index), new Uint32Array([timeStamp]).buffer);
+        },
+    },
+    sectorIndex: {
+        get(file, index) {
+            const sectorIndexData = file.read(RegionSystem._getTagIndex(RegionTagIds.sectorIndex, index), 2);
+            if (!sectorIndexData)
+                return false;
+            return new Uint16Array(sectorIndexData)[0] + 1;
+        },
+        set(file, index, sectorIndex) {
+            return file.write(RegionSystem._getTagIndex(RegionTagIds.sectorIndex, index), new Uint16Array([sectorIndex - 1]).buffer);
+        },
+    },
+    columnLength: {
+        get(file, index) {
+            const columnLengthData = file.read(RegionSystem._getTagIndex(RegionTagIds.columnLength, index), 2);
+            if (!columnLengthData)
+                return false;
+            return new Uint16Array(columnLengthData)[0];
+        },
+        set(file, index, length) {
+            return file.write(RegionSystem._getTagIndex(RegionTagIds.columnLength, index), new Uint16Array([length]).buffer);
+        },
+    },
+    sectors: {
+        get(file, sectorIndex, length) {
+            return file.read(SecotrData.getSectorByteIndex(sectorIndex - 1), length);
+        },
+        set(file, sectorIndex, data) {
+            const sectorByteIndex = SecotrData.getSectorByteIndex(sectorIndex - 1);
+            file.clear(sectorByteIndex, SecotrData.getTotalBytesNeeded(data.byteLength));
+            return file.write(sectorByteIndex, data);
+        },
+    },
+    getHeader(file) {
+        return file.read(0, RegionData.headByteSize);
+    },
+    _rebuild(file, swapFile, newColumnIndex, newColumnData) {
+        const columns = this._getAllColumns(file);
+        for (const column of columns) {
+            let [index, data] = column;
+            if (data.byteLength == 0)
+                continue;
+            if (index == newColumnIndex)
+                data = newColumnData;
+            this.saveColumn(swapFile, index, data);
+        }
+    },
+    _getAllColumns(file) {
+        return (function* generator() {
+            for (let i = 0; i < RegionData.numColumns; i++) {
+                let data = RegionSystem.loadColumn(file, i);
+                data = data ? data : new ArrayBuffer(0);
+                yield [i, data];
+            }
+        })();
+    },
+    loadColumn(file, index) {
+        let realIndex;
+        if (Array.isArray(index)) {
+            realIndex = this._getIndex(index);
+        }
+        else {
+            realIndex = index;
+        }
+        const sectorIndex = this.sectorIndex.get(file, realIndex);
+        if (typeof sectorIndex == "boolean")
+            return false;
+        const columnLength = this.columnLength.get(file, realIndex);
+        if (typeof columnLength == "boolean" || columnLength === 0)
+            return false;
+        return this.sectors.get(file, sectorIndex, columnLength);
+    },
+    saveColumn(file, index, data) {
+        index = this._getIndex(index);
+        data = this._processInput(data);
+        let timeStamp = this.timeStamp.get(file, index);
+        let sectorIndex = this.sectorIndex.get(file, index);
+        if (!sectorIndex)
+            throw new Error("error");
+        if (!timeStamp) {
+            const currentFileSize = file.getSize();
+            sectorIndex = SecotrData.getTotalSectorsInFile(currentFileSize) + 1;
+            this.sectorIndex.set(file, index, sectorIndex);
+        }
+        let currentColumnLegnth = this.columnLength.get(file, index);
+        if (currentColumnLegnth) {
+            const currentSectors = SecotrData.getSectorsNeeded(currentColumnLegnth);
+            const newSectors = SecotrData.getSectorsNeeded(data.byteLength);
+            if (currentSectors != newSectors) {
+                const swapFilePath = SystemPath.getDirecoty(file.getPath()) +
+                    "/" +
+                    Date.now() +
+                    "-temp.dved";
+                const oldPath = file.getPath();
+                file.move(swapFilePath);
+                //  file.reOpen();
+                const swapFile = System.sync.createAndOpenFile(oldPath, RegionData.headByteSize);
+                if (swapFile) {
+                    this._rebuild(file, swapFile, index, data);
+                    file.delete();
+                    swapFile.close();
+                    return;
+                }
+            }
+        }
+        this.sectors.set(file, sectorIndex, data);
+        this.columnLength.set(file, index, data.byteLength);
+        this.timeStamp.set(file, index);
+    },
+};

package/DataLoader/Node/System/System.d.ts

@@ -0,0 +1,13 @@
+import type * as FileSystem from "fs";
+import type { DVEDSyncFile } from "../../Types/DVED.types";
+export declare const System: {
+    fs: typeof FileSystem;
+    $INIT(fs: typeof FileSystem): void;
+    updateFolder(folder: string): void;
+    mkdirs(paths: string[]): void;
+    sync: {
+        createFile(path: string, size?: number, mode?: number): boolean;
+        createAndOpenFile(path: string, size?: number): false | DVEDSyncFile;
+        openFile(filePath: string, showErrors?: boolean): DVEDSyncFile | false;
+    };
+};

package/DataLoader/Node/System/System.js

@@ -0,0 +1,168 @@
+import { SystemPath } from "./SystemPath.js";
+export const System = {
+    fs: {},
+    $INIT(fs) {
+        this.fs = fs;
+        SystemPath.$INIT();
+        this.mkdirs([SystemPath.getDataPath(), SystemPath.getTempPath()]);
+    },
+    updateFolder(folder) {
+        SystemPath.setFolder(folder);
+        this.mkdirs([SystemPath.getDataPath()]);
+    },
+    mkdirs(paths) {
+        for (const path of paths) {
+            if (!this.fs.existsSync(path)) {
+                this.fs.mkdirSync(path, { recursive: true });
+            }
+        }
+    },
+    sync: {
+        createFile(path, size = 0, mode = 0o777) {
+            try {
+                System.fs.writeFileSync(path, new Uint8Array(size), { mode: mode });
+                return true;
+            }
+            catch (error) {
+                return false;
+            }
+        },
+        createAndOpenFile(path, size = 0) {
+            try {
+                this.createFile(path, size);
+                return this.openFile(path);
+            }
+            catch (error) {
+                return false;
+            }
+        },
+        openFile(filePath, showErrors = false) {
+            try {
+                const fs = System.fs;
+                let fileHandlerId = fs.openSync(filePath, "r+");
+                let closed = false;
+                const file = {
+                    getSize() {
+                        try {
+                            const stats = fs.statSync(filePath);
+                            return stats.size;
+                        }
+                        catch (error) {
+                            if (showErrors) {
+                                console.error(error);
+                            }
+                            return 0;
+                        }
+                    },
+                    getPath() {
+                        return filePath;
+                    },
+                    clear(byteStart, byteLength) {
+                        try {
+                            return this.write(byteStart, new ArrayBuffer(byteLength));
+                        }
+                        catch (error) {
+                            console.error(error);
+                            return false;
+                        }
+                    },
+                    write(byteStart, data) {
+                        try {
+                            fs.writeSync(fileHandlerId, new Uint8Array(data), 0, data.byteLength, byteStart);
+                            return true;
+                        }
+                        catch (error) {
+                            if (showErrors) {
+                                console.error(error);
+                            }
+                            return false;
+                        }
+                    },
+                    rename(newPath) {
+                        try {
+                            fs.renameSync(filePath, newPath);
+                            filePath = newPath;
+                            return true;
+                        }
+                        catch (error) {
+                            if (showErrors) {
+                                console.error(error);
+                            }
+                            return false;
+                        }
+                    },
+                    move(newPath) {
+                        try {
+                            //   fs.unlinkSync(newPath);
+                            fs.renameSync(filePath, newPath);
+                            //  fs.unlinkSync(filePath);
+                            filePath = newPath;
+                            return true;
+                        }
+                        catch (error) {
+                            if (showErrors) {
+                                console.error(error);
+                            }
+                            return false;
+                        }
+                    },
+                    reOpen() {
+                        try {
+                            fs.closeSync(fileHandlerId);
+                            fileHandlerId = fs.openSync(filePath, "r+");
+                            closed = false;
+                            return true;
+                        }
+                        catch (error) {
+                            return false;
+                        }
+                    },
+                    delete() {
+                        try {
+                            fs.closeSync(fileHandlerId);
+                            fs.unlinkSync(filePath);
+                            closed = true;
+                            return true;
+                        }
+                        catch (error) {
+                            if (showErrors) {
+                                console.error(error);
+                            }
+                            return false;
+                        }
+                    },
+                    read(byteStart, byteLength) {
+                        try {
+                            const buffer = new ArrayBuffer(byteLength);
+                            fs.readSync(fileHandlerId, new Uint8Array(buffer), {
+                                length: byteLength,
+                                offset: 0,
+                                position: byteStart,
+                            });
+                            return buffer;
+                        }
+                        catch (error) {
+                            if (showErrors) {
+                                console.error(error);
+                            }
+                            return false;
+                        }
+                    },
+                    close() {
+                        if (closed)
+                            return;
+                        closed = true;
+                        fs.closeSync(fileHandlerId);
+                    },
+                };
+                return file;
+            }
+            catch (error) {
+                if (showErrors) {
+                    console.error(error);
+                }
+                return false;
+            }
+        },
+    },
+};

package/DataLoader/Node/System/SystemPath.d.ts

@@ -0,0 +1,12 @@
+export declare const SystemPath: {
+    _dataPath: string;
+    _dataFolder: string;
+    _folder: string;
+    _tempPath: string;
+    setFolder(folder: string): void;
+    getDataPath(): string;
+    getDataDirectory(fileName?: string): string;
+    getDirecoty(fileName?: string): string;
+    getTempPath(fileName?: string): string;
+    $INIT(): void;
+};

package/DataLoader/Node/System/SystemPath.js

@@ -0,0 +1,29 @@
+import * as path from "path";
+export const SystemPath = {
+    _dataPath: "",
+    _dataFolder: "dved",
+    _folder: "test",
+    _tempPath: "/",
+    setFolder(folder) {
+        this._folder = folder;
+    },
+    getDataPath() {
+        return path.join(this._dataPath, this._dataFolder);
+    },
+    getDataDirectory(fileName = "") {
+        return path.join(this._dataPath, this._dataFolder, this._folder, fileName);
+    },
+    getDirecoty(fileName = "") {
+        return path.dirname(fileName);
+    },
+    getTempPath(fileName = "") {
+        return path.join(`${this._tempPath}/${this._dataFolder}`, fileName);
+    },
+    $INIT() {
+        this._dataPath =
+            process.env.APPDATA ||
+                (process.platform == "darwin"
+                    ? process.env.HOME + "/Library/Preferences"
+                    : process.env.HOME + "/.local/share");
+    },
+};

package/DataLoader/Node/Tools/NodeRegionTool.d.ts

@@ -0,0 +1,28 @@
+import type { DVEDDataTypes } from "../../Types/DVED.types";
+import type { LocationData } from "../../../Math/";
+export declare class NodeRegionTool {
+    location: LocationData;
+    dimension: string;
+    previousDimension: string;
+    path: string;
+    fileName: string;
+    dataType: DVEDDataTypes;
+    setDataType(dataTypes: DVEDDataTypes): this;
+    setLocation(location: LocationData): this;
+    getCurrentPath(): string;
+    _getSwapPath(): string;
+    _dimensionPath(dataPath?: string): string;
+    _getDataPath(dataType: DVEDDataTypes, fileName?: string): string;
+    _setFileName(): void;
+    regionExists(): boolean;
+    createRegion(): boolean;
+    regionHasColumn(): boolean;
+    getAllColumns(): false | IterableIterator<[number, ArrayBuffer]>;
+    copyToNewfile(): void;
+    getColumnTimestamp(): number | false;
+    getSectorIndex(): number | false;
+    getColumnDataLength(): number | false;
+    getHeader(): false | ArrayBuffer;
+    loadColumn(): false | ArrayBuffer;
+    saveColumn(buffer: ArrayBuffer | string): boolean;
+}