@divinevoxel/vlox 0.0.73 → 0.0.75

package/World/SnapShot/SectionSnapShot.d.ts

@@ -0,0 +1,19 @@
+import { Flat3DIndex } from "@amodx/math";
+import { LocationData } from "../../Math";
+export interface SectionSnapShotTransferData {
+    location: LocationData;
+    sections: Uint8Array[];
+}
+export declare class SectionSnapShot {
+    sections: Uint8Array[];
+    location: LocationData;
+    index: Flat3DIndex;
+    private _buffers;
+    constructor();
+    setLocation([dimension, x, y, z]: LocationData): void;
+    storeSnapShot(): void;
+    private _isTransfered;
+    isTransfered(): boolean;
+    transfer(): [SectionSnapShotTransferData, ArrayBuffer[]];
+    restore(data: SectionSnapShotTransferData): void;
+}

package/World/SnapShot/SectionSnapShot.js

@@ -0,0 +1,72 @@
+import { Flat3DIndex } from "@amodx/math";
+import { WorldSpaces } from "../WorldSpaces";
+import { Section } from "../Section/Section";
+import { WorldRegister } from "../WorldRegister";
+export class SectionSnapShot {
+    sections = [];
+    location = [0, 0, 0, 0];
+    index = Flat3DIndex.GetXYZOrder();
+    _buffers = [];
+    constructor() {
+        this.index.setBounds(3, 3, 3);
+        let totalSections = this.index.size;
+        while (totalSections--) {
+            const buffer = new ArrayBuffer(Section.GetBufferSize());
+            this.sections.push(new Uint8Array(buffer));
+            this._buffers.push(buffer);
+        }
+    }
+    setLocation([dimension, x, y, z]) {
+        this.location[0] = dimension;
+        this.location[1] = x;
+        this.location[2] = y;
+        this.location[3] = z;
+    }
+    storeSnapShot() {
+        const { x: sizeX, y: sizeY, z: sizeZ } = WorldSpaces.section.bounds;
+        const [dim, ox, oy, oz] = this.location;
+        for (let x = 0; x < 3; x++) {
+            for (let y = 0; y < 3; y++) {
+                for (let z = 0; z < 3; z++) {
+                    const wx = ox + (x - 1) * sizeX;
+                    const wy = oy + (y - 1) * sizeY;
+                    const wz = oz + (z - 1) * sizeZ;
+                    const snapShotSection = this.sections[this.index.getIndexXYZ(x, y, z)];
+                    if (!WorldSpaces.world.inBounds(wx, wy, wz)) {
+                        snapShotSection.fill(0);
+                        continue;
+                    }
+                    const sector = WorldRegister.sectors.get(dim, wx, wy, wz);
+                    if (!sector) {
+                        snapShotSection.fill(0);
+                        continue;
+                    }
+                    snapShotSection.set(sector.getSection(wx, wy, wz).view);
+                }
+            }
+        }
+    }
+    _isTransfered = false;
+    isTransfered() {
+        return this._isTransfered;
+    }
+    transfer() {
+        this._isTransfered = true;
+        return [
+            {
+                location: [...this.location],
+                sections: [...this.sections],
+            },
+            this._buffers,
+        ];
+    }
+    restore(data) {
+        this.sections = data.sections;
+        this.location = data.location;
+        this._buffers = [];
+        this._isTransfered = false;
+        for (let i = 0; i < this.sections.length; i++) {
+            this._buffers.push(this.sections[i].buffer);
+        }
+    }
+}

package/World/SnapShot/SectionSnapShotCursor.d.ts

@@ -0,0 +1,23 @@
+import { Flat3DIndex, Vector3Like } from "@amodx/math";
+import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
+import { SectionSnapShot } from "./SectionSnapShot";
+import { Sector } from "../Sector";
+import { SectorCursor } from "../Cursor/SectorCursor";
+import { SectionCursor } from "../Cursor/SectionCursor";
+export declare class SectionSnapshotCursor implements DataCursorInterface {
+    origin: Vector3Like;
+    sectorOrigin: Vector3Like;
+    dimension: number;
+    sectors: Sector[];
+    cursors: SectorCursor[];
+    index: Flat3DIndex;
+    constructor();
+    private _snapShot;
+    private _centeralCursor;
+    getCenteralCursor(): SectionCursor | null;
+    setSectionSnapShot(snapShot: SectionSnapShot): void;
+    protected getSectorIndex(x: number, y: number, z: number): number;
+    inBounds(x: number, y: number, z: number): boolean;
+    getVoxel(x: number, y: number, z: number): import("../Cursor/WorldVoxelCursor").WorldVoxelCursor | null;
+    clone(): SectionSnapshotCursor;
+}

