@divinevoxel/vlox 0.0.4 → 0.0.6

package/Renderer/MeshRegister.d.ts

@@ -1,39 +1,21 @@
 import { type LocationData } from "../Math/index.js";
-import { MushRegisterRegion } from "./Classes/MushRegisterRegion.js";
-import { MeshRegisterColumn } from "./Classes/MeshRegisterColumn.js";
-import { ChunkMesh } from "./Classes/ChunkMesh.js";
-import { ChunkMeshInterface } from "./DVEChunkMeshInterface.js";
-export type MeshRegisterDimensions = Map<string, Map<string, MushRegisterRegion>>;
-declare class Chunk {
-    static addMesh(location: LocationData, mesh: ChunkMeshInterface, substance: string): ChunkMesh;
-    static add(location: LocationData): ChunkMesh;
-    static removeMesh(location: LocationData, substance: string): false | ChunkMeshInterface;
-    static getMesh(location: LocationData, substance: string): false | ChunkMeshInterface;
-    static remove(location: LocationData): false | ChunkMesh;
-    static get(location: LocationData): false | ChunkMesh;
-}
-declare class Column {
-    static add(location: LocationData): MeshRegisterColumn;
-    static remove(location: LocationData): false | MeshRegisterColumn;
-    static get(location: LocationData): false | MeshRegisterColumn | undefined;
-}
-declare class Region {
-    static add(location: LocationData): MushRegisterRegion;
-    static remove(location: LocationData): boolean;
-    static get(location: LocationData): false | MushRegisterRegion;
+import { SectorMesh } from "./Classes/SectorMesh.js";
+export type MeshRegisterDimensions = Map<string, Map<string, SectorMesh>>;
+declare class Sectors {
+    static add(location: LocationData): SectorMesh;
+    static remove(location: LocationData): false | SectorMesh;
+    static get(location: LocationData): false | SectorMesh | undefined;
 }
 declare class Dimensions {
     static add(id: string): Map<any, any>;
-    static get(id: string): Map<string, MushRegisterRegion> | undefined;
-    static getAllMeshes(id: string): Generator<[location: LocationData, substance: string, mesh: ChunkMeshInterface]>;
+    static get(id: string): Map<string, SectorMesh> | undefined;
+    static getAllMeshes(id: string): Generator<[location: LocationData, substance: string, mesh: any]>;
     static remove(id: string): boolean;
 }
 export declare class MeshRegister {
     static _dimensions: MeshRegisterDimensions;
     static dimensions: typeof Dimensions;
-    static region: typeof Region;
-    static column: typeof Column;
-    static chunk: typeof Chunk;
+    static sectors: typeof Sectors;
     static clearAll(): void;
 }
 export {};

package/Renderer/MeshRegister.js

@@ -1,155 +1,36 @@
-import { Vector3Like } from "@amodx/math";
-import { WorldSpaces } from "../Data/World/WorldSpaces.js";
-import { MushRegisterRegion } from "./Classes/MushRegisterRegion.js";
-import { MeshRegisterColumn } from "./Classes/MeshRegisterColumn.js";
-import { ChunkMesh } from "./Classes/ChunkMesh.js";
-class Chunk {
-    static addMesh(location, mesh, substance) {
-        let column = MeshRegister.column.get(location);
-        if (!column) {
-            column = MeshRegister.column.add(location);
-        }
-        const index = WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]);
-        let chunk = column.chunks.get(index);
-        if (!chunk) {
-            chunk = new ChunkMesh([location[1], location[2], location[3]]);
-            column.chunks.set(index, chunk);
-        }
-        chunk?.meshes.set(substance, mesh);
-        return chunk;
-    }
-    static add(location) {
-        let column = MeshRegister.column.get(location);
-        if (!column) {
-            column = MeshRegister.column.add(location);
-        }
-        const index = WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]);
-        let chunk = column.chunks.get(index);
-        if (!chunk) {
-            chunk = new ChunkMesh([location[1], location[2], location[3]]);
-            column.chunks.set(index, chunk);
-        }
-        return chunk;
-    }
-    static removeMesh(location, substance) {
-        const column = MeshRegister.column.get(location);
-        if (!column)
-            return false;
-        const index = WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]);
-        const chunk = column.chunks.get(index);
-        if (!chunk)
-            return false;
-        const chunkMesh = chunk.meshes.get(substance);
-        if (!chunkMesh)
-            return false;
-        chunk.meshes.delete(substance);
-        if (chunk.meshes.size == 0) {
-            column.chunks.delete(index);
-        }
-        return chunkMesh;
-    }
-    static getMesh(location, substance) {
-        const column = MeshRegister.column.get(location);
-        if (!column)
-            return false;
-        const chunk = column.chunks.get(WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]));
-        if (!chunk)
-            return false;
-        const chunkMesh = chunk.meshes.get(substance);
-        if (!chunkMesh)
-            return false;
-        return chunkMesh;
-    }
-    static remove(location) {
-        const column = MeshRegister.column.get(location);
-        if (!column)
-            return false;
-        const index = WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]);
-        const chunk = column.chunks.get(index);
-        if (!chunk)
-            return false;
-        column.chunks.delete(index);
-        return chunk;
-    }
-    static get(location) {
-        const column = MeshRegister.column.get(location);
-        if (!column)
-            return false;
-        const chunk = column.chunks.get(WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]));
-        if (!chunk)
-            return false;
-        return chunk;
-    }
-}
-class Column {
+import { WorldSpaces } from "../World/WorldSpaces.js";
+import { SectorMesh } from "./Classes/SectorMesh.js";
+class Sectors {
     static add(location) {
-        let region = MeshRegister.region.get(location);
-        if (!region) {
-            region = MeshRegister.region.add(location);
-        }
-        const column = new MeshRegisterColumn([
+        let dimension = MeshRegister.dimensions.get(location[0]);
+        if (!dimension)
+            dimension = MeshRegister.dimensions.add(location[0]);
+        const sector = new SectorMesh([
             location[0],
-            ...Vector3Like.ToArray(WorldSpaces.column.getPositionXYZ(location[1], location[2], location[3])),
+            ...WorldSpaces.sector.getPositionVec3Array(location[1], location[2], location[3]),
         ]);
-        region.columns.set(WorldSpaces.column.getIndexXYZ(location[1], location[2], location[3]), column);
-        return column;
+        dimension.set(WorldSpaces.hash.hashXYZ(location[1], location[2], location[3]), sector);
+        return sector;
     }
     static remove(location) {
-        const region = MeshRegister.region.get(location);
-        if (!region)
+        let dimension = MeshRegister.dimensions.get(location[0]);
+        if (!dimension)
             return false;
-        const index = WorldSpaces.column.getIndexXYZ(location[1], location[2], location[3]);
-        const column = region.columns.get(index);
-        if (!column)
+        const key = WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(location[1], location[2], location[3]));
+        const sector = dimension.get(key);
+        if (!sector)
             return false;
-        region.columns.delete(index);
-        if (region.columns.size == 0) {
-            MeshRegister.region.remove(location);
+        dimension.delete(key);
+        if (dimension.size == 0) {
+            MeshRegister.dimensions.remove(location[0]);
         }
-        return column;
+        return sector;
     }
     static get(location) {
-        const region = MeshRegister.region.get(location);
-        if (!region)
-            return false;
-        return region.columns.get(WorldSpaces.column.getIndexXYZ(location[1], location[2], location[3]));
-    }
-}
-class Region {
-    static add(location) {
         let dimension = MeshRegister.dimensions.get(location[0]);
-        if (!dimension) {
-            dimension = MeshRegister.dimensions.add(location[0]);
-        }
-        const region = new MushRegisterRegion();
-        dimension.set(WorldSpaces.region.getKeyXYZ(location[1], location[2], location[3]), region);
-        return region;
-    }
-    static remove(location) {
-        const region = this.get(location);
-        if (!region)
-            return false;
-        const dimension = MeshRegister.dimensions.get(location[0]);
-        if (!dimension)
-            return false;
-        dimension.delete(WorldSpaces.region.getKeyXYZ(location[1], location[2], location[3]));
-        region.columns.forEach((column) => {
-            column.chunks.forEach((chunk) => {
-                chunk.meshes.forEach((chunkMeshes) => {
-                    chunkMeshes.dispose();
-                });
-            });
-        });
-        return true;
-    }
-    static get(location) {
-        const dimension = MeshRegister.dimensions.get(location[0]);
         if (!dimension)
             return false;
-        const region = dimension.get(WorldSpaces.region.getKeyXYZ(location[1], location[2], location[3]));
-        if (!region)
-            return false;
-        return region;
+        return dimension.get(WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(location[1], location[2], location[3])));
     }
 }
 class Dimensions {
@@ -165,21 +46,19 @@ class Dimensions {
         const dimension = MeshRegister._dimensions.get(id);
         if (!dimension)
             return;
-        for (const [key, region] of dimension) {
-            for (const [columnKey, column] of region.columns) {
-                for (const [chunkKey, chunk] of column.chunks) {
-                    for (const [substance, mesh] of chunk.meshes) {
-                        yield [
-                            [
-                                column.location[0],
-                                column.location[1],
-                                column.location[2] + chunkKey * WorldSpaces.chunk._bounds.y,
-                                column.location[3],
-                            ],
-                            substance,
-                            mesh,
-                        ];
-                    }
+        for (const [key, sector] of dimension) {
+            for (let i = 0; i < sector.sections.length; i++) {
+                for (const [substance, mesh] of sector.sections[i].meshes) {
+                    yield [
+                        [
+                            sector.location[0],
+                            sector.location[1],
+                            sector.location[2] + i * WorldSpaces.section.bounds.y,
+                            sector.location[3],
+                        ],
+                        substance,
+                        mesh,
+                    ];
                 }
             }
         }
@@ -188,12 +67,10 @@ class Dimensions {
         const dimension = MeshRegister._dimensions.get(id);
         if (!dimension)
             return false;
-        dimension.forEach((region) => {
-            region.columns.forEach((column) => {
-                column.chunks.forEach((chunk) => {
-                    chunk.meshes.forEach((chunkMeshes) => {
-                        chunkMeshes.dispose();
-                    });
+        dimension.forEach((sector) => {
+            sector.sections.forEach((section) => {
+                section.meshes.forEach((sectionMeshes) => {
+                    sectionMeshes.dispose();
                 });
             });
         });
@@ -202,12 +79,9 @@ class Dimensions {
     }
 }
 export class MeshRegister {
-    // Main dimensions data store
     static _dimensions = new Map([["main", new Map()]]);
     static dimensions = Dimensions;
-    static region = Region;
-    static column = Column;
-    static chunk = Chunk;
+    static sectors = Sectors;
     static clearAll() {
         for (const [dkey, dim] of this._dimensions) {
             this.dimensions.remove(dkey);

package/Renderer/Renderer.types.d.ts

@@ -0,0 +1,21 @@
+import { CompactMeshData } from "../Mesher/Types/Mesher.types";
+import type { LocationData } from "../Math/index";
+export type SetSectionMeshTask = [
+    location: LocationData,
+    meshes: CompactMeshData,
+    effects: SectionEffectData[],
+    priority: number
+];
+export type SectionEffectData = [id: string, data: any];
+export type SectionMeshData = [
+    substanceType: string,
+    meshData: [location: LocationData, mesh: CompactMeshData]
+];
+export type RemoveSectionMeshTasks = [
+    location: LocationData,
+    substanceType: string
+];
+export type RemoveSectionsOutsideDistance = [
+    location: LocationData,
+    distance: number
+];

package/Renderer/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Classes/DVESectionMeshes";
+export * from "./Classes/SectionMesh";
+export * from "./Classes/SectorMesh";

package/Renderer/index.js

@@ -0,0 +1,3 @@
+export * from "./Classes/DVESectionMeshes";
+export * from "./Classes/SectionMesh";
+export * from "./Classes/SectorMesh";

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 {};