@divinevoxel/vlox 0.0.5 → 0.0.6

package/World/Archive/Functions/ArchiveSector.js

@@ -132,9 +132,8 @@ function GetArchivedSection(archiveSection, sectorPalettes) {
         },
     };
 }
-export default function ArchiveColumn(archiveData) {
-    WorldRegister.setDimension(archiveData.location[0]);
-    const sector = WorldRegister.sectors.get(archiveData.location[1], archiveData.location[2], archiveData.location[3]);
+export default function ArchiveSector(archiveData) {
+    const sector = WorldRegister.sectors.get(archiveData.location[0], archiveData.location[1], archiveData.location[2], archiveData.location[3]);
     if (!sector)
         throw new Error(`Column at location ${location} does not exist when trying to arhicve it.`);
     if (!sectorStructInstance)

package/World/Archive/InitTasks.js

@@ -2,10 +2,9 @@ import { Threads } from "@amodx/threads";
 import ArchiveSector from "./Functions/ArchiveSector";
 import { WorldRegister } from "../WorldRegister";
 import ImportSector from "./Functions/ImportSector";
-import { compressBinaryObject, expandBinaryObject } from "../../Util/BinaryObject";
+import { compressBinaryObject, expandBinaryObject, } from "../../Util/BinaryObject";
 function runArchiveSector(location) {
-    WorldRegister.setDimension(location[0]);
-    const sector = WorldRegister.sectors.get(location[1], location[2], location[3]);
+    const sector = WorldRegister.sectors.get(location[0], location[1], location[2], location[3]);
     if (!sector)
         throw new Error(`Sector at location ${location.toString()} does not exist`);
     const archived = ArchiveSector({

package/World/Cursor/SectionCursor.js

@@ -36,8 +36,7 @@ export class SectionCursor extends DataCursorInterface {
             this._sectionPosition.z = sectionPos[2];
             return;
         }
-        WorldRegister.setDimension(sectionOrDimension);
-        const sector = WorldRegister.sectors.get(x || 0, y || 0, z || 0);
+        const sector = WorldRegister.sectors.get(sectionOrDimension, x || 0, y || 0, z || 0);
         if (!sector)
             return false;
         this._section = sector.getSection(y || 0);

package/World/Cursor/SectorCursor.js

@@ -29,8 +29,7 @@ export class SectorCursor extends DataCursorInterface {
         return true;
     }
     setSector(dimension, x, y, z) {
-        WorldRegister.setDimension(dimension);
-        const sector = WorldRegister.sectors.get(x, y, z);
+        const sector = WorldRegister.sectors.get(dimension, x, y, z);
         if (!sector)
             return false;
         this._current = sector;

package/World/Cursor/WorldCursor.js

@@ -2,7 +2,6 @@ import { Vector3Like } from "@amodx/math";
 import { SectorCursor } from "./SectorCursor";
 import { WorldSpaces } from "../WorldSpaces";
 import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
-import { WorldBounds } from "../WorldBounds";
 let cursorCache = [];
 const tempPosition = Vector3Like.Create();
 export class WorldCursor extends DataCursorInterface {
@@ -23,7 +22,7 @@ export class WorldCursor extends DataCursorInterface {
         this.origin.z = sectorPos.z / WorldSpaces.sector.bounds.z;
     }
     inBounds(x, y, z) {
-        return WorldBounds.inBounds(x, y, z);
+        return WorldSpaces.world.inBounds(x, y, z);
     }
     getSector(x, y, z) {
         const sectorPos = WorldSpaces.sector.getPosition(x, y, z, tempPosition);

package/World/InitTasks.js

@@ -29,8 +29,7 @@ export default function ({ threads, worldStorage, }) {
         }
     };
     Threads.registerTask("add-sector", async (location) => {
-        WorldRegister.setDimension(location[0]);
-        const sector = WorldRegister.sectors.get(location[1], location[2], location[3]);
+        const sector = WorldRegister.sectors.get(location[0], location[1], location[2], location[3]);
         if (sector) {
             for (const thread of threads) {
                 thread.runTask(WorldDataSyncIds.SyncSector, [location, sector]);
@@ -38,8 +37,7 @@ export default function ({ threads, worldStorage, }) {
             return;
         }
         if (!sector && !worldStorage) {
-            WorldRegister.setDimension(location[0]);
-            WorldRegister.sectors.new(location[1], location[2], location[3]);
+            WorldRegister.sectors.new(location[0], location[1], location[2], location[3]);
         }
         if (worldStorage) {
             const sectorPos = WorldSpaces.sector.getPosition(location[1], location[2], location[3]);
@@ -56,8 +54,7 @@ export default function ({ threads, worldStorage, }) {
             const success = await worldStorage.loadSector(sectorLocation);
             loadInMap.delete(sectorId);
             if (!success) {
-                WorldRegister.setDimension(sectorLocation[0]);
-                WorldRegister.sectors.new(sectorLocation[1], sectorLocation[2], sectorLocation[3]);
+                WorldRegister.sectors.new(sectorLocation[0], sectorLocation[1], sectorLocation[2], sectorLocation[3]);
             }
             return;
         }
@@ -71,16 +68,14 @@ export default function ({ threads, worldStorage, }) {
     Threads.registerTask("unload-sector", (location) => {
         if (WorldLock.isLocked(location))
             return [false];
-        WorldRegister.setDimension(location[0]);
-        WorldRegister.sectors.remove(location[1], location[2], location[3]);
+        WorldRegister.sectors.remove(location[0], location[1], location[2], location[3]);
         for (const thread of threads) {
             thread.runTask(WorldDataSyncIds.UnSyncSector, location);
         }
         return [false];
     });
     Threads.registerTask("load-sector", ([location, sector]) => {
-        WorldRegister.setDimension(location[0]);
-        WorldRegister.sectors.add(location[1], location[2], location[3], sector);
+        WorldRegister.sectors.add(location[0], location[1], location[2], location[3], sector);
         for (const thread of threads) {
             thread.runTask(WorldDataSyncIds.SyncSector, [location, sector]);
         }

package/World/Lock/WorldLock.js

@@ -23,8 +23,7 @@ export class WorldLock {
                                 sectorPos.z,
                             ];
                             location[0] = dim;
-                            WorldRegister.setDimension(location[0]);
-                            if (WorldRegister.sectors.get(location[1], location[2], location[3]))
+                            if (WorldRegister.sectors.get(location[0], location[1], location[2], location[3]))
                                 continue;
                             allFound = false;
                             const key = location.toString();
@@ -33,7 +32,7 @@ export class WorldLock {
                             this._loadMap.set(key, true);
                             let success = false;
                             if (!this.worldStorage) {
-                                if (WorldRegister.sectors.get(location[1], location[2], location[3])) {
+                                if (WorldRegister.sectors.get(location[0], location[1], location[2], location[3])) {
                                     success = true;
                                 }
                             }
@@ -41,10 +40,10 @@ export class WorldLock {
                                 success = await this.worldStorage.loadSector(location);
                             }
                             this._loadMap.delete(key);
-                            if (WorldRegister.sectors.get(location[1], location[2], location[3]))
+                            if (WorldRegister.sectors.get(location[0], location[1], location[2], location[3]))
                                 return;
                             if (!success) {
-                                WorldRegister.sectors.new(location[1], location[2], location[3]);
+                                WorldRegister.sectors.new(location[0], location[1], location[2], location[3]);
                             }
                         }
                     }

package/World/Sector/SectorHeightMap.js

@@ -1,6 +1,5 @@
 import { $2dMooreNeighborhood } from "../../Math/CardinalNeighbors";
 import { SectionHeightMap } from "../Section/SectionHeightMap";
-import { WorldBounds } from "../WorldBounds";
 import { WorldRegister } from "../WorldRegister";
 import { WorldSpaces } from "../WorldSpaces";
 export class SectorHeightMap {
@@ -21,13 +20,12 @@ export class SectorHeightMap {
         return maxHeight;
     }
     static getAbsolute(location) {
-        WorldRegister.setDimension(location[0]);
-        const sector = WorldRegister.sectors.get(location[1], location[2], location[3]);
+        const sector = WorldRegister.sectors.get(location[0], location[1], location[2], location[3]);
         if (!sector)
-            return WorldBounds.bounds.MinY;
+            return WorldSpaces.world.bounds.MinY;
         if (sector.sections.length == 0)
-            return WorldBounds.bounds.MinY;
-        let maxHeight = WorldBounds.bounds.MinY;
+            return WorldSpaces.world.bounds.MinY;
+        let maxHeight = WorldSpaces.world.bounds.MinY;
         const positon = [location[1], location[2], location[3]];
         let y = positon[1];
         for (let i = 0; i < sector.sections.length; i++) {

package/World/WorldRegister.d.ts

@@ -18,18 +18,16 @@ declare class WorldRegisterDimensions {
 }
 declare class WorldRegisterSectors {
     static setSecotrPool(enabled: boolean): void;
-    static add(x: number, y: number, z: number, sector: SectorData): Sector;
-    static new(x: number, y: number, z: number): boolean;
-    static get(x: number, y: number, z: number): false | Sector;
-    static remove(x: number, y: number, z: number): boolean;
+    static add(dimensionId: string, x: number, y: number, z: number, sector: SectorData): Sector;
+    static new(dimensionId: string, x: number, y: number, z: number): boolean;
+    static get(dimensionId: string, x: number, y: number, z: number): false | Sector;
+    static remove(dimensionId: string, x: number, y: number, z: number): boolean;
 }
 export declare class WorldRegister {
     static _dimensions: Map<string, Dimension>;
     static _hooks: typeof WorldDataHooks;
     static dimensions: typeof WorldRegisterDimensions;
     static sectors: typeof WorldRegisterSectors;
-    static _currentDimension: Dimension;
-    static setDimension(dimensionId: string): void;
     static clearAll(): void;
 }
 export {};

package/World/WorldRegister.js

@@ -42,33 +42,45 @@ class WorldRegisterSectors {
         SectorPool._enabled = enabled;
         SectorPool._secotrs.length = 0;
     }
-    static add(x, y, z, sector) {
+    static add(dimensionId, x, y, z, sector) {
+        let dimension = WorldRegister.dimensions.get(dimensionId);
+        if (!dimension)
+            dimension = WorldRegister.dimensions.add(dimensionId);
         WorldSpaces.sector.getPositionVec3Array(x, y, z, sector.position);
         const newSector = new Sector(sector);
-        WorldRegister._currentDimension.sectors.set(WorldSpaces.hash.hashVec3Array(newSector.position), newSector);
+        dimension.sectors.set(WorldSpaces.hash.hashVec3Array(newSector.position), newSector);
         return newSector;
     }
-    static new(x, y, z) {
-        if (this.get(x, y, z))
+    static new(dimensionId, x, y, z) {
+        if (this.get(dimensionId, x, y, z))
             return false;
-        const sector = this.add(x, y, z, Sector.CreateNew());
-        WorldDataHooks.sectors.onNew([WorldRegister._currentDimension.id, x, y, z], sector);
+        let dimension = WorldRegister.dimensions.get(dimensionId);
+        if (!dimension)
+            dimension = WorldRegister.dimensions.add(dimensionId);
+        const sector = this.add(dimensionId, x, y, z, Sector.CreateNew());
+        WorldDataHooks.sectors.onNew([dimensionId, x, y, z], sector);
         return true;
     }
-    static get(x, y, z) {
-        const sector = WorldRegister._currentDimension.sectors.get(WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(x, y, z, tempPosition)));
+    static get(dimensionId, x, y, z) {
+        let dimension = WorldRegister.dimensions.get(dimensionId);
+        if (!dimension)
+            return false;
+        const sector = dimension.sectors.get(WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(x, y, z, tempPosition)));
         return sector || false;
     }
-    static remove(x, y, z) {
+    static remove(dimensionId, x, y, z) {
+        let dimension = WorldRegister.dimensions.get(dimensionId);
+        if (!dimension)
+            return false;
         const position = WorldSpaces.sector.getPosition(x, y, z, tempPosition);
         const sectorKey = WorldSpaces.hash.hashVec3(position);
-        const sector = WorldRegister._currentDimension.sectors.get(sectorKey);
+        const sector = dimension.sectors.get(sectorKey);
         if (!sector)
             return false;
         if (SectorPool._enabled)
             SectorPool.returnSector(sector);
-        WorldRegister._currentDimension.sectors.delete(sectorKey);
-        WorldDataHooks.sectors.onRemove([WorldRegister._currentDimension.id, position.x, position.y, position.z], sector);
+        WorldDataHooks.sectors.onRemove([dimensionId, position.x, position.y, position.z], sector);
+        dimension.sectors.delete(sectorKey);
         return true;
     }
 }
@@ -77,14 +89,6 @@ export class WorldRegister {
     static _hooks = WorldDataHooks;
     static dimensions = WorldRegisterDimensions;
     static sectors = WorldRegisterSectors;
-    static _currentDimension;
-    static setDimension(dimensionId) {
-        let dimension = this.dimensions.get(dimensionId);
-        if (!dimension) {
-            dimension = this.dimensions.add(dimensionId);
-        }
-        this._currentDimension = dimension;
-    }
     static clearAll() {
         this._dimensions.clear();
     }

package/World/WorldSpaces.d.ts

@@ -1,4 +1,24 @@
 import { Vec3Array, Vector3Like } from "@amodx/math";
+declare class WorldBounds {
+    static bounds: {
+        MinZ: number;
+        MaxZ: number;
+        MinX: number;
+        MaxX: number;
+        MinY: number;
+        MaxY: number;
+    };
+    static setWorldBounds(minX: number, maxX: number, minZ: number, maxZ: number, minY: number, maxY: number): void;
+    static inBounds(x: number, y: number, z: number): boolean;
+    static getWorldWidth(): number;
+    static getWorldDepth(): number;
+    static getWorldHeightY(): number;
+    static getWorldDimensions(): {
+        width: number;
+        depth: number;
+        height: number;
+    };
+}
 declare class SectorSpace {
     static power2Axes: Vector3Like;
     static bounds: Vector3Like;
@@ -27,6 +47,7 @@ declare class Hash {
 }
 export declare class WorldSpaces {
     static hash: typeof Hash;
+    static world: typeof WorldBounds;
     static sector: typeof SectorSpace;
     static section: typeof SectionSpace;
     static voxel: typeof VoxelSpace;

package/World/WorldSpaces.js

@@ -4,6 +4,55 @@ import { Vector3Like } from "@amodx/math";
 import { CubeHashVec3, CubeHashVec3Array, GetYXZOrderArrayIndex, } from "../Math/Indexing.js";
 const tempPosition = Vector3Like.Create();
 const tempPosition2 = Vector3Like.Create();
+class WorldBounds {
+    static bounds = {
+        MinZ: -Number.MAX_SAFE_INTEGER,
+        MaxZ: Number.MAX_SAFE_INTEGER,
+        MinX: -Number.MAX_SAFE_INTEGER,
+        MaxX: Number.MAX_SAFE_INTEGER,
+        MinY: 0,
+        MaxY: 256,
+    };
+    static setWorldBounds(minX, maxX, minZ, maxZ, minY, maxY) {
+        this.bounds.MinX = minX;
+        this.bounds.MaxX = maxX;
+        this.bounds.MinX = minZ;
+        this.bounds.MaxZ = maxZ;
+        this.bounds.MinY = minY;
+        this.bounds.MaxY = maxY;
+    }
+    static inBounds(x, y, z) {
+        if (x < this.bounds.MinX)
+            return false;
+        if (y < this.bounds.MinY)
+            return false;
+        if (z < this.bounds.MinZ)
+            return false;
+        if (x > this.bounds.MaxX)
+            return false;
+        if (y > this.bounds.MaxY)
+            return false;
+        if (z > this.bounds.MaxZ)
+            return false;
+        return true;
+    }
+    static getWorldWidth() {
+        return this.bounds.MaxX - this.bounds.MinX;
+    }
+    static getWorldDepth() {
+        return this.bounds.MaxZ - this.bounds.MinZ;
+    }
+    static getWorldHeightY() {
+        return this.bounds.MaxY - this.bounds.MinY;
+    }
+    static getWorldDimensions() {
+        return {
+            width: this.getWorldWidth(),
+            depth: this.getWorldDepth(),
+            height: this.getWorldHeightY(),
+        };
+    }
+}
 class SectorSpace {
     static power2Axes = Vector3Like.Create();
     static bounds = Vector3Like.Create();
@@ -69,21 +118,23 @@ class Hash {
 }
 export class WorldSpaces {
     static hash = Hash;
+    static world = WorldBounds;
     static sector = SectorSpace;
     static section = SectionSpace;
     static voxel = VoxelSpace;
 }
 EngineSettings.addEventListener("synced", (event) => {
-    event.detail.settings;
-    SectorSpace.power2Axes.x = EngineSettings.settings.sectors.sectorXPow2;
-    SectorSpace.power2Axes.y = EngineSettings.settings.sectors.sectorYPow2;
-    SectorSpace.power2Axes.z = EngineSettings.settings.sectors.sectorZPow2;
+    const { settings } = event.detail.settings;
+    WorldBounds.setWorldBounds(settings.world.minX, settings.world.maxX, settings.world.minZ, settings.world.maxZ, settings.world.minY, settings.world.maxY);
+    SectorSpace.power2Axes.x = settings.sectors.sectorXPow2;
+    SectorSpace.power2Axes.y = settings.sectors.sectorYPow2;
+    SectorSpace.power2Axes.z = settings.sectors.sectorZPow2;
     SectorSpace.bounds.x = 1 << SectorSpace.power2Axes.x;
     SectorSpace.bounds.y = 1 << SectorSpace.power2Axes.y;
     SectorSpace.bounds.z = 1 << SectorSpace.power2Axes.z;
-    SectionSpace.power2Axes.x = EngineSettings.settings.sections.sectionXPow2;
-    SectionSpace.power2Axes.y = EngineSettings.settings.sections.sectionYPow2;
-    SectionSpace.power2Axes.z = EngineSettings.settings.sections.sectionZPow2;
+    SectionSpace.power2Axes.x = settings.sections.sectionXPow2;
+    SectionSpace.power2Axes.y = settings.sections.sectionYPow2;
+    SectionSpace.power2Axes.z = settings.sections.sectionZPow2;
     SectionSpace.bounds.x = 1 << SectionSpace.power2Axes.x;
     SectionSpace.bounds.y = 1 << SectionSpace.power2Axes.y;
     SectionSpace.bounds.z = 1 << SectionSpace.power2Axes.z;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@divinevoxel/vlox",
-  "version": "0.0.05",
+  "version": "0.0.06",
   "description": "Vlox a block style voxel engine.",
   "main": "index.js",
   "types": "index.d.ts",

package/Mesher/Geomtry/Mesh.d.ts

@@ -1,11 +0,0 @@
-import { Vector3Like } from "@amodx/math";
-export declare class Mesh {
-    buildBVH?: boolean | undefined;
-    indicieIndex: number;
-    minBounds: Vector3Like;
-    maxBounds: Vector3Like;
-    readonly buffer: number[];
-    readonly indices: number[];
-    constructor(buildBVH?: boolean | undefined);
-    clear(): void;
-}

package/Mesher/Geomtry/Mesh.js

@@ -1,23 +0,0 @@
-import { Vector3Like } from "@amodx/math";
-export class Mesh {
-    buildBVH;
-    indicieIndex = 0;
-    minBounds = Vector3Like.Create(Infinity, Infinity, Infinity);
-    maxBounds = Vector3Like.Create(-Infinity, -Infinity, -Infinity);
-    buffer = [];
-    indices = [];
-    constructor(buildBVH) {
-        this.buildBVH = buildBVH;
-    }
-    clear() {
-        this.buffer.length = 0;
-        this.indices.length = 0;
-        this.indicieIndex = 0;
-        this.minBounds.x = Infinity;
-        this.minBounds.y = Infinity;
-        this.minBounds.z = Infinity;
-        this.maxBounds.x = -Infinity;
-        this.maxBounds.y = -Infinity;
-        this.maxBounds.z = -Infinity;
-    }
-}

package/Renderer/Classes/DVESectionMeshInterface.d.ts

@@ -1,3 +0,0 @@
-export interface DVESectionMeshInterface {
-    dispose(): void;
-}

package/Renderer/Classes/DVESectionMeshInterface.js

@@ -1 +0,0 @@
-export {};

package/World/WorldBounds.d.ts

@@ -1,20 +0,0 @@
-export declare class WorldBounds {
-    static bounds: {
-        MinZ: number;
-        MaxZ: number;
-        MinX: number;
-        MaxX: number;
-        MinY: number;
-        MaxY: number;
-    };
-    static setWorldBounds(minX: number, maxX: number, minZ: number, maxZ: number, minY: number, maxY: number): void;
-    static inBounds(x: number, y: number, z: number): boolean;
-    static getWorldWidth(): number;
-    static getWorldDepth(): number;
-    static getWorldHeightY(): number;
-    static getWorldDimensions(): {
-        width: number;
-        depth: number;
-        height: number;
-    };
-}

package/World/WorldBounds.js

@@ -1,53 +0,0 @@
-import { EngineSettings } from "../Settings/EngineSettings";
-export class WorldBounds {
-    static bounds = {
-        MinZ: -Number.MAX_SAFE_INTEGER,
-        MaxZ: Number.MAX_SAFE_INTEGER,
-        MinX: -Number.MAX_SAFE_INTEGER,
-        MaxX: Number.MAX_SAFE_INTEGER,
-        MinY: 0,
-        MaxY: 256,
-    };
-    static setWorldBounds(minX, maxX, minZ, maxZ, minY, maxY) {
-        this.bounds.MinX = minX;
-        this.bounds.MaxX = maxX;
-        this.bounds.MinX = minZ;
-        this.bounds.MaxZ = maxZ;
-        this.bounds.MinY = minY;
-        this.bounds.MaxY = maxY;
-    }
-    static inBounds(x, y, z) {
-        if (x < this.bounds.MinX)
-            return false;
-        if (y < this.bounds.MinY)
-            return false;
-        if (z < this.bounds.MinZ)
-            return false;
-        if (x > this.bounds.MaxX)
-            return false;
-        if (y > this.bounds.MaxY)
-            return false;
-        if (z > this.bounds.MaxZ)
-            return false;
-        return true;
-    }
-    static getWorldWidth() {
-        return this.bounds.MaxX - this.bounds.MinX;
-    }
-    static getWorldDepth() {
-        return this.bounds.MaxZ - this.bounds.MinZ;
-    }
-    static getWorldHeightY() {
-        return this.bounds.MaxY - this.bounds.MinY;
-    }
-    static getWorldDimensions() {
-        return {
-            width: this.getWorldWidth(),
-            depth: this.getWorldDepth(),
-            height: this.getWorldHeightY(),
-        };
-    }
-}
-EngineSettings.addEventListener("synced", ({ detail: { settings: { settings }, }, }) => {
-    WorldBounds.setWorldBounds(settings.world.minX, settings.world.maxX, settings.world.minZ, settings.world.maxZ, settings.world.minY, settings.world.maxY);
-});