package/World/SnapShot/SectionSnapShotCursor.js

@@ -0,0 +1,107 @@
+import { Flat3DIndex, Vector3Like } from "@amodx/math";
+import { WorldSpaces } from "../WorldSpaces";
+import { Sector } from "../Sector";
+import { SectorCursor } from "../Cursor/SectorCursor";
+import { SectionCursor } from "../Cursor/SectionCursor";
+const tempPosition = Vector3Like.Create();
+export class SectionSnapshotCursor {
+    origin = Vector3Like.Create();
+    sectorOrigin = Vector3Like.Create();
+    dimension = 0;
+    sectors = [];
+    cursors = [];
+    index = Flat3DIndex.GetXYZOrder();
+    constructor() {
+        this.index.setBounds(3, 3, 3);
+        const { x: sizeX, y: sizeY, z: sizeZ } = WorldSpaces.sector.bounds;
+        for (let x = 0; x < 3; x++) {
+            for (let y = 0; y < 3; y++) {
+                for (let z = 0; z < 3; z++) {
+                    if (!WorldSpaces.world.inBounds((x - 1) * sizeX, (y - 1) * sizeY, (z - 1) * sizeZ))
+                        continue;
+                    const sectorIndex = this.index.getIndexXYZ(x, y, z);
+                    const sector = new Sector();
+                    sector.setBuffer(Sector.CreateNewBuffer());
+                    const cursor = new SectorCursor();
+                    cursor.setSector(sector);
+                    this.sectors[sectorIndex] = sector;
+                    this.cursors[sectorIndex] = cursor;
+                }
+            }
+        }
+    }
+    _snapShot;
+    _centeralCursor = new SectionCursor();
+    getCenteralCursor() {
+        const [dim, x, y, z] = this._snapShot.location;
+        const sector = this.sectors[this.getSectorIndex(x, y, z)];
+        if (!sector)
+            return null;
+        const section = sector.getSection(x, y, z);
+        if (!section)
+            return null;
+        this._centeralCursor.setSection(section);
+        return this._centeralCursor;
+    }
+    setSectionSnapShot(snapShot) {
+        this._snapShot = snapShot;
+        const { x: sectorSizeX, y: sectorSizeY, z: sectorSizeZ, } = WorldSpaces.sector.bounds;
+        this.origin.x = snapShot.location[1];
+        this.origin.y = snapShot.location[2];
+        this.origin.z = snapShot.location[3];
+        this.sectorOrigin.x = this.origin.x;
+        this.sectorOrigin.y = this.origin.y;
+        this.sectorOrigin.z = this.origin.z;
+        WorldSpaces.sector.transformPosition(this.sectorOrigin);
+        for (let x = 0; x < 3; x++) {
+            for (let y = 0; y < 3; y++) {
+                for (let z = 0; z < 3; z++) {
+                    const sectorIndex = this.index.getIndexXYZ(x, y, z);
+                    const sector = this.sectors[sectorIndex];
+                    if (!sector)
+                        continue;
+                    const secotrPosition = WorldSpaces.sector.getPosition(this.sectorOrigin.x + (x - 1) * sectorSizeX, this.sectorOrigin.y + (y - 1) * sectorSizeY, this.sectorOrigin.z + (z - 1) * sectorSizeZ, tempPosition);
+                    sector.position[0] = secotrPosition.x;
+                    sector.position[1] = secotrPosition.y;
+                    sector.position[2] = secotrPosition.z;
+                    this.cursors[sectorIndex].setSector(sector);
+                }
+            }
+        }
+        const { x: sectionSizeX, y: sectionSizeY, z: sectionSizeZ, } = WorldSpaces.section.bounds;
+        for (let x = 0; x < 3; x++) {
+            for (let y = 0; y < 3; y++) {
+                for (let z = 0; z < 3; z++) {
+                    const sectionX = this.origin.x + (x - 1) * sectionSizeX;
+                    const sectionY = this.origin.y + (y - 1) * sectionSizeY;
+                    const sectionZ = this.origin.z + (z - 1) * sectionSizeZ;
+                    if (!WorldSpaces.world.inBounds(sectionX, sectionY, sectionZ))
+                        continue;
+                    const sectorIndex = this.getSectorIndex(sectionX, sectionY, sectionZ);
+                    const sector = this.sectors[sectorIndex];
+                    if (!sector)
+                        continue;
+                    const section = sector.getSection(sectionX, sectionY, sectionZ);
+                    section.updatePosition();
+                    section.view.set(snapShot.sections[snapShot.index.getIndexXYZ(x, y, z)]);
+                }
+            }
+        }
+    }
+    getSectorIndex(x, y, z) {
+        const sectorPos = WorldSpaces.sector.getPosition(x, y, z, tempPosition);
+        return this.index.getIndexXYZ((sectorPos.x - this.sectorOrigin.x) / WorldSpaces.sector.bounds.x + 1, (sectorPos.y - this.sectorOrigin.y) / WorldSpaces.sector.bounds.y + 1, (sectorPos.z - this.sectorOrigin.z) / WorldSpaces.sector.bounds.z + 1);
+    }
+    inBounds(x, y, z) {
+        return WorldSpaces.world.inBounds(x, y, z);
+    }
+    getVoxel(x, y, z) {
+        const sector = this.cursors[this.getSectorIndex(x, y, z)];
+        if (!sector)
+            return null;
+        return sector.getVoxel(x, y, z);
+    }
+    clone() {
+        return new SectionSnapshotCursor();
+    }
+}

