@divinevoxel/vlox 0.0.5 → 0.0.6

package/Mesher/Models/VoxelGeometryLookUp.js

@@ -1,67 +1,106 @@
 import { VoxelModelConstructorRegister } from "./VoxelModelConstructorRegister";
-import { Vector3Like } from "@amodx/math";
 import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
-export class VoxelGeometryLookUp {
-    static voxelHash = [];
-    static modCache = [];
-    static stateCache = [];
-    static conditonalStateCache = [];
-    static geometryCache = [];
-    static conditionalGeometryCache = [];
-    static noCastAO = [];
-    static offset = [0, 0, 0];
-    static voxelCursor = new VoxelCursor();
-    static init() { }
-    static start(dimension, x, y, z) {
+import { GetYXZOrderArrayIndex } from "../../Math/Indexing";
+export class VoxelGeometryLookUpSpace {
+    bounds;
+    foundHash;
+    voxelHash;
+    modCache;
+    stateCache;
+    conditonalStateCache;
+    noCastAO;
+    offset = [0, 0, 0];
+    constructor(bounds) {
+        this.bounds = bounds;
+        const volume = bounds.x * bounds.y * bounds.z;
+        this.foundHash = new Uint8Array(volume);
+        this.voxelHash = new Uint16Array(volume);
+        this.modCache = new Int32Array(volume);
+        this.stateCache = new Int32Array(volume);
+        this.conditonalStateCache = new Int32Array(volume);
+        this.noCastAO = new Uint8Array(volume);
+    }
+    start(x, y, z) {
         this.offset[0] = x;
         this.offset[1] = y;
         this.offset[2] = z;
+        this.foundHash.fill(0);
+        this.conditonalStateCache.fill(-1);
+        this.stateCache.fill(-1);
+        this.modCache.fill(-1);
+    }
+    getIndex(x, y, z) {
+        return GetYXZOrderArrayIndex(x - this.offset[0], y - this.offset[1], z - this.offset[2], this.bounds.x, this.bounds.y, this.bounds.z);
+    }
+    getConstructor(index) {
+        if (this.foundHash[index] !== 2)
+            return null;
+        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelHash[index]];
+    }
+    getGeomtry(index) {
+        if (this.foundHash[index] !== 2)
+            return false;
+        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelHash[index]].data.shapeStateGeometryMap[this.stateCache[index]];
+    }
+    getConditionalGeomtry(index) {
+        if (this.foundHash[index] !== 2)
+            return false;
+        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelHash[index]].data.condiotnalShapeStateGeometryMap[this.conditonalStateCache[index]];
+    }
+}
+export class VoxelGeometryLookUp {
+    static space = null;
+    static voxelCursor = new VoxelCursor();
+    static createSpace(x, y, z) {
+        return new VoxelGeometryLookUpSpace({ x, y, z });
+    }
+    static init() { }
+    static start(space) {
+        this.space = space;
     }
     static isRulesless(geoId) {
         return VoxelModelConstructorRegister.rulesless[geoId] == true;
     }
-    static stop() {
-        this.stateCache.length = 0;
-        this.voxelHash.length = 0;
-        this.modCache.length = 0;
-        this.geometryCache.length = 0;
-        this.conditionalGeometryCache.length = 0;
-        this.conditonalStateCache.length = 0;
-        this.noCastAO.length = 0;
-    }
+    static stop() { }
     static getHash(dataCursor, x, y, z) {
-        const hashed = Vector3Like.HashXYZ(x - this.offset[0], y - this.offset[1], z - this.offset[2]);
-        if (!this.stateCache[hashed])
+        if (!this.space)
+            throw new Error(`Voxel geomtry look up must have space set`);
+        const hashed = this.space?.getIndex(x, y, z);
+        if (this.space.foundHash[hashed] == 0)
             this.hashState(dataCursor, hashed, x, y, z);
         return hashed;
     }
-    static hashState(dataCursor, hashed, x, y, z) {
-        if (this.stateCache[hashed] !== undefined)
-            return this.stateCache[hashed];
+    static hashState(dataCursor, index, x, y, z) {
+        if (!this.space)
+            throw new Error(`Voxel geomtry look up must have space set`);
+        if (this.space.foundHash[index] == 2)
+            return this.space.stateCache[index];
         const voxel = dataCursor.getVoxel(x, y, z);
         if (!voxel) {
-            this.stateCache[hashed] = -1;
+            this.space.foundHash[index] = 1;
             return -1;
         }
         if (!voxel.isRenderable()) {
-            this.stateCache[hashed] = -1;
+            this.space.foundHash[index] = 1;
             return -1;
         }
         const voxelConstructor = VoxelModelConstructorRegister.constructorsPaltte[voxel.getId()];
+        this.space.voxelHash[index] = voxel.getId();
         if (!voxelConstructor || !voxelConstructor.isModel) {
-            this.stateCache[hashed] = -1;
+            this.space.foundHash[index] = 1;
             return -1;
         }
+        this.space.foundHash[index] = 2;
         //no ao
-        this.noCastAO[hashed] = voxel.isLightSource() || voxel.noAO();
+        this.space.noCastAO[index] = voxel.isLightSource() || voxel.noAO() ? 1 : 0;
         //state
         const shapeState = voxel.getState();
         const state = voxelConstructor.shapeStateTree.getState(shapeState);
-        this.stateCache[hashed] = state;
+        this.space.stateCache[index] = state;
         //mod
         const mod = voxel.getMod();
         const modState = voxelConstructor.modTree.getState(mod);
-        this.modCache[hashed] = modState;
+        this.space.modCache[index] = modState;
         this.voxelCursor.copy(voxel).process();
         voxelConstructor.schema.position.x = x;
         voxelConstructor.schema.position.y = y;
@@ -69,12 +108,7 @@ export class VoxelGeometryLookUp {
         voxelConstructor.schema.voxel = this.voxelCursor;
         voxelConstructor.schema.dataCursor = dataCursor;
         const conditonalState = voxelConstructor.condtioanlShapeStateTree.getState();
-        this.voxelHash[hashed] = voxelConstructor;
-        this.conditonalStateCache[hashed] = conditonalState;
-        this.geometryCache[hashed] =
-            voxelConstructor.data.shapeStateGeometryMap[state];
-        this.conditionalGeometryCache[hashed] =
-            voxelConstructor.data.condiotnalShapeStateGeometryMap[conditonalState];
+        this.space.conditonalStateCache[index] = conditonalState;
         return state;
     }
 }

package/Mesher/Tools/VoxelMeshBVHBuilder.js

@@ -1,4 +1,5 @@
 import { WorldSpaces } from "../../World/WorldSpaces";
+const MAX_FLOAT32 = new Float32Array([Infinity])[0];
 /**
  * A class to help with indexing a full flat binary tree defined by the number of levels it has.
  */
@@ -160,23 +161,29 @@ export class StructCursor {
         const ix = this.trueIndex;
         const iy = this.trueIndex + 1;
         const iz = this.trueIndex + 2;
-        this.data[ix] =
-            this.data[ix] == -Infinity || x < this.data[ix] ? x : this.data[ix];
-        this.data[iy] =
-            this.data[iy] == -Infinity || y < this.data[iy] ? y : this.data[iy];
-        this.data[iz] =
-            this.data[iz] == -Infinity || z < this.data[iz] ? z : this.data[iz];
+        if (x < this.data[ix] || this.data[ix] == -MAX_FLOAT32) {
+            this.data[ix] = x;
+        }
+        if (y < this.data[iy] || this.data[iy] == -MAX_FLOAT32) {
+            this.data[iy] = y;
+        }
+        if (z < this.data[iz] || this.data[iz] == -MAX_FLOAT32) {
+            this.data[iz] = z;
+        }
     }
     updateMax(x, y, z) {
         const ix = this.trueIndex + 4;
         const iy = this.trueIndex + 5;
         const iz = this.trueIndex + 6;
-        this.data[ix] =
-            this.data[ix] == -Infinity || x > this.data[ix] ? x : this.data[ix];
-        this.data[iy] =
-            this.data[iy] == -Infinity || y > this.data[iy] ? y : this.data[iy];
-        this.data[iz] =
-            this.data[iz] == -Infinity || z > this.data[iz] ? z : this.data[iz];
+        if (x > this.data[ix] || this.data[ix] == -MAX_FLOAT32) {
+            this.data[ix] = x;
+        }
+        if (y > this.data[iy] || this.data[iy] == -MAX_FLOAT32) {
+            this.data[iy] = y;
+        }
+        if (z > this.data[iz] || this.data[iz] == -MAX_FLOAT32) {
+            this.data[iz] = z;
+        }
     }
     toJSON() {
         return {
@@ -194,7 +201,7 @@ export class VoxelMeshBVHBuilder {
     structCursor = new StructCursor(this.tree);
     indices = new Uint32Array(this.treeIndex.getLevelSize(12) * 2);
     reset() {
-        this.tree.fill(-Infinity);
+        this.tree.fill(-MAX_FLOAT32);
         this.indices.fill(0);
     }
     updateVoxel(voxelX, voxelY, voxelZ, meshIndex, indicesStart, indicesEnd, minX, minY, minZ, maxX, maxY, maxZ) {
@@ -219,15 +226,3 @@ export class VoxelMeshBVHBuilder {
         }
     }
 }
-/*
-console.warn(
-  [voxelX, voxelY, voxelZ],
-  "add gometry",
-     [minX, minY, minZ],
-  [maxX, maxY, maxZ],
-  [voxelX, voxelY, voxelZ],
-  [indicesStart, indicesEnd],
-  indicesEnd - indicesStart,
-  (indicesEnd - indicesStart) / 3
-);
-*/

package/Mesher/Tools/VoxelMeshVertexStructCursor.d.ts

@@ -39,7 +39,9 @@ export declare class VoxelMeshVertexStructCursor {
     set colorB(value: number);
     trueIndex: number;
     _index: number;
-    data: Float32Array | number[];
+    data: {
+        [index: number]: number;
+    };
     get index(): number;
     set index(index: number);
     constructor(data?: Float32Array);

package/Mesher/Tools/VoxelMesherDataTool.d.ts

@@ -2,7 +2,7 @@ import { MesherDataTool } from "../Geomtry/Tools/MesherDataTools";
 import { QuadScalarVertexData } from "../Geomtry/Primitives/QuadVertexData";
 import { VoxelFaces } from "../../Math";
 import { QuadVerticies } from "../Geomtry/Geometry.types";
-import { Mesh } from "../Geomtry/Mesh";
+import { VoxelMesh } from "../Geomtry/VoxelMesh";
 import { VoxelMeshBVHBuilder } from "./VoxelMeshBVHBuilder";
 import { Vec3Array, Vector3Like } from "@amodx/math";
 import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface.js";
@@ -26,7 +26,7 @@ export declare class VoxelMesherDataTool extends MesherDataTool {
     position: Vector3Like;
     /**The current local origin  */
     origin: Vector3Like;
-    mesh: Mesh;
+    mesh: VoxelMesh;
     bvhTool: VoxelMeshBVHBuilder | null;
     vars: VoxelVars;
     dataCalculated: Record<VoxelFaces, boolean>;

package/Mesher/Tools/VoxelMesherDataTool.js

@@ -5,7 +5,7 @@ import { QuadScalarVertexData } from "../Geomtry/Primitives/QuadVertexData";
 import { VoxelFaces, VoxelFacesArray } from "../../Math";
 import { QuadVerticies } from "../Geomtry/Geometry.types";
 import { FaceDataCalc } from "../Models/Common/Calc/FaceDataCalc.js";
-import { Mesh } from "../Geomtry/Mesh";
+import { VoxelMesh } from "../Geomtry/VoxelMesh";
 import { Vector3Like } from "@amodx/math";
 class VoxelVars {
     faceFlipped = false;
@@ -29,7 +29,7 @@ export class VoxelMesherDataTool extends MesherDataTool {
     position = Vector3Like.Create();
     /**The current local origin  */
     origin = Vector3Like.Create();
-    mesh = new Mesh();
+    mesh = new VoxelMesh();
     bvhTool = null;
     vars = new VoxelVars();
     dataCalculated;
@@ -70,7 +70,7 @@ export class VoxelMesherDataTool extends MesherDataTool {
             this.lightData[face][QuadVerticies.BottomLeft] = 0;
             this.lightData[face][QuadVerticies.BottomRight] = 0;
         }
-        this.startNewMesh(new Mesh(true));
+        this.startNewMesh(new VoxelMesh());
     }
     bounds = {
         min: [0, 0, 0],

package/Renderer/Classes/DVESectionMeshes.d.ts

@@ -3,4 +3,5 @@ import { CompactMeshData } from "../../Mesher/Types/Mesher.types";
 import { SectionMesh } from "./SectionMesh";
 export declare abstract class DVESectionMeshes {
     abstract updateVertexData(section: SectionMesh, position: Vec3Array, data: CompactMeshData): SectionMesh;
+    abstract returnMesh(mesh: any): void;
 }

package/Renderer/Classes/SectionMesh.d.ts

@@ -1,11 +1,10 @@
-import { DVESectionMeshInterface } from "./DVESectionMeshInterface";
 import { VoxelEffect } from "../../Voxels/Effects/VoxelEffect";
 import { SectorMesh } from "./SectorMesh";
 import { Vec3Array } from "@amodx/math";
 export declare class SectionMesh {
     sector: SectorMesh;
     index: number;
-    meshes: Map<string, DVESectionMeshInterface>;
+    meshes: Map<string, any>;
     effects: Map<string, VoxelEffect>;
     constructor(sector: SectorMesh, index: number);
     getPosition(): Vec3Array;

package/Renderer/Classes/SectionMesh.js

@@ -19,8 +19,5 @@ export class SectionMesh {
         for (const [key, effect] of this.effects) {
             effect.dispose();
         }
-        for (const [key, mesh] of this.meshes) {
-            mesh.dispose();
-        }
     }
 }

package/Renderer/InitTasks.js

@@ -4,7 +4,19 @@ import { MeshRegister } from "./MeshRegister";
 import { TaskTool } from "../Tools/Tasks/TasksTool";
 export default function RendererTasks(threads) {
     const tasks = new TaskTool(threads);
-    Threads.registerTask("set-section", (data) => MeshManager.updateSection(data));
+    Threads.registerTask("set-section", (data, origin) => {
+        MeshManager.updateSection(data);
+        const tranfers = [];
+        for (const comp of data[1]) {
+            if (comp[0] !== 0)
+                continue;
+            for (const mesh of comp[1]) {
+                tranfers.push(mesh[1]);
+                tranfers.push(mesh[2]);
+            }
+        }
+        origin.sendMessage(data, tranfers);
+    });
     Threads.registerTask("remove-sector", (data) => {
         MeshManager.removeSector(data);
     });

package/Renderer/MeshManager.js

@@ -49,6 +49,10 @@ export class MeshManager {
             if (!section)
                 continue;
             section.dispose();
+            for (const [, mesh] of section.meshes) {
+                this.sectorMeshes.returnMesh(mesh);
+            }
+            section.meshes.clear();
         }
     }
 }

package/Renderer/MeshRegister.d.ts

@@ -1,6 +1,5 @@
 import { type LocationData } from "../Math/index.js";
 import { SectorMesh } from "./Classes/SectorMesh.js";
-import { DVESectionMeshInterface } from "./Classes/DVESectionMeshInterface.js";
 export type MeshRegisterDimensions = Map<string, Map<string, SectorMesh>>;
 declare class Sectors {
     static add(location: LocationData): SectorMesh;
@@ -10,11 +9,7 @@ declare class Sectors {
 declare class Dimensions {
     static add(id: string): Map<any, any>;
     static get(id: string): Map<string, SectorMesh> | undefined;
-    static getAllMeshes(id: string): Generator<[
-        location: LocationData,
-        substance: string,
-        mesh: DVESectionMeshInterface
-    ]>;
+    static getAllMeshes(id: string): Generator<[location: LocationData, substance: string, mesh: any]>;
     static remove(id: string): boolean;
 }
 export declare class MeshRegister {

package/Renderer/index.d.ts

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

package/Renderer/index.js

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

package/Tasks/IWG/Internal/Functions/cullSectors.js

@@ -70,13 +70,12 @@ export function cullSectors(generatos, cullGenerators) {
                     });
                 }
                 else {
-                    WorldRegister.sectors.remove(cx, cy, cz);
+                    WorldRegister.sectors.remove(dimension.id, cx, cy, cz);
                 }
             }
         }
         if (!cullGenerators.length)
             continue;
-        WorldRegister.setDimension(dimension.id);
         const worldDimension = WorldRegister.dimensions.get(dimension.id);
         for (const [, sector] of worldDimension.sectors) {
             const [cx, cy, cz] = sector.position;

package/Tasks/IWG/Internal/Functions/getSectorState.js

@@ -14,7 +14,7 @@ export function getSectorState(sector, state, segment) {
         if (!segment.vistedMap.has(sectorPOS.x, cy, sectorPOS.z)) {
             segment.queue.push(sectorPOS.x, cy, sectorPOS.z);
         }
-        const sector = WorldRegister.sectors.get(sectorPOS.x, cy, sectorPOS.z);
+        const sector = WorldRegister.sectors.get(segment.id, sectorPOS.x, cy, sectorPOS.z);
         if (!sector) {
             state.genAlldone = false;
             state.nWorldGenAllDone = false;

package/Tasks/IWG/Internal/Functions/runBuildUpdate.js

@@ -32,8 +32,7 @@ export function runBuildUpdate(generators) {
             sectorSquare.center.y = cz + WorldSpaces.sector.bounds.z / 2;
             if (!Circle.IsSquareInsideOrTouchingCircle(sectorSquare, generator._renderCircle))
                 continue;
-            WorldRegister.setDimension(generator._dimension);
-            const sector = WorldRegister.sectors.get(cx, cy, cz);
+            const sector = WorldRegister.sectors.get(generator._dimension, cx, cy, cz);
             if (!sector)
                 continue;
             const state = getSectorState(sector, stateCursor, segment);

package/Tasks/IWG/Internal/Functions/runWorldUpdate.js

@@ -35,8 +35,7 @@ export function runWorldUpdate(generators) {
             sectorSquare.center.y = cz + WorldSpaces.sector.bounds.z / 2;
             if (!Circle.IsSquareInsideOrTouchingCircle(sectorSquare, generator._genCircle))
                 continue;
-            WorldRegister.setDimension(generator._dimension);
-            const sector = WorldRegister.sectors.get(cx, cy, cz);
+            const sector = WorldRegister.sectors.get(generator._dimension, cx, cy, cz);
             if (!sector) {
                 IWGTasks.worldLoadTasks.add(generator._dimension, cx, cy, cz);
                 continue;

package/Tasks/IWG/Internal/IWGTasks.js

@@ -12,12 +12,11 @@ export class IWGTasks {
         propagationBlocking: true,
         async run(location, onDone) {
             const [dimension, x, y, z] = location;
-            WorldRegister.setDimension(location[0]);
-            const sector = WorldRegister.sectors.get(x, y, z);
+            const sector = WorldRegister.sectors.get(location[0], x, y, z);
             if (sector)
                 return onDone();
             if (!IWGTools.worldStorage) {
-                WorldRegister.sectors.new(x, y, z);
+                WorldRegister.sectors.new(location[0], x, y, z);
                 return onDone();
             }
             const loaded = await IWGTools.worldStorage.loadSector([
@@ -27,8 +26,7 @@ export class IWGTasks {
                 z,
             ]);
             if (!loaded) {
-                WorldRegister.setDimension(location[0]);
-                WorldRegister.sectors.new(x, y, z);
+                WorldRegister.sectors.new(location[0], x, y, z);
             }
             onDone();
         },
@@ -40,8 +38,7 @@ export class IWGTasks {
         id: "generate",
         propagationBlocking: true,
         async run(location, onDone) {
-            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.toString()} does not exist when attempting generation.`);
             Sector.StateStruct.setBuffer(sector.buffer);
@@ -61,8 +58,7 @@ export class IWGTasks {
         id: "decorate",
         propagationBlocking: true,
         async run(location, onDone) {
-            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.toString()} does not exist when attempting decoration.`);
             Sector.StateStruct.setBuffer(sector.buffer);
@@ -82,8 +78,7 @@ export class IWGTasks {
         id: "wolrd_sun",
         propagationBlocking: true,
         async run(location, onDone) {
-            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.toString()} does not exist when attempting world sun.`);
             Sector.StateStruct.setBuffer(sector.buffer);
@@ -103,8 +98,7 @@ export class IWGTasks {
         id: "propagation",
         propagationBlocking: true,
         async run(location, onDone) {
-            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.toString()} does not exist when attempting propagation.`);
             Sector.StateStruct.setBuffer(sector.buffer);

package/Tasks/Propagation/Flow/WorldFlow.js

@@ -4,7 +4,6 @@ import { SectionHeightMap } from "../../../World/Section/SectionHeightMap";
 import { EngineSettings } from "../../../Settings/EngineSettings";
 import { SunRemove, SunUpdate } from "../Illumanation/SunUpdate";
 import { RGBRemove, RGBUpdate } from "../Illumanation/RGBUpdate";
-import { WorldBounds } from "../../../World/WorldBounds";
 const flowUpdateChecks = [
     [0, -1, 0],
     [1, 0, 0],
@@ -72,7 +71,7 @@ function Flood(task, voxel) {
             }
             continue;
         }
-        if (!WorldBounds.inBounds(x, y - 1, z) && levelState != 1)
+        if (!WorldSpaces.world.inBounds(x, y - 1, z) && levelState != 1)
             continue;
         let nVoxel = task.nDataCursor.getVoxel(x, y - 1, z);
         const nLevel = nVoxel.isAir()
@@ -108,8 +107,7 @@ function Flood(task, voxel) {
 export function WorldFlow(task) {
     if (!EngineSettings.doFlow())
         return false;
-    WorldRegister.setDimension(task.origin[0]);
-    const sector = WorldRegister.sectors.get(task.origin[1], task.origin[2], task.origin[3]);
+    const sector = WorldRegister.sectors.get(task.origin[0], task.origin[1], task.origin[2], task.origin[3]);
     if (!sector) {
         console.error(`Tried running world flow on a sector that does not exist ${task.origin.toString()}`);
         return false;

package/Tasks/Propagation/Illumanation/WorldRGB.js

@@ -8,8 +8,7 @@ const sectionCursor = new SectionCursor();
 export function WorldRGB(task) {
     if (!EngineSettings.doLight())
         return false;
-    WorldRegister.setDimension(task.origin[0]);
-    const sector = WorldRegister.sectors.get(task.origin[1], task.origin[2], task.origin[3]);
+    const sector = WorldRegister.sectors.get(task.origin[0], task.origin[1], task.origin[2], task.origin[3]);
     if (!sector) {
         console.error(`Tried running world rgb on a sector that does not exist ${task.origin.toString()}`);
         return false;

package/Tasks/Propagation/Illumanation/WorldSun.js

@@ -1,7 +1,5 @@
 //types
 //data
-import { WorldBounds } from "../../../World/WorldBounds.js";
-import { WorldRegister } from "../../../World/WorldRegister.js";
 import { $3dCardinalNeighbors } from "../../../Math/CardinalNeighbors.js";
 import { WorldSpaces } from "../../../World/WorldSpaces.js";
 import { SectorHeightMap } from "../../../World/Sector/SectorHeightMap.js";
@@ -17,12 +15,11 @@ const FloodOutPositions = [
 const queue = [];
 const lightData = new VoxelLightData();
 export function RunWorldSun(tasks) {
-    WorldRegister.setDimension(tasks.origin[0]);
     const [dimension, cx, cy, cz] = tasks.origin;
     const RmaxY = SectorHeightMap.getRelative(tasks.origin);
     const AmaxY = SectorHeightMap.getAbsolute(tasks.origin);
     const maxX = cx + WorldSpaces.sector.bounds.x;
-    const maxY = WorldBounds.bounds.MaxY;
+    const maxY = WorldSpaces.world.bounds.MaxY;
     const maxZ = cz + WorldSpaces.sector.bounds.z;
     const sectorCursor = tasks.nDataCursor.getSector(tasks.origin[1], tasks.origin[2], tasks.origin[3]);
     if (!sectorCursor) {

package/Tasks/WorldGeneration/WorldGenRegister.js

@@ -1,6 +1,5 @@
 import { WorldSpaces } from "../../World/WorldSpaces.js";
 import { BrushTool } from "../../Tools/Brush/Brush";
-import { WorldBounds } from "../../World/WorldBounds";
 import { DivineVoxelEngineConstructor } from "../../Contexts/Constructor";
 import { WorldRegister } from "../../World/WorldRegister";
 const brush = new BrushTool();
@@ -19,14 +18,13 @@ export class WorldGenRegister {
         return id;
     }
     static addToRequest(registerId, location, rawData) {
-        if (location[2] < WorldBounds.bounds.MinY ||
-            location[2] >= WorldBounds.bounds.MaxY)
+        if (location[2] < WorldSpaces.world.bounds.MinY ||
+            location[2] >= WorldSpaces.world.bounds.MaxY)
             return false;
         const requests = this._requests.get(registerId);
         if (!requests)
             return;
-        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) {
             const sectorPos = WorldSpaces.sector.getPosition(location[1], location[2], location[3]);
             const sectorKey = WorldSpaces.hash.hashVec3(sectorPos);
@@ -46,12 +44,11 @@ export class WorldGenRegister {
         const requests = this._requests.get(registerId);
         if (!requests || !requests.voxels.length)
             return true;
-        WorldRegister.setDimension(requests.dimension);
         let done = true;
         for (const [key, pos] of requests.sections) {
-            if (!WorldBounds.inBounds(pos[0], pos[1], pos[2]))
+            if (!WorldSpaces.world.inBounds(pos[0], pos[1], pos[2]))
                 continue;
-            const sector = WorldRegister.sectors.get(pos[0], pos[1], pos[2]);
+            const sector = WorldRegister.sectors.get(requests.dimension, pos[0], pos[1], pos[2]);
             if (!sector) {
                 done = false;
                 DivineVoxelEngineConstructor.instance.threads.world.runTask("add-sector", [requests.dimension, pos[0], pos[1], pos[2]]);

package/Tasks/WorldGeneration/WorldGeneration.d.ts

@@ -1,4 +1,3 @@
-import { WorldBounds } from "../../World/WorldBounds.js";
 import { WorldGenRegister } from "./WorldGenRegister.js";
 import { WorldGenBrush } from "./WorldGenBrush.js";
 import { WorldGenInterface } from "./WorldGen.types.js";
@@ -6,7 +5,6 @@ import { GenerateTasks } from "../Tasks.types.js";
 export declare class WorldGeneration {
     static worldGen: WorldGenInterface | null;
     static register: typeof WorldGenRegister;
-    static worldBounds: typeof WorldBounds;
     static _brushes: any[];
     static setWorldGen(worldGen: WorldGenInterface): void;
     static generate(data: GenerateTasks, mode: "generate" | "decorate", onDone: Function): Promise<void>;

package/Tasks/WorldGeneration/WorldGeneration.js

@@ -1,13 +1,11 @@
 //types
 //objects
-import { WorldBounds } from "../../World/WorldBounds.js";
 import { WorldGenRegister } from "./WorldGenRegister.js";
 //tools
 import { WorldGenBrush } from "./WorldGenBrush.js";
 export class WorldGeneration {
     static worldGen = null;
     static register = WorldGenRegister;
-    static worldBounds = WorldBounds;
     static _brushes = [];
     static setWorldGen(worldGen) {
         this.worldGen = worldGen;

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;

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