@divinevoxel/vlox 0.0.4 → 0.0.6

package/Tasks/DataLoader/World/DataLoaderTasks.js

@@ -1,70 +0,0 @@
-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/Tasks/DataLoader/World/DivineVoxelEngineDataLoaderWorld.d.ts

@@ -1,12 +0,0 @@
-import { DataHanlderWrapper } from "./DataHandlerWrapper.js";
-import { DVEDataHandler } from "../Types/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/Tasks/DataLoader/World/DivineVoxelEngineDataLoaderWorld.js

@@ -1,17 +0,0 @@
-//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/Tasks/DataLoader/World/Tools/DataLoaderTool.d.ts

@@ -1,24 +0,0 @@
-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/Tasks/DataLoader/World/Tools/DataLoaderTool.js

@@ -1,113 +0,0 @@
-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 "../../../../Settings/EngineSettings.js";
-import { DataHooks } from "../../../../Contexts/Base/DataHooks";
-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.dataLoader.mode;
-        DataHooks.settingsSynced.subscribe("data-loader", (data) => {
-            this.mode = data.dataLoader.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/Tasks/DataLoader/World/Tools/DataSerializerTool.d.ts

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

package/Tasks/DataLoader/World/Tools/DataSerializerTool.js

@@ -1,27 +0,0 @@
-import { DivineVoxelEngineWorld } from "../../../../Contexts/World";
-export class DataSerializerTool {
-    serializeColumn(location, onDone) {
-        DivineVoxelEngineWorld.instance.threads.constructors.runPromiseTasks("serialize-column", location, [], (buffer) => {
-            onDone(buffer);
-        });
-    }
-    serializeColumnAsync(location) {
-        return new Promise((resolve) => {
-            this.serializeColumn(location, (buffer) => {
-                resolve(buffer);
-            });
-        });
-    }
-    deSerializeColumn(column, onDone) {
-        DivineVoxelEngineWorld.instance.threads.constructors.runPromiseTasks("deserialize-column", column, [column], (buffer) => {
-            onDone(buffer);
-        });
-    }
-    deSerializeColumnAsync(column) {
-        return new Promise((resolve) => {
-            this.deSerializeColumn(column, (buffer) => {
-                resolve(buffer);
-            });
-        });
-    }
-}

package/Tasks/DataLoader/World/Tools/LoaderRegister.d.ts

@@ -1,9 +0,0 @@
-import { ThreadPool } from "@amodx/threads/";
-import { LocationData } from "../../../../Math";
-export declare const LoaderRegister: {
-    load: Map<string, Function[]>;
-    dataComm: ThreadPool;
-    $INIT(dataComm: ThreadPool): void;
-    addToLoad(location: LocationData, run: Function): number | undefined;
-    runLoad(location: LocationData, data: any): false | undefined;
-};

package/Tasks/DataLoader/World/Tools/LoaderRegister.js

@@ -1,29 +0,0 @@
-import { WorldSpaces } from "../../../../Data/World/WorldSpaces.js";
-export const LoaderRegister = {
-    load: new Map(),
-    dataComm: {},
-    $INIT(dataComm) {
-        this.dataComm = dataComm;
-    },
-    addToLoad(location, run) {
-        const key = WorldSpaces.column.getKeyXYZ(location[1], 0, location[3]);
-        let load = this.load.get(key);
-        if (load)
-            return load.push(run);
-        const newL = [...location];
-        load = [];
-        this.load.set(key, load);
-        load.push(run);
-        this.dataComm.runPromiseTasks("load-column", newL, [], (data) => {
-            this.runLoad(newL, data);
-        });
-    },
-    runLoad(location, data) {
-        const key = WorldSpaces.column.getKeyXYZ(location[1], 0, location[3]);
-        const run = this.load.get(key);
-        if (!run)
-            return false;
-        run.forEach((_) => _(data));
-        this.load.delete(key);
-    },
-};

package/Tasks/IWG/Constants/ColumnState.d.ts

@@ -1,6 +0,0 @@
-export declare enum ColumnState {
-    GenDone = "dve_is_world_gen_done",
-    SunDone = "dve_is_world_sun_done",
-    DecorDone = "dve_is_world_decor_done",
-    PropagationDone = "dve_is_world_propagation_done"
-}

package/Tasks/IWG/Constants/ColumnState.js

@@ -1,7 +0,0 @@
-export var ColumnState;
-(function (ColumnState) {
-    ColumnState["GenDone"] = "dve_is_world_gen_done";
-    ColumnState["SunDone"] = "dve_is_world_sun_done";
-    ColumnState["DecorDone"] = "dve_is_world_decor_done";
-    ColumnState["PropagationDone"] = "dve_is_world_propagation_done";
-})(ColumnState || (ColumnState = {}));

package/Tasks/IWG/World/Classes/DebouncedTasks.d.ts

@@ -1,16 +0,0 @@
-import { LocationData } from "../../../../Math";
-type DebouncedTasksData = {
-    run: (location: LocationData) => void;
-    timeOut: number;
-};
-export declare class DebouncedTasks {
-    data: DebouncedTasksData;
-    _tasks: Map<string, any>;
-    constructor(data: DebouncedTasksData);
-    runTasksNow([dimension, cx, cy, cz]: LocationData): void;
-    runTasks([dimension, cx, cy, cz]: LocationData): void;
-    clearTasks([dimension, cx, cy, cz]: LocationData): void;
-    hasTasks(key: string): boolean;
-    hasTasksLocation([dimension, cx, cy, cz]: LocationData): boolean;
-}
-export {};

package/Tasks/IWG/World/Classes/DebouncedTasks.js

@@ -1,34 +0,0 @@
-import { WorldSpaces } from "../../../../Data/World/WorldSpaces";
-export class DebouncedTasks {
-    data;
-    _tasks = new Map();
-    constructor(data) {
-        this.data = data;
-    }
-    runTasksNow([dimension, cx, cy, cz]) {
-        this.data.run([dimension, cx, cy, cz]);
-    }
-    runTasks([dimension, cx, cy, cz]) {
-        const columnKey = WorldSpaces.column.getKeyXYZ(cx, 0, cz);
-        if (this._tasks.has(columnKey)) {
-            clearTimeout(this._tasks.get(columnKey));
-        }
-        this._tasks.set(columnKey, setTimeout(() => {
-            this.data.run([dimension, cx, cy, cz]);
-        }, this.data.timeOut));
-    }
-    clearTasks([dimension, cx, cy, cz]) {
-        const columnKey = WorldSpaces.column.getKeyXYZ(cx, 0, cz);
-        if (this._tasks.has(columnKey)) {
-            clearTimeout(this._tasks.get(columnKey));
-            this._tasks.delete(columnKey);
-        }
-    }
-    hasTasks(key) {
-        return this._tasks.has(key);
-    }
-    hasTasksLocation([dimension, cx, cy, cz]) {
-        const columnKey = WorldSpaces.column.getKeyXYZ(cx, 0, cz);
-        return this._tasks.has(columnKey);
-    }
-}

package/Tasks/IWG/World/Classes/Generator.d.ts

@@ -1,50 +0,0 @@
-import { IWGGeneratorData, IWGSettignsData, IWGTasksTypes } from "../Types/IWG.types";
-import { Vec3Array } from "@amodx/math";
-import { ColumnDataTool } from "../../../../Tools/Data/WorldData/ColumnDataTool.js";
-import { MesherTool } from "../../../../Tools/Mesher/MesherTool.js";
-import { TaskTool } from "../../../../Tools/Tasks/TasksTool.js";
-import { DataLoaderTool } from "../../../DataLoader/World/Tools/DataLoaderTool.js";
-import { AnaylzerTool } from "../../../../Tools/Anaylzer/AnaylzerTool.js";
-import { IWGTaskBase } from "./Tasks/IWGTaskBase.js";
-import { LocationBoundTool } from "../../../../Tools/Classes/LocationBoundTool.js";
-/**# Infinite World Generator
- *
- */
-export declare class Generator extends LocationBoundTool {
-    data: IWGGeneratorData;
-    _anaylzerDone: boolean;
-    anaylzer: AnaylzerTool;
-    columnTool: ColumnDataTool;
-    nColumnTool: ColumnDataTool;
-    builder: MesherTool;
-    dataLoader: DataLoaderTool | null;
-    dveTasks: TaskTool;
-    _cachedPosition: Vec3Array;
-    _cachedVelocity: Vec3Array;
-    __build: boolean;
-    _visitedMap: Map<string, boolean>;
-    _builtColumns: Map<string, number[]>;
-    private columnSquare;
-    private genCircle;
-    private renderCircle;
-    private maxCircle;
-    tasks: Record<IWGTasksTypes, Map<string, IWGTaskBase>>;
-    constructor(data: IWGGeneratorData);
-    setDimension(dimensionId: string): this;
-    updateDimension(dimension: string): this;
-    clearAll(): void;
-    saveUpdate(max?: number): void;
-    saveAllColumns(): void;
-    unLoadAllColumns(): void;
-    _logTasks(): string;
-    anaylzerUpdate(): void;
-    worldGenUpdate(max?: number): void;
-    renderTaskUpdate(max?: number): void;
-    cancelWorldGenTasks(): void;
-    cancelAllRenderTask(): void;
-    updateSettings(settings: IWGSettignsData): void;
-    private cullColumns;
-    private getColumnState;
-    generateUpdate(): void;
-    renderUpdate(): void;
-}