package/World/SnapShot/SnapShots.d.ts

@@ -0,0 +1,11 @@
+import { LocationData } from "../../Math";
+import { SectionSnapShot } from "./SectionSnapShot";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+export declare class SnapShots {
+    static _readyCache: SectionSnapShot[];
+    static _pendingCache: SectionSnapShot[];
+    private static bounds;
+    static getSnapShotBounds(x: number, y: number, z: number): Readonly<BoundingBox>;
+    static createSnapShot(location: LocationData): SectionSnapShot;
+    static transferSnapShot(snapShot: SectionSnapShot): void;
+}

package/World/SnapShot/SnapShots.js

@@ -0,0 +1,24 @@
+import { SectionSnapShot } from "./SectionSnapShot";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+import { WorldSpaces } from "../WorldSpaces";
+import { Vector3Like } from "@amodx/math";
+export class SnapShots {
+    static _readyCache = [];
+    static _pendingCache = [];
+    static bounds = new BoundingBox();
+    static getSnapShotBounds(x, y, z) {
+        this.bounds.setMinMax(WorldSpaces.section.transformPosition(Vector3Like.Subtract({ x, y, z }, WorldSpaces.section.bounds)), WorldSpaces.section.transformPosition(Vector3Like.Add({ x, y, z }, WorldSpaces.section.bounds)));
+        return this.bounds;
+    }
+    static createSnapShot(location) {
+        let snapShot = this._readyCache.length
+            ? this._readyCache.shift()
+            : new SectionSnapShot();
+        snapShot.setLocation(location);
+        snapShot.storeSnapShot();
+        return snapShot;
+    }
+    static transferSnapShot(snapShot) {
+        this._pendingCache.push(snapShot);
+    }
+}

package/World/Types/WorldData.types.d.ts

