@divinevoxel/vlox 0.0.5 → 0.0.7

package/Textures/TextureBuilder.d.ts

@@ -4,7 +4,7 @@ export declare class TextureBuilder {
     static finalImagWidth: number;
     static finalImageHeight: number;
     static _canvas: HTMLCanvasElement;
-    static defineTextureDimensions(textureSize: number, mipMapSizes: number[]): void;
+    static defineTextureDimensions(textureSize: number): void;
     static setUpImageCreation(): void;
     static createMaterialTexture(name: string, images: Map<string, HTMLImageElement | string | false>, width?: number, height?: number): Promise<HTMLImageElement[]>;
     static getRawData(imageSrc: string): Promise<Uint8ClampedArray>;

package/Textures/TextureBuilder.js

@@ -4,7 +4,7 @@ export class TextureBuilder {
     static finalImagWidth = 16;
     static finalImageHeight = 16;
     static _canvas = document.createElement("canvas");
-    static defineTextureDimensions(textureSize, mipMapSizes) {
+    static defineTextureDimensions(textureSize) {
         this.finalImagWidth = textureSize < 256 ? 256 : textureSize;
         this.finalImageHeight = textureSize < 256 ? 256 : textureSize;
         this._textureSize = textureSize;

package/Textures/TextureManager.js

@@ -17,7 +17,7 @@ export class TextureManager {
         return this._ready;
     }
     static async init() {
-        TextureBuilder.defineTextureDimensions(EngineSettings.settings.textures.textureSize, EngineSettings.settings.textures.mipMapSizes);
+        TextureBuilder.defineTextureDimensions(EngineSettings.settings.textures.textureSize);
         for (const [key, type] of this.textureTypes) {
             await type.build();
         }

package/Tools/Brush/Brush.d.ts

@@ -26,6 +26,7 @@ export declare class BrushTool {
     setLevelState(levelState: number): this;
     setMod(mod: number): this;
     clear(): void;
+    _debug: boolean;
     _paint(): false | undefined;
     _erase(): void;
     paint(): this;

package/Tools/Brush/Brush.js

@@ -29,8 +29,7 @@ export class BrushTool {
         return this;
     }
     newSector() {
-        WorldRegister.setDimension(this.dimension);
-        WorldRegister.sectors.new(this.x, this.y, this.z);
+        WorldRegister.sectors.new(this.dimension, this.x, this.y, this.z);
     }
     setData(data) {
         this.data.id = data.id ? data.id : airId;
@@ -103,6 +102,7 @@ export class BrushTool {
         this.y = 0;
         this.z = 0;
     }
+    _debug = false;
     _paint() {
         if (!this.dataCursor.inBounds(this.x, this.y, this.z))
             return false;
@@ -113,7 +113,10 @@ export class BrushTool {
         if (id < 0)
             return false;
         voxel.setId(id);
-        voxel.setState(this.data.state ? this.data.state : 0);
+        if (this._debug) {
+            console.warn(this.x, this.y, this.z, this.data.state);
+        }
+        voxel.setState(this.data.state);
         voxel.setLevel(this.data.level);
         voxel.setMod(this.data.mod);
         if (this.data.secondaryVoxelId) {
@@ -127,19 +130,13 @@ export class BrushTool {
         if (voxel.isLightSource() && voxel.getLightSourceValue()) {
             voxel.setLight(voxel.getLightSourceValue());
         }
-        /*    if (this.voxelCursor.isRich()) {
-          DataHooks.paint.onRichVoxelPaint.notify([
-            this.voxelCursor.getStringId(),
-            [this.dimenion, x, y, z],
-          ]);
-        } */
-        voxel.updateHeightMap(0);
+        voxel.updateVoxel(0);
     }
     _erase() {
         const voxel = this.dataCursor.getVoxel(this.x, this.y, this.z);
         if (!voxel)
             return;
-        voxel.copyRaw(air).updateHeightMap(1);
+        voxel.copyRaw(air).updateVoxel(1);
     }
     paint() {
         this._paint();

package/Voxels/Cursor/VoxelCursor.d.ts

@@ -9,4 +9,5 @@ export declare class VoxelCursor extends VoxelCursorInterface {
     secondary: number[];
     mod: number[];
     loadIn(): void;
+    updateVoxel(mode: 0 | 1): void;
 }

package/Voxels/Cursor/VoxelCursor.interface.d.ts

@@ -19,6 +19,11 @@ export declare abstract class VoxelCursorInterface {
     abstract state: WritableArrayLike<number>;
     abstract secondary: WritableArrayLike<number>;
     abstract mod: WritableArrayLike<number>;
+    /**
+     *
+     * @param mode 0 for add 1 for remove
+     */
+    abstract updateVoxel(mode: 0 | 1): void;
     _lightData: VoxelLightData;
     _substanceData: SubstanceDataTool;
     process(): void;

package/Voxels/Cursor/VoxelCursor.interface.js

@@ -2,7 +2,7 @@ import { VoxelStructIds } from "../Types/Voxel.types";
 import { VoxelLightData } from "./VoxelLightData";
 import { MappedDataRegister } from "../../Data/Register/MappedDataRegister";
 import { VoxelStruct } from "../Structs/VoxelStruct";
-import { VoxelStateReader } from "../VoxelStateReader";
+import { VoxelLevelReader } from "../VoxelLevelReader";
 import { VoxelTagStates } from "../State/VoxelTagStates";
 import { VoxelPalette } from "../Palettes/VoxelPalette";
 import { SubstancePalette } from "../Palettes/SubstancePalette";
@@ -84,17 +84,17 @@ export class VoxelCursorInterface {
         return this;
     }
     getLevel() {
-        return VoxelStateReader.getLevel(this.level[this._index]);
+        return VoxelLevelReader.getLevel(this.level[this._index]);
     }
     setLevel(level) {
-        this.level[this._index] = VoxelStateReader.setLevel(this.level[this._index], level);
+        this.level[this._index] = VoxelLevelReader.setLevel(this.level[this._index], level);
         return this;
     }
     getLevelState() {
-        return VoxelStateReader.getLevelState(this.level[this._index]);
+        return VoxelLevelReader.getLevelState(this.level[this._index]);
     }
     setLevelState(state) {
-        this.level[this._index] = VoxelStateReader.setLevelState(this.level[this._index], state);
+        this.level[this._index] = VoxelLevelReader.setLevelState(this.level[this._index], state);
         return this;
     }
     getState() {

package/Voxels/Cursor/VoxelCursor.js

@@ -1,6 +1,6 @@
 import { VoxelCursorInterface } from "./VoxelCursor.interface";
 import { VoxelPalette } from "../../Voxels/Palettes/VoxelPalette";
-import { VoxelStateReader } from "../../Voxels/VoxelStateReader";
+import { VoxelLevelReader } from "../VoxelLevelReader";
 export class VoxelCursor extends VoxelCursorInterface {
     static VoxelDataToRaw(data, light = 0) {
         const id = (data.id !== undefined && VoxelPalette.ids.getNumberId(data.id)) || 0;
@@ -9,9 +9,9 @@ export class VoxelCursor extends VoxelCursorInterface {
             0;
         let levleData = 0;
         if (data.level !== undefined)
-            levleData = VoxelStateReader.setLevel(levleData, data.level);
+            levleData = VoxelLevelReader.setLevel(levleData, data.level);
         if (data.levelState !== undefined)
-            levleData = VoxelStateReader.setLevelState(levleData, data.levelState);
+            levleData = VoxelLevelReader.setLevelState(levleData, data.levelState);
         return [id, light, levleData, data.state || 0, data.mod || 0, secondaryId];
     }
     ids = [0];
@@ -21,4 +21,6 @@ export class VoxelCursor extends VoxelCursorInterface {
     secondary = [0];
     mod = [0];
     loadIn() { }
+    updateVoxel(mode) {
+    }
 }

package/Voxels/VoxelLevelReader.d.ts

@@ -0,0 +1,10 @@
+/**# Voxel Reader
+ * ---
+ * Used to decode voxel state data.
+ */
+export declare class VoxelLevelReader {
+    static getLevel(levelData: number): number;
+    static setLevel(levelData: number, level: number): number;
+    static getLevelState(levelData: number): number;
+    static setLevelState(levelData: number, levelState: number): number;
+}

package/Voxels/VoxelLevelReader.js

@@ -0,0 +1,20 @@
+const LEVEL_MASK = 0b0000_1111;
+const LEVEL_STATE_MASK = 0b1111_0000;
+/**# Voxel Reader
+ * ---
+ * Used to decode voxel state data.
+ */
+export class VoxelLevelReader {
+    static getLevel(levelData) {
+        return levelData & LEVEL_MASK;
+    }
+    static setLevel(levelData, level) {
+        return (levelData & ~LEVEL_MASK) | level;
+    }
+    static getLevelState(levelData) {
+        return (levelData & LEVEL_STATE_MASK) >> 4;
+    }
+    static setLevelState(levelData, levelState) {
+        return (levelData & ~LEVEL_STATE_MASK) | (levelState << 4);
+    }
+}

package/World/Archive/Functions/ArchiveSector.d.ts

@@ -3,5 +3,5 @@ import { ArchivedSectorData } from "../Archive.types";
 type ArchiveColumnProps = {
     location: LocationData;
 };
-export default function ArchiveColumn(archiveData: ArchiveColumnProps): ArchivedSectorData;
+export default function ArchiveSector(archiveData: ArchiveColumnProps): ArchivedSectorData;
 export {};

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.d.ts

@@ -13,5 +13,6 @@ export declare class SectorCursor extends DataCursorInterface implements WorldSe
     _sectorPosition: Vector3Like;
     inBounds(x: number, y: number, z: number): boolean;
     setSector(dimension: string, x: number, y: number, z: number): boolean;
+    getSection(x: number, y: number, z: number): Section | null;
     getVoxel(x: number, y: number, z: number): WorldVoxelCursor | null;
 }

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;
@@ -39,7 +38,7 @@ export class SectorCursor extends DataCursorInterface {
         this._sectorPosition.z = sector.position[2];
         return true;
     }
-    getVoxel(x, y, z) {
+    getSection(x, y, z) {
         if (!this._current)
             return null;
         const section = this._current.sections[WorldSpaces.section.getIndex(x, y, z)];
@@ -49,6 +48,12 @@ export class SectorCursor extends DataCursorInterface {
             this._section = null;
             return null;
         }
+        return section;
+    }
+    getVoxel(x, y, z) {
+        if (!this._current)
+            return null;
+        const section = this.getSection(x, y, z);
         this._section = section;
         this._voxelIndex = WorldSpaces.voxel.getIndex(x, y, z);
         WorldSpaces.voxel.getPosition(x, y, z, this._voxelPosition);

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/Cursor/WorldVoxelCursor.d.ts

@@ -14,10 +14,6 @@ export declare class WorldVoxelCursor extends VoxelCursorInterface {
     /**
      *
      * @param mode 0 for add 1 for remove
-     * @param x
-     * @param y
-     * @param z
-     * @returns
      */
-    updateHeightMap(mode: 0 | 1): boolean;
+    updateVoxel(mode: 0 | 1): boolean;
 }

package/World/Cursor/WorldVoxelCursor.js

@@ -36,12 +36,8 @@ export class WorldVoxelCursor extends VoxelCursorInterface {
     /**
      *
      * @param mode 0 for add 1 for remove
-     * @param x
-     * @param y
-     * @param z
-     * @returns
      */
-    updateHeightMap(mode) {
+    updateVoxel(mode) {
         Section.StateStruct.setData(this._section.sectionState);
         const voxelPos = this.dataCursor._voxelPosition;
         if (mode == 0) {

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, minY: number, minZ: number, maxX: number, maxY: number, maxZ: 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;