@divinevoxel/vlox 0.0.3 → 0.0.5

package/Settings/EngineSettings.d.ts

@@ -1,27 +1,25 @@
 import { EngineSettingsData } from "./EngineSettings.types.js";
-import { Observable } from "@amodx/core/Observers/Observable.js";
+import { TypedEventTarget } from "../Util/TypedEventTarget.js";
+type EngineSettingsEvents = {
+    synced: {
+        settings: EngineSettingsClass;
+    };
+};
 /**# Engine Settings
  * ---
  * Handles common settings for all contexts
  */
-export declare class EngineSettings {
-    static observers: {
-        updated: Observable<EngineSettingsData>;
-    };
-    static enviorment: "node" | "browser";
-    static settings: EngineSettingsData;
-    static getSettings(): EngineSettingsData;
-    static syncSettings(data: EngineSettingsData): void;
-    static getSettingsCopy(): any;
-    static syncChunkInRichWorldThread(): boolean;
-    static richDataEnabled(): boolean;
-    static syncChunkInDataThread(): boolean;
-    static syncChunksInNexusThread(): boolean;
-    static doSunPropagation(): boolean;
-    static doRGBPropagation(): boolean;
-    static doLight(): boolean;
-    static doFlow(): boolean;
-    static saveWorldData(): boolean;
-    static isServer(): boolean;
-    static isClient(): boolean;
+declare class EngineSettingsClass extends TypedEventTarget<EngineSettingsEvents> {
+    enviorment: "node" | "browser";
+    settings: EngineSettingsData;
+    getSettings(): EngineSettingsData;
+    syncSettings(data: EngineSettingsData): void;
+    getSettingsCopy(): any;
+    doSunPropagation(): boolean;
+    doRGBPropagation(): boolean;
+    doLight(): boolean;
+    doFlow(): boolean;
+    isClient(): boolean;
 }
+export declare const EngineSettings: EngineSettingsClass;
+export {};

package/Settings/EngineSettings.js

@@ -1,24 +1,17 @@
 import { EngineSettingsData } from "./EngineSettings.types.js";
-import { WorldBounds } from "../Data/World/WorldBounds.js";
-import { InitWorldSpaces } from "../Data/World/WorldSpaces.js";
-import { Environment } from "@amodx/core/Environment/Environment.js";
-import { Observable } from "@amodx/core/Observers/Observable.js";
+import { Environment } from "../Util/Environment";
+import { TypedEventTarget } from "../Util/TypedEventTarget.js";
 /**# Engine Settings
  * ---
  * Handles common settings for all contexts
  */
-export class EngineSettings {
-    static observers = {
-        updated: new Observable(),
-    };
-    static enviorment = Environment.nodeJS.isNode
-        ? "node"
-        : "browser";
-    static settings = new EngineSettingsData();
-    static getSettings() {
+class EngineSettingsClass extends TypedEventTarget {
+    enviorment = Environment.isNode() ? "node" : "browser";
+    settings = new EngineSettingsData();
+    getSettings() {
         return this.settings;
     }
-    static syncSettings(data) {
+    syncSettings(data) {
         //safetly set data without prototype pollution
         for (const settingsKey of Object.keys(data)) {
             if (settingsKey.includes("__")) {
@@ -36,46 +29,25 @@ export class EngineSettings {
                 }
             }
         }
-        InitWorldSpaces(this.settings);
-        if (this.settings.world) {
-            WorldBounds.setWorldBounds(this.settings.world.minX, this.settings.world.maxX, this.settings.world.minZ, this.settings.world.maxZ, this.settings.world.minY, this.settings.world.maxY);
-        }
-        this.observers.updated.notify(this.settings);
+        this.dispatch("synced", { settings: this });
     }
-    static getSettingsCopy() {
+    getSettingsCopy() {
         return JSON.parse(JSON.stringify(this.settings));
     }
-    static syncChunkInRichWorldThread() {
-        return (this.settings.richWorld.enabled && this.settings.richWorld.autoSyncChunks);
-    }
-    static richDataEnabled() {
-        return this.settings.richWorld.enabled;
-    }
-    static syncChunkInDataThread() {
-        return this.settings.dataLoader.enabled && this.settings.dataLoader.autoSyncChunks;
-    }
-    static syncChunksInNexusThread() {
-        return this.settings.nexus.enabled && this.settings.nexus.autoSyncChunks;
-    }
-    static doSunPropagation() {
+    doSunPropagation() {
         return this.settings.lighting.autoSunLight == true;
     }
-    static doRGBPropagation() {
+    doRGBPropagation() {
         return this.settings.lighting.autoRGBLight == true;
     }
-    static doLight() {
+    doLight() {
         return this.doRGBPropagation() || this.doSunPropagation();
     }
-    static doFlow() {
+    doFlow() {
         return this.settings.flow.enable;
     }
-    static saveWorldData() {
-        return this.settings.dataLoader.enabled;
-    }
-    static isServer() {
-        return this.settings.server.enabled && this.enviorment == "node";
-    }
-    static isClient() {
+    isClient() {
         return this.enviorment != "browser";
     }
 }
+export const EngineSettings = new EngineSettingsClass();

package/Settings/EngineSettings.types.d.ts

@@ -2,27 +2,6 @@ export declare class EngineSettingsData {
     rendererSettings: {
         mode: "webgl" | "webgpu";
     };
-    floatingOrigi: {
-        enable: boolean;
-    };
-    nexus: {
-        enabled: boolean;
-        autoSyncChunks: boolean;
-        autoSyncVoxelPalette: boolean;
-    };
-    dataLoader: {
-        enabled: boolean;
-        autoSyncChunks: boolean;
-        mode: string;
-    };
-    server: {
-        enabled: boolean;
-    };
-    richWorld: {
-        enabled: boolean;
-        autoSyncChunks: boolean;
-        autoSyncVoxelPalette: boolean;
-    };
     textures: {
         animationTime: number;
         textureSize: number;
@@ -39,16 +18,16 @@ export declare class EngineSettingsData {
         maxY: number;
         minY: number;
     };
-    regions: {
-        regionXPow2: number;
-        regionYPow2: number;
-        regionZPow2: number;
+    sectors: {
+        sectorXPow2: number;
+        sectorYPow2: number;
+        sectorZPow2: number;
     };
-    chunks: {
+    sections: {
         autoHeightMap: boolean;
-        chunkXPow2: number;
-        chunkYPow2: number;
-        chunkZPow2: number;
+        sectionXPow2: number;
+        sectionYPow2: number;
+        sectionZPow2: number;
     };
     voxels: {
         doColors: boolean;
@@ -64,10 +43,4 @@ export declare class EngineSettingsData {
         autoRGBLight: boolean;
         autoSunLight: boolean;
     };
-    meshes: {
-        clearChachedGeometry: boolean;
-        checkCollisions: boolean;
-        serialize: boolean;
-        pickable: boolean;
-    };
 }

package/Settings/EngineSettings.types.js

@@ -1,26 +1,5 @@
 export class EngineSettingsData {
     rendererSettings = { mode: "webgl" };
-    floatingOrigi = {
-        enable: false,
-    };
-    nexus = {
-        enabled: false,
-        autoSyncChunks: true,
-        autoSyncVoxelPalette: true,
-    };
-    dataLoader = {
-        enabled: false,
-        autoSyncChunks: true,
-        mode: "indexdb",
-    };
-    server = {
-        enabled: false,
-    };
-    richWorld = {
-        enabled: false,
-        autoSyncChunks: true,
-        autoSyncVoxelPalette: true,
-    };
     textures = {
         animationTime: 20,
         textureSize: 16,
@@ -37,16 +16,16 @@ export class EngineSettingsData {
         maxY: 256,
         minY: 0,
     };
-    regions = {
-        regionXPow2: 9,
-        regionYPow2: 8,
-        regionZPow2: 9,
+    sectors = {
+        sectorXPow2: 4,
+        sectorYPow2: 8,
+        sectorZPow2: 4,
     };
-    chunks = {
+    sections = {
         autoHeightMap: true,
-        chunkXPow2: 4,
-        chunkYPow2: 4,
-        chunkZPow2: 4,
+        sectionXPow2: 4,
+        sectionYPow2: 4,
+        sectionZPow2: 4,
     };
     voxels = {
         doColors: true,
@@ -62,10 +41,4 @@ export class EngineSettingsData {
         autoRGBLight: true,
         autoSunLight: true,
     };
-    meshes = {
-        clearChachedGeometry: true,
-        checkCollisions: false,
-        serialize: false,
-        pickable: false,
-    };
 }

package/Tasks/IWG/IWG.d.ts

@@ -0,0 +1,25 @@
+import { Thread, ThreadPool } from "@amodx/threads";
+import { WorldStorageInterface } from "../../World/Storage/WorldStorage.interface";
+import { Generator, GeneratorData } from "./Internal/Classes/Generator";
+import { InitalLoad } from "./Procedures/InitalLoad";
+import SaveAllSectors from "./Procedures/SaveAllSectors";
+interface IWGInitData {
+    parent: Thread;
+    threads: Thread | ThreadPool;
+    worldStorage?: WorldStorageInterface;
+}
+export declare class IWG {
+    private static _cullGenerators;
+    static readonly _generators: Generator[];
+    static addDimension(id: string): void;
+    static Procedures: {
+        InitalLoad: typeof InitalLoad;
+        SaveAllSectors: typeof SaveAllSectors;
+    };
+    static init(data: IWGInitData): void;
+    static createGenerator(data: Partial<GeneratorData>): Generator;
+    static addGenerator(generator: Generator): void;
+    static removeGenerator(generator: Generator): boolean;
+    static update(): void;
+}
+export {};

package/Tasks/IWG/IWG.js

@@ -0,0 +1,89 @@
+import { TaskTool } from "../../Tools/Tasks/TasksTool";
+import { Generator } from "./Internal/Classes/Generator";
+import { runWorldUpdate } from "./Internal/Functions/runWorldUpdate";
+import { IWGTasks } from "./Internal/IWGTasks";
+import { runBuildUpdate } from "./Internal/Functions/runBuildUpdate";
+import { IWGTools } from "./Internal/IWGTools";
+import { IWGDimensions } from "./Internal/IWGDimensions";
+import { cullSectors } from "./Internal/Functions/cullSectors";
+import { Vector3Like } from "@amodx/math";
+import { InitalLoad } from "./Procedures/InitalLoad";
+import SaveAllSectors from "./Procedures/SaveAllSectors";
+let initalized = false;
+export class IWG {
+    static _cullGenerators = [];
+    static _generators = [];
+    static addDimension(id) {
+        IWGDimensions.addDimension(id);
+    }
+    static Procedures = {
+        InitalLoad,
+        SaveAllSectors,
+    };
+    static init(data) {
+        initalized = true;
+        IWGTools.parent = data.parent;
+        IWGTools.taskTool = new TaskTool(data.threads);
+        if (data.worldStorage)
+            IWGTools.worldStorage = data.worldStorage;
+        console.warn("load the thing", IWGTools.worldStorage, data.worldStorage);
+    }
+    static createGenerator(data) {
+        return new Generator({
+            dimension: data.dimension ? data.dimension : "main",
+            position: data.position ? data.position : Vector3Like.Create(),
+            renderRadius: data.renderRadius ? data.renderRadius : 150,
+            generationRadius: data.generationRadius ? data.generationRadius : 250,
+            maxRadius: data.maxRadius ? data.maxRadius : 300,
+            building: data.building ? data.building : undefined,
+        });
+    }
+    static addGenerator(generator) {
+        this._generators.push(generator);
+    }
+    static removeGenerator(generator) {
+        for (let i = 0; i < this._generators.length; i++) {
+            if (this._generators[i] == generator) {
+                this._generators.splice(i, 1);
+                return true;
+            }
+        }
+        return false;
+    }
+    static update() {
+        if (!initalized) {
+            throw new Error(`IWG must be initalized.`);
+        }
+        if (this._cullGenerators.length)
+            this._cullGenerators.length = 0;
+        for (const gen of this._generators) {
+            gen.update();
+            if (!gen._culling)
+                continue;
+            if (gen._positonChanged) {
+                if (!gen._waitingForCull) {
+                    gen._waitingForCull = true;
+                    gen._cullTime = performance.now();
+                }
+                else {
+                    if (performance.now() - gen._cullTime > 4000) {
+                        gen._waitingForCull = false;
+                        this._cullGenerators.push(gen);
+                    }
+                }
+            }
+        }
+        runBuildUpdate(this._generators);
+        IWGTasks.buildTasks.runTask();
+        runWorldUpdate(this._generators);
+        IWGTasks.worldLoadTasks.runTask();
+        IWGTasks.worldGenTasks.runTask();
+        IWGTasks.worldDecorateTasks.runTask();
+        IWGTasks.worldSunTasks.runTask();
+        IWGTasks.worldPropagationTasks.runTask();
+        IWGTasks.saveTasks.runTask();
+        IWGTasks.saveAndUnloadTasks.runTask();
+        cullSectors(this._generators, this._cullGenerators);
+    }
+}
+IWG.addDimension("main");

package/Tasks/IWG/Internal/Classes/DimensionSegment.d.ts

@@ -0,0 +1,37 @@
+import { Vec3Array } from "@amodx/math";
+import { SectorVisistedMap } from "./SectorVisistedMap";
+import { Sector } from "World";
+declare class TaskSegment {
+    queue: number[];
+    vistedMap: SectorVisistedMap;
+    waitingFor: number;
+    clear(): void;
+}
+declare class SecotrQueueNode {
+    position: Vec3Array;
+    time: number;
+    constructor(position: Vec3Array);
+}
+declare class SectorQueue {
+    nodes: SecotrQueueNode[];
+    private addedMap;
+    removeIndex(index: number): void;
+    inMap(sector: Sector): boolean;
+    addSector(sector: Sector): void;
+}
+export declare class DimensionSegment {
+    id: string;
+    tasks: Map<string, TaskSegment>;
+    queue: number[];
+    vistedMap: SectorVisistedMap;
+    rendered: SectorVisistedMap;
+    inProgress: SectorVisistedMap;
+    unRenderQueue: SectorQueue;
+    unLoadQueue: SectorQueue;
+    constructor(id: string);
+    addTask(id: string): void;
+    getTask(id: string): TaskSegment;
+    clearAllTasks(): void;
+    logTasks(): string;
+}
+export {};

package/Tasks/IWG/Internal/Classes/DimensionSegment.js

@@ -0,0 +1,67 @@
+import { SectorVisistedMap } from "./SectorVisistedMap";
+class TaskSegment {
+    queue = [];
+    vistedMap = new SectorVisistedMap();
+    waitingFor = 0;
+    clear() {
+        this.waitingFor = 0;
+        this.queue.length = 0;
+        this.vistedMap.clear();
+    }
+}
+class SecotrQueueNode {
+    position;
+    time = 0;
+    constructor(position) {
+        this.position = position;
+    }
+}
+class SectorQueue {
+    nodes = [];
+    addedMap = new SectorVisistedMap();
+    removeIndex(index) {
+        const sector = this.nodes.splice(index, 1)[0];
+        this.addedMap.remove(...sector.position);
+    }
+    inMap(sector) {
+        return this.addedMap.has(...sector.position);
+    }
+    addSector(sector) {
+        this.addedMap.add(...sector.position);
+        this.nodes.push(new SecotrQueueNode([...sector.position]));
+    }
+}
+export class DimensionSegment {
+    id;
+    tasks = new Map();
+    queue = [];
+    vistedMap = new SectorVisistedMap();
+    rendered = new SectorVisistedMap();
+    inProgress = new SectorVisistedMap();
+    unRenderQueue = new SectorQueue();
+    unLoadQueue = new SectorQueue();
+    constructor(id) {
+        this.id = id;
+    }
+    addTask(id) {
+        this.tasks.set(id, new TaskSegment());
+    }
+    getTask(id) {
+        const task = this.tasks.get(id);
+        if (!task)
+            throw new Error(`Task with id [${id}] not registered in dimension segment ${this.id}`);
+        return task;
+    }
+    clearAllTasks() {
+        for (const [key, task] of this.tasks) {
+            task.clear();
+        }
+    }
+    logTasks() {
+        const tasks = [];
+        for (const [key, task] of this.tasks) {
+            tasks.push(`${key} | ${task.waitingFor}`);
+        }
+        return tasks.join("\n");
+    }
+}

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

@@ -0,0 +1,27 @@
+import { Vector3Like } from "@amodx/math";
+import { Circle } from "@amodx/math/Shapes";
+export interface GeneratorData {
+    dimension: string;
+    building?: boolean;
+    culling?: boolean;
+    position: Vector3Like;
+    renderRadius: number;
+    generationRadius: number;
+    maxRadius: number;
+}
+export declare class Generator {
+    position: Vector3Like;
+    _dimension: string;
+    _building: boolean;
+    _positonChanged: boolean;
+    _waitingForCull: boolean;
+    _cullTime: number;
+    _culling: boolean;
+    _cachedPosition: Vector3Like;
+    _sectorPosition: Vector3Like;
+    _genCircle: Circle;
+    _renderCircle: Circle;
+    _maxCircle: Circle;
+    constructor(data: GeneratorData);
+    update(): void;
+}

package/Tasks/IWG/Internal/Classes/Generator.js

@@ -0,0 +1,41 @@
+import { Vector3Like } from "@amodx/math";
+import { Circle } from "@amodx/math/Shapes";
+import { WorldSpaces } from "../../../../World/WorldSpaces";
+export class Generator {
+    position;
+    _dimension = "main";
+    _building = true;
+    _positonChanged = false;
+    _waitingForCull = false;
+    _cullTime = 0;
+    _culling = true;
+    _cachedPosition = Vector3Like.Create();
+    _sectorPosition = Vector3Like.Create();
+    _genCircle = new Circle({ x: 0, y: 0 }, 0);
+    _renderCircle = new Circle({ x: 0, y: 0 }, 0);
+    _maxCircle = new Circle({ x: 0, y: 0 }, 10);
+    constructor(data) {
+        this._dimension = data.dimension;
+        this.position = data.position;
+        this._building =
+            typeof data.building !== "undefined" ? data.building : true;
+        this._culling = typeof data.culling !== "undefined" ? data.culling : true;
+        this._renderCircle.radius = data.renderRadius;
+        this._genCircle.radius = data.generationRadius;
+        this._maxCircle.radius = data.maxRadius;
+    }
+    update() {
+        this._positonChanged = false;
+        WorldSpaces.section.getPosition(this.position.x, this.position.y, this.position.z, this._sectorPosition);
+        if (!Vector3Like.Equals(this._sectorPosition, this._cachedPosition)) {
+            this._positonChanged = true;
+            Vector3Like.Copy(this._cachedPosition, this._sectorPosition);
+        }
+        this._renderCircle.center.x = this._sectorPosition.x;
+        this._renderCircle.center.y = this._sectorPosition.z;
+        this._genCircle.center.x = this._sectorPosition.x;
+        this._genCircle.center.y = this._sectorPosition.z;
+        this._maxCircle.center.x = this._sectorPosition.x;
+        this._maxCircle.center.y = this._sectorPosition.z;
+    }
+}

package/Tasks/IWG/Internal/Classes/IWGTaskBase.d.ts

@@ -0,0 +1,15 @@
+import { LocationData } from "../../../../Math/index.js";
+import { DimensionSegment } from "./DimensionSegment.js";
+export type IWGTasksData = {
+    id: string;
+    propagationBlocking?: boolean;
+    run(location: LocationData, onDone: () => void, dimension: DimensionSegment): void;
+};
+export declare class IWGTaskBase {
+    data: IWGTasksData;
+    constructor(data: IWGTasksData);
+    add(dimensionId: string, x: number, y: number, z: number): void;
+    remove(dimensionId: string, x: number, y: number, z: number): void;
+    cancelAll(dimensionId?: string | null): void;
+    runTask(max?: number): void;
+}

package/Tasks/IWG/Internal/Classes/IWGTaskBase.js

@@ -0,0 +1,62 @@
+import { IWGDimensions } from "../../Internal/IWGDimensions.js";
+export class IWGTaskBase {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+    add(dimensionId, x, y, z) {
+        const dimension = IWGDimensions.getDimension(dimensionId);
+        const task = dimension.getTask(this.data.id);
+        if (task.vistedMap.has(x, y, z))
+            return;
+        if (this.data.propagationBlocking && dimension.inProgress.has(x, y, z))
+            return;
+        task.queue.push(x, y, z);
+        task.vistedMap.add(x, y, z);
+    }
+    remove(dimensionId, x, y, z) {
+        const dimension = IWGDimensions.getDimension(dimensionId);
+        const task = dimension.getTask(this.data.id);
+        task.vistedMap.remove(x, y, z);
+        if (this.data.propagationBlocking) {
+            dimension.inProgress.remove(x, y, z);
+        }
+    }
+    cancelAll(dimensionId = null) {
+        if (dimensionId) {
+            const dimension = IWGDimensions.getDimension(dimensionId);
+            const task = dimension.getTask(this.data.id);
+            task.clear();
+        }
+        else {
+            for (const [key, dimension] of IWGDimensions._dimensions) {
+                dimension.clearAllTasks();
+            }
+        }
+    }
+    runTask(max = 1000) {
+        for (const [key, dimension] of IWGDimensions._dimensions) {
+            const task = dimension.getTask(this.data.id);
+            if (task.waitingFor < 0)
+                task.waitingFor = 0;
+            if (task.waitingFor >= max)
+                continue;
+            while (task.waitingFor < max && task.queue.length) {
+                const x = task.queue.shift();
+                const y = task.queue.shift();
+                const z = task.queue.shift();
+                task.waitingFor++;
+                if (this.data.propagationBlocking) {
+                    dimension.inProgress.add(x, 0, z);
+                }
+                this.data.run([dimension.id, x, y, z], () => {
+                    task.vistedMap.remove(x, y, z);
+                    if (this.data.propagationBlocking) {
+                        dimension.inProgress.remove(x, 0, z);
+                    }
+                    task.waitingFor--;
+                }, dimension);
+            }
+        }
+    }
+}

package/Tasks/IWG/Internal/Classes/SectorState.d.ts

@@ -0,0 +1,11 @@
+export declare class SectorState {
+    isLoaded: boolean;
+    isGenerated: boolean;
+    genAlldone: boolean;
+    allLoaded: boolean;
+    nWorldGenAllDone: boolean;
+    nDecorAllDone: boolean;
+    nSunAllDone: boolean;
+    nPropagtionAllDone: boolean;
+    resset(): void;
+}

package/Tasks/IWG/Internal/Classes/SectorState.js

@@ -0,0 +1,20 @@
+export class SectorState {
+    isLoaded = true;
+    isGenerated = true;
+    genAlldone = true;
+    allLoaded = true;
+    nWorldGenAllDone = true;
+    nDecorAllDone = true;
+    nSunAllDone = true;
+    nPropagtionAllDone = true;
+    resset() {
+        this.isLoaded = true;
+        this.isGenerated = true;
+        this.genAlldone = true;
+        this.allLoaded = true;
+        this.nWorldGenAllDone = true;
+        this.nDecorAllDone = true;
+        this.nSunAllDone = true;
+        this.nPropagtionAllDone = true;
+    }
+}

package/Tasks/IWG/Internal/Classes/SectorVisistedMap.d.ts

@@ -0,0 +1,9 @@
+export declare class SectorVisistedMap {
+    _map: Set<string>;
+    get size(): number;
+    _getKey(x: number, y: number, z: number): string;
+    has(x: number, y: number, z: number): boolean;
+    add(x: number, y: number, z: number): void;
+    remove(x: number, y: number, z: number): void;
+    clear(): void;
+}