@@ -1,11 +1,6 @@
-export type DimensionOptions = {
-    liquidFlowSpeed: number;
-    magmaFlowSpeed: number;
-    sunLight: boolean;
-};
-export type DimensionData = {
+export type DimensionSyncData = {
     id: string;
-    options: DimensionOptions;
+    index: number;
 };
 export type RichDataSchema = Record<string, Record<string, any>>;
 export type RichSector = {

package/World/Types/WorldDataSyncIds.d.ts

@@ -1,6 +1,8 @@
 export declare enum WorldDataSyncIds {
     SyncSector = "sync-sector",
     UnSyncSector = "unsync-sector",
+    CheckInSector = "check-in-sector",
+    CheckOutSector = "check-out-sector",
     SyncDimension = "sync-dimension",
     UnSyncDimension = "unsync-dimension"
 }

package/World/Types/WorldDataSyncIds.js

@@ -2,6 +2,8 @@ export var WorldDataSyncIds;
 (function (WorldDataSyncIds) {
     WorldDataSyncIds["SyncSector"] = "sync-sector";
     WorldDataSyncIds["UnSyncSector"] = "unsync-sector";
+    WorldDataSyncIds["CheckInSector"] = "check-in-sector";
+    WorldDataSyncIds["CheckOutSector"] = "check-out-sector";
     WorldDataSyncIds["SyncDimension"] = "sync-dimension";
     WorldDataSyncIds["UnSyncDimension"] = "unsync-dimension";
 })(WorldDataSyncIds || (WorldDataSyncIds = {}));

package/World/WorldRegister.d.ts

@@ -1,10 +1,11 @@
 import { Dimension } from "./Dimension/Dimension";
 import { Sector, SectorData } from "./Sector/Sector.js";
 import type { LocationData } from "../Math/index.js";
-import { DimensionData } from "./Types/WorldData.types.js";
+import { DimensionSyncData } from "./Types/WorldData.types.js";
+import { Section } from "./Section/Section.js";
 declare class WorldDataHooks {
     static dimension: {
-        onNew: (dimension: DimensionData) => void;
+        onNew: (dimension: DimensionSyncData) => void;
         onRemove: (location: LocationData) => void;
     };
     static sectors: {
@@ -13,22 +14,33 @@ declare class WorldDataHooks {
     };
 }
 declare class WorldRegisterDimensions {
-    static add(id: string): Dimension;
-    static get(id: string): Dimension | undefined;
+    static _dimensionMap: Map<string, number>;
+    static add(index: number, id?: string): Dimension;
+    static get(index: number): Dimension | undefined;
+}
+declare class WorldRegisterPools {
+    static _sectorBuffers: ArrayBufferLike[];
+    static _sectors: Sector[];
+    static _sections: Section[];
+    static _sectorBufferEnabled: boolean;
+    static getSector(): ArrayBufferLike;
+    static returnSector(sector: Sector): void;
 }
 declare class WorldRegisterSectors {
-    static setSecotrPool(enabled: boolean): void;
-    static add(dimensionId: string, x: number, y: number, z: number, sector: SectorData): Sector;
-    static addAt(location: LocationData, sector: SectorData): Sector;
-    static new(dimensionId: string, x: number, y: number, z: number): boolean;
+    static setSecotrBufferPool(enabled: boolean): void;
+    static add(dimensionId: number, x: number, y: number, z: number, sector: ArrayBufferLike): Sector;
+    static addAt(location: LocationData, sector: ArrayBufferLike): Sector;
+    static new(dimensionId: number, x: number, y: number, z: number): boolean;
     static newAt(location: LocationData): boolean;
-    static get(dimensionId: string, x: number, y: number, z: number): false | Sector;
-    static getAt(location: LocationData): false | Sector;
-    static remove(dimensionId: string, x: number, y: number, z: number): boolean;
-    static removeAt(location: LocationData): boolean;
+    static get(dimensionId: number, x: number, y: number, z: number): null | Sector;
+    static getAt(location: LocationData): Sector | null;
+    static remove(dimensionId: number, x: number, y: number, z: number): ArrayBuffer | null;
+    static removeAt(location: LocationData): ArrayBuffer | null;
 }
 export declare class WorldRegister {
-    static _dimensions: Map<string, Dimension>;
+    static proxy: boolean;
+    static _pools: typeof WorldRegisterPools;
+    static _dimensions: Map<number, Dimension>;
     static _hooks: typeof WorldDataHooks;
     static dimensions: typeof WorldRegisterDimensions;
     static sectors: typeof WorldRegisterSectors;

package/World/WorldRegister.js

@@ -2,6 +2,7 @@ import { WorldSpaces } from "./WorldSpaces.js";
 import { Dimension } from "./Dimension/Dimension";
 import { Sector } from "./Sector/Sector.js";
 import { Vector3Like } from "@amodx/math";
+import { EngineSettings } from "../Settings/EngineSettings.js";
 class WorldDataHooks {
     static dimension = {
         onNew: (dimension) => { },
@@ -13,41 +14,59 @@ class WorldDataHooks {
     };
 }
 class WorldRegisterDimensions {
-    static add(id) {
-        const dimesnion = Dimension.CreateNew(id);
-        WorldRegister._dimensions.set(id, dimesnion);
+    static _dimensionMap = new Map([["main", 0]]);
+    static add(index, id = "") {
+        const dimesnion = Dimension.CreateNew(index, id);
+        WorldRegister._dimensions.set(index, dimesnion);
+        WorldDataHooks.dimension.onNew(dimesnion.getData());
         return dimesnion;
     }
-    static get(id) {
-        return WorldRegister._dimensions.get(id);
+    static get(index) {
+        return WorldRegister._dimensions.get(index);
     }
 }
 const tempPosition = Vector3Like.Create();
-class SectorPool {
-    static _secotrs = [];
-    static _enabled = false;
+class WorldRegisterPools {
+    static _sectorBuffers = [];
+    static _sectors = [];
+    static _sections = [];
+    static _sectorBufferEnabled = false;
     static getSector() {
-        if (!this._enabled)
-            return Sector.CreateNew();
-        if (this._secotrs.length)
-            return this._secotrs.shift();
-        return Sector.CreateNew();
+        if (!this._sectorBufferEnabled)
+            return Sector.CreateNewBuffer();
+        if (this._sectorBuffers.length)
+            return this._sectorBuffers.shift();
+        return Sector.CreateNewBuffer();
     }
-    static returnSector(secotr) {
-        secotr.bufferView.fill(0);
-        this._secotrs.push(secotr.toJSON());
+    static returnSector(sector) {
+        if (this._sectorBufferEnabled) {
+            sector.bufferView.fill(0);
+            this._sectorBuffers.push(sector.buffer);
+        }
+        this._sectors.push(sector);
+        sector.clear();
+        for (let i = 0; i < sector.sections.length; i++) {
+            sector.sections[i].clear();
+            this._sections.push(sector.sections[i]);
+        }
+        sector.setReleased(true);
     }
 }
 class WorldRegisterSectors {
-    static setSecotrPool(enabled) {
-        SectorPool._enabled = enabled;
-        SectorPool._secotrs.length = 0;
+    static setSecotrBufferPool(enabled) {
+        WorldRegisterPools._sectorBufferEnabled = enabled;
+        WorldRegisterPools._sectorBuffers.length = 0;
     }
     static add(dimensionId, x, y, z, sector) {
         let dimension = WorldRegister.dimensions.get(dimensionId);
         if (!dimension)
             dimension = WorldRegister.dimensions.add(dimensionId);
-        const newSector = new Sector(sector, WorldSpaces.sector.getPositionVec3Array(x, y, z));
+        const newSector = WorldRegisterPools._sectors.length
+            ? WorldRegisterPools._sectors.shift()
+            : new Sector();
+        newSector.setReleased(false);
+        WorldSpaces.sector.getPositionVec3Array(x, y, z, newSector.position);
+        newSector.setBuffer(sector);
         dimension.sectors.set(WorldSpaces.hash.hashVec3Array(newSector.position), newSector);
         return newSector;
     }
@@ -60,7 +79,7 @@ class WorldRegisterSectors {
         let dimension = WorldRegister.dimensions.get(dimensionId);
         if (!dimension)
             dimension = WorldRegister.dimensions.add(dimensionId);
-        const sector = this.add(dimensionId, x, y, z, SectorPool.getSector());
+        const sector = this.add(dimensionId, x, y, z, WorldRegisterPools.getSector());
         WorldDataHooks.sectors.onNew([dimensionId, x, y, z], sector);
         return true;
     }
@@ -70,9 +89,9 @@ class WorldRegisterSectors {
     static get(dimensionId, x, y, z) {
         let dimension = WorldRegister.dimensions.get(dimensionId);
         if (!dimension)
-            return false;
+            return null;
         const sector = dimension.sectors.get(WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(x, y, z, tempPosition)));
-        return sector || false;
+        return sector || null;
     }
     static getAt(location) {
         return this.get(...location);
@@ -80,24 +99,32 @@ class WorldRegisterSectors {
     static remove(dimensionId, x, y, z) {
         let dimension = WorldRegister.dimensions.get(dimensionId);
         if (!dimension)
-            return false;
+            return null;
         const position = WorldSpaces.sector.getPosition(x, y, z, tempPosition);
         const sectorKey = WorldSpaces.hash.hashVec3(position);
         const sector = dimension.sectors.get(sectorKey);
         if (!sector)
-            return false;
-        if (SectorPool._enabled)
-            SectorPool.returnSector(sector);
+            return null;
         WorldDataHooks.sectors.onRemove([dimensionId, position.x, position.y, position.z], sector);
+        if (!EngineSettings.settings.memoryAndCPU.useSharedMemory &&
+            WorldRegister.proxy == true) {
+            dimension.sectors.delete(sectorKey);
+            return sector.buffer;
+        }
+        WorldRegisterPools.returnSector(sector);
         dimension.sectors.delete(sectorKey);
-        return true;
+        return null;
     }
     static removeAt(location) {
         return this.remove(...location);
     }
 }
 export class WorldRegister {
-    static _dimensions = new Map();
+    static proxy = false;
+    static _pools = WorldRegisterPools;
+    static _dimensions = new Map([
+        [0, new Dimension(Dimension.CreateNew(0, "main"))],
+    ]);
     static _hooks = WorldDataHooks;
     static dimensions = WorldRegisterDimensions;
     static sectors = WorldRegisterSectors;

package/World/WorldSpaces.d.ts

@@ -1,4 +1,20 @@
 import { Vec3Array, Vector3Like } from "@amodx/math";
+import { IndexOrderingTypes } from "../Math/Indexing.js";
+export type WorldSpaceDataKey = {
+    sector: {
+        size: Vector3Like;
+        sectionArrayOrder: IndexOrderingTypes;
+    };
+    section: {
+        size: Vector3Like;
+        arrayOrders: {
+            id: IndexOrderingTypes;
+            light: IndexOrderingTypes;
+            level: IndexOrderingTypes;
+            secondary: IndexOrderingTypes;
+        };
+    };
+};
 declare class WorldBounds {
     static bounds: {
         MinZ: number;
@@ -26,6 +42,7 @@ declare class SectorSpace {
     static sectionBounds: Vector3Like;
     static sectionVolumne: number;
     static getPosition(x: number, y: number, z: number, refPosition?: Vector3Like): Vector3Like;
+    static transformPosition(position: Vector3Like): Vector3Like;
     static getPositionVec3Array(x: number, y: number, z: number, refPosition?: Vec3Array): Vec3Array;
 }
 declare class SectionSpace {
@@ -33,6 +50,7 @@ declare class SectionSpace {
     static bounds: Vector3Like;
     static volumne: number;
     static getPosition(x: number, y: number, z: number, refPosition?: Vector3Like): Vector3Like;
+    static transformPosition(position: Vector3Like): Vector3Like;
     static getPositionVec3Array(x: number, y: number, z: number, refPosition?: Vec3Array): Vec3Array;
     static getIndex(x: number, y: number, z: number): number;
     static getPositionFromIndex(index: number, refPosition?: Vector3Like): Vector3Like;
@@ -42,6 +60,7 @@ declare class VoxelSpace {
     static bounds: Vector3Like;
     static getPosition(x: number, y: number, z: number, refPosition?: Vector3Like): Vector3Like;
     static getPositionVec3Array(x: number, y: number, z: number, refPosition?: Vec3Array): Vec3Array;
+    static transformPosition(position: Vector3Like): Vector3Like;
     static getPositionFromIndex(index: number, refPosition?: Vector3Like): Vector3Like;
     static getIndex(x: number, y: number, z: number): number;
     static getIndexFromPosition(x: number, y: number, z: number): number;
@@ -57,5 +76,6 @@ export declare class WorldSpaces {
     static sector: typeof SectorSpace;
     static section: typeof SectionSpace;
     static voxel: typeof VoxelSpace;
+    static getDataKey(): WorldSpaceDataKey;
 }
 export {};

package/World/WorldSpaces.js

@@ -63,6 +63,10 @@ class SectorSpace {
         CubeHashVec3(x, y, z, SectorSpace.power2Axes.x, SectorSpace.power2Axes.y, SectorSpace.power2Axes.z, refPosition);
         return refPosition;
     }
+    static transformPosition(position) {
+        CubeHashVec3(position.x, position.y, position.z, SectorSpace.power2Axes.x, SectorSpace.power2Axes.y, SectorSpace.power2Axes.z, position);
+        return position;
+    }
     static getPositionVec3Array(x, y, z, refPosition = [0, 0, 0]) {
         CubeHashVec3Array(x, y, z, SectorSpace.power2Axes.x, SectorSpace.power2Axes.y, SectorSpace.power2Axes.z, refPosition);
         return refPosition;
@@ -76,6 +80,10 @@ class SectionSpace {
         CubeHashVec3(x, y, z, SectionSpace.power2Axes.x, SectionSpace.power2Axes.y, SectionSpace.power2Axes.z, refPosition);
         return refPosition;
     }
+    static transformPosition(position) {
+        CubeHashVec3(position.x, position.y, position.z, SectionSpace.power2Axes.x, SectionSpace.power2Axes.y, SectionSpace.power2Axes.z, position);
+        return position;
+    }
     static getPositionVec3Array(x, y, z, refPosition = [0, 0, 0]) {
         CubeHashVec3Array(x, y, z, SectionSpace.bounds.x, SectionSpace.bounds.y, SectionSpace.bounds.z, refPosition);
         return refPosition;
@@ -108,6 +116,14 @@ class VoxelSpace {
         refPosition[2] = z - refPosition[2];
         return refPosition;
     }
+    static transformPosition(position) {
+        const { x, y, z } = position;
+        CubeHashVec3(x, y, z, SectionSpace.power2Axes.x, SectionSpace.power2Axes.y, SectionSpace.power2Axes.z, position);
+        position.x = x - position.x;
+        position.y = y - position.y;
+        position.z = z - position.z;
+        return position;
+    }
     static getPositionFromIndex(index, refPosition = Vector3Like.Create()) {
         return GetYXZOrderArrayPositionVec3(index, SectionSpace.bounds.x, SectionSpace.bounds.y, SectionSpace.bounds.z, refPosition);
     }
@@ -136,21 +152,38 @@ export class WorldSpaces {
     static sector = SectorSpace;
     static section = SectionSpace;
     static voxel = VoxelSpace;
+    static getDataKey() {
+        return {
+            sector: {
+                size: { ...WorldSpaces.sector.bounds },
+                sectionArrayOrder: "YXZ",
+            },
+            section: {
+                size: { ...WorldSpaces.section.bounds },
+                arrayOrders: {
+                    id: "YXZ",
+                    level: "YXZ",
+                    light: "YXZ",
+                    secondary: "YXZ",
+                },
+            },
+        };
+    }
 }
 EngineSettings.addEventListener("synced", (event) => {
     const { settings } = event.detail.settings;
     WorldBounds.setWorldBounds(settings.world.min.x, settings.world.min.y, settings.world.min.z, settings.world.max.x, settings.world.max.y, settings.world.max.z);
-    SectorSpace.power2Axes.x = settings.sectors.power2Size.x;
-    SectorSpace.power2Axes.y = settings.sectors.power2Size.y;
-    SectorSpace.power2Axes.z = settings.sectors.power2Size.z;
+    SectorSpace.power2Axes.x = settings.world.sectorPower2Size.x;
+    SectorSpace.power2Axes.y = settings.world.sectorPower2Size.y;
+    SectorSpace.power2Axes.z = settings.world.sectorPower2Size.z;
     SectorSpace.bounds.x = 1 << SectorSpace.power2Axes.x;
     SectorSpace.bounds.y = 1 << SectorSpace.power2Axes.y;
     SectorSpace.bounds.z = 1 << SectorSpace.power2Axes.z;
     SectorSpace.volumne =
         SectorSpace.bounds.x * SectorSpace.bounds.y * SectorSpace.bounds.z;
-    SectionSpace.power2Axes.x = settings.sections.power2Size.x;
-    SectionSpace.power2Axes.y = settings.sections.power2Size.y;
-    SectionSpace.power2Axes.z = settings.sections.power2Size.z;
+    SectionSpace.power2Axes.x = settings.world.sectionPower2Size.x;
+    SectionSpace.power2Axes.y = settings.world.sectionPower2Size.y;
+    SectionSpace.power2Axes.z = settings.world.sectionPower2Size.z;
     SectionSpace.bounds.x = 1 << SectionSpace.power2Axes.x;
     SectionSpace.bounds.y = 1 << SectionSpace.power2Axes.y;
     SectionSpace.bounds.z = 1 << SectionSpace.power2Axes.z;