@divinevoxel/vlox 0.0.5 → 0.0.7

package/Settings/EngineSettings.types.d.ts

@@ -1,46 +1,64 @@
+import { Vector3Like } from "@amodx/math";
+export interface RenderSettingsData {
+}
+export declare class RenderSettingsData {
+    mode: "webgl" | "webgpu";
+    cpuBound: boolean;
+}
+export interface TextureSettings {
+}
+export declare class TextureSettings {
+    textureSize: number;
+}
+export interface UpdatingSettings {
+}
+export declare class UpdatingSettings {
+    autoRebuild: boolean;
+}
+export interface WorldSettings {
+}
+export declare class WorldSettings {
+    min: Vector3Like;
+    max: Vector3Like;
+}
+export interface SectorSettings {
+}
+export declare class SectorSettings {
+    power2Size: Vector3Like;
+}
+export interface SectionSettings {
+}
+export declare class SectionSettings {
+    power2Size: Vector3Like;
+}
+export interface VoxelSettings {
+}
+export declare class VoxelSettings {
+    doColors: boolean;
+}
+export interface FlowSettings {
+}
+export declare class FlowSettings {
+    enable: boolean;
+    baseFlowLimit: number;
+}
+export interface LightingSettings {
+}
+export declare class LightingSettings {
+    doAO: boolean;
+    doSunLight: boolean;
+    doRGBLight: boolean;
+    autoRGBLight: boolean;
+    autoSunLight: boolean;
+}
 export declare class EngineSettingsData {
-    rendererSettings: {
-        mode: "webgl" | "webgpu";
-    };
-    textures: {
-        animationTime: number;
-        textureSize: number;
-        mipMapSizes: number[];
-    };
-    updating: {
-        autoRebuild: boolean;
-    };
-    world: {
-        maxX: number;
-        minX: number;
-        maxZ: number;
-        minZ: number;
-        maxY: number;
-        minY: number;
-    };
-    sectors: {
-        sectorXPow2: number;
-        sectorYPow2: number;
-        sectorZPow2: number;
-    };
-    sections: {
-        autoHeightMap: boolean;
-        sectionXPow2: number;
-        sectionYPow2: number;
-        sectionZPow2: number;
-    };
-    voxels: {
-        doColors: boolean;
-    };
-    flow: {
-        enable: boolean;
-        baseFlowLimit: number;
-    };
-    lighting: {
-        doAO: boolean;
-        doSunLight: boolean;
-        doRGBLight: boolean;
-        autoRGBLight: boolean;
-        autoSunLight: boolean;
-    };
+    rendererSettings: RenderSettingsData;
+    textures: TextureSettings;
+    updating: UpdatingSettings;
+    world: WorldSettings;
+    sectors: SectorSettings;
+    sections: SectionSettings;
+    voxels: VoxelSettings;
+    flow: FlowSettings;
+    lighting: LightingSettings;
 }

package/Settings/EngineSettings.types.js

@@ -1,44 +1,46 @@
+import { Vector3Like } from "@amodx/math";
+export class RenderSettingsData {
+    mode = "webgl";
+    cpuBound = false;
+}
+export class TextureSettings {
+    textureSize = 16;
+}
+export class UpdatingSettings {
+    autoRebuild = true;
+}
+export class WorldSettings {
+    min = Vector3Like.Create(-Number.MAX_SAFE_INTEGER, 0, -Number.MAX_SAFE_INTEGER);
+    max = Vector3Like.Create(Number.MAX_SAFE_INTEGER, 256, Number.MAX_SAFE_INTEGER);
+}
+export class SectorSettings {
+    power2Size = Vector3Like.Create(4, 8, 4);
+}
+export class SectionSettings {
+    power2Size = Vector3Like.Create(4, 4, 4);
+}
+export class VoxelSettings {
+    doColors = true;
+}
+export class FlowSettings {
+    enable = true;
+    baseFlowLimit = 200;
+}
+export class LightingSettings {
+    doAO = true;
+    doSunLight = true;
+    doRGBLight = true;
+    autoRGBLight = true;
+    autoSunLight = true;
+}
 export class EngineSettingsData {
-    rendererSettings = { mode: "webgl" };
-    textures = {
-        animationTime: 20,
-        textureSize: 16,
-        mipMapSizes: [16, 12, 8, 4],
-    };
-    updating = {
-        autoRebuild: true,
-    };
-    world = {
-        maxX: Number.MAX_SAFE_INTEGER,
-        minX: -Number.MAX_SAFE_INTEGER,
-        maxZ: Number.MAX_SAFE_INTEGER,
-        minZ: -Number.MAX_SAFE_INTEGER,
-        maxY: 256,
-        minY: 0,
-    };
-    sectors = {
-        sectorXPow2: 4,
-        sectorYPow2: 8,
-        sectorZPow2: 4,
-    };
-    sections = {
-        autoHeightMap: true,
-        sectionXPow2: 4,
-        sectionYPow2: 4,
-        sectionZPow2: 4,
-    };
-    voxels = {
-        doColors: true,
-    };
-    flow = {
-        enable: true,
-        baseFlowLimit: 200,
-    };
-    lighting = {
-        doAO: true,
-        doSunLight: true,
-        doRGBLight: true,
-        autoRGBLight: true,
-        autoSunLight: true,
-    };
+    rendererSettings = new RenderSettingsData();
+    textures = new TextureSettings();
+    updating = new UpdatingSettings();
+    world = new WorldSettings();
+    sectors = new SectorSettings();
+    sections = new SectionSettings();
+    voxels = new VoxelSettings();
+    flow = new FlowSettings();
+    lighting = new LightingSettings();
 }

package/Tasks/IWG/IWG.d.ts

@@ -8,6 +8,9 @@ interface IWGInitData {
     threads: Thread | ThreadPool;
     worldStorage?: WorldStorageInterface;
 }
+/**# Infinite World Generation IWG
+ * Object to handle the loading and generating the world around a created generator.
+ */
 export declare class IWG {
     private static _cullGenerators;
     static readonly _generators: Generator[];

package/Tasks/IWG/IWG.js

@@ -10,6 +10,9 @@ import { Vector3Like } from "@amodx/math";
 import { InitalLoad } from "./Procedures/InitalLoad";
 import SaveAllSectors from "./Procedures/SaveAllSectors";
 let initalized = false;
+/**# Infinite World Generation IWG
+ * Object to handle the loading and generating the world around a created generator.
+ */
 export class IWG {
     static _cullGenerators = [];
     static _generators = [];

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/Explosion/ExplosionManager.js

@@ -104,7 +104,7 @@ export const ExplosionManager = {
                               ) {
                                 continue;
                               } */
-                    voxel.setAir().updateHeightMap(1);
+                    voxel.setAir().updateVoxel(1);
                 }
             }
         }

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],
@@ -51,13 +50,13 @@ function Flood(task, voxel) {
                     nState == 0) {
                     if (downAir && !downSameVoxel) {
                         nVoxel.setId(voxelId);
-                        nVoxel.updateHeightMap(0);
+                        nVoxel.updateVoxel(0);
                         nVoxel.setLevel(7);
                         nVoxel.setLevelState(1);
                     }
                     else if (!downSameVoxel) {
                         nVoxel.setId(voxelId);
-                        nVoxel.updateHeightMap(0);
+                        nVoxel.updateVoxel(0);
                         nVoxel.setLevel(level - 1);
                         nVoxel.setLevelState(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()
@@ -99,17 +98,16 @@ function Flood(task, voxel) {
             task.rgb.remove.push(x, y - 1, z);
         }
         nVoxel.setId(voxelId);
-        nVoxel.updateHeightMap(0);
+        nVoxel.updateVoxel(0);
         nVoxel.setLevel(7);
         nVoxel.setLevelState(state);
         queue.push(x, y - 1, z);
     }
 }
 export function WorldFlow(task) {
-    if (!EngineSettings.doFlow())
+    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/RGBUpdate.js

@@ -1,5 +1,5 @@
 import { $3dCardinalNeighbors } from "../../../Math/CardinalNeighbors";
-import { getMinusOneForRGB, isGreaterOrEqualThanForRGBRemove, isLessThanForRGBAdd, isLessThanForRGBRemove, removeSunLight, } from "./CommonFunctions";
+import { getMinusOneForRGB, isGreaterOrEqualThanForRGBRemove, isLessThanForRGBAdd, isLessThanForRGBRemove, removeRGBLight, } from "./CommonFunctions";
 //@todo change array to not use push and shift
 export function RGBUpdate(tasks) {
     const queue = tasks.rgb.update;
@@ -76,7 +76,7 @@ export function RGBRemove(tasks) {
             }
         }
         tasks.bounds.update(x, y, z);
-        voxel.setLight(removeSunLight(sl));
+        voxel.setLight(removeRGBLight(sl));
     }
     removeMap.clear();
 }

package/Tasks/Propagation/Illumanation/WorldRGB.js

@@ -6,10 +6,9 @@ import { EngineSettings } from "../../../Settings/EngineSettings";
 import { RGBUpdate } from "./RGBUpdate";
 const sectionCursor = new SectionCursor();
 export function WorldRGB(task) {
-    if (!EngineSettings.doLight())
+    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) {
@@ -30,8 +27,10 @@ export function RunWorldSun(tasks) {
         return;
     }
     const minY = AmaxY - 1 < 0 ? 0 : AmaxY;
+    const section = sectorCursor.getSection(cx, minY, cz);
+    const sectionY = section.getPosition()[1] + WorldSpaces.section.bounds.y;
     //fill
-    for (let iy = minY; iy < maxY; iy++) {
+    for (let iy = minY; iy < sectionY; iy++) {
         for (let ix = cx; ix < maxX; ix++) {
             for (let iz = cz; iz < maxZ; iz++) {
                 const voxel = sectorCursor.getVoxel(ix, iy, iz);
@@ -44,6 +43,13 @@ export function RunWorldSun(tasks) {
             }
         }
     }
+    for (let iy = sectionY; iy < maxY; iy += WorldSpaces.section.bounds.y) {
+        const section = sectorCursor.getSection(cx, iy, cz);
+        const length = section.light.length;
+        for (let i = 0; i < length; i++) {
+            section.light[i] = lightData.setS(0xf, section.light[i]);
+        }
+    }
     const maxAcculamteY = AmaxY == RmaxY ? RmaxY + 1 : RmaxY;
     let index = queue.length;
     //accumulate

package/Tasks/Update/VoxelUpdate.js

@@ -9,8 +9,8 @@ import { FlowRemove } from "../Propagation/Flow/FlowRemove.js";
 const tasks = new UpdateTask();
 const substanceData = new SubstanceDataTool();
 const updateLightTask = (tasks) => {
-    let doRGB = ES.doRGBPropagation();
-    let doSun = ES.doSunPropagation();
+    let doRGB = ES.doRGBPropagation;
+    let doSun = ES.doSunPropagation;
     const [dimension, x, y, z] = tasks.origin;
     tasks.nDataCursor.setFocalPoint(dimension, x, y, z);
     for (const n of $3dCardinalNeighbors) {
@@ -39,7 +39,7 @@ export async function EreaseAndUpdate(location) {
     if (!voxel)
         return false;
     substanceData.setSubstance(voxel.getSubstance());
-    if (!voxel.isAir() && ES.doFlow() && voxel.isRenderable()) {
+    if (!voxel.isAir() && ES.doFlow && voxel.isRenderable()) {
         if (substanceData.isLiquid()) {
             FlowRemove(tasks);
             return tasks;
@@ -56,17 +56,17 @@ export async function EreaseAndUpdate(location) {
         .setLevelState(0)
         .setState(0)
         .setMod(0)
-        .updateHeightMap(1);
-    if (ES.doLight()) {
-        if (ES.doRGBPropagation() && isLightSource) {
+        .updateVoxel(1);
+    if (ES.doLight) {
+        if (ES.doRGBPropagation && isLightSource) {
             tasks.rgb.remove.push(x, y, z);
             RGBRemove(tasks);
         }
         updateLightTask(tasks);
-        if (ES.doRGBPropagation()) {
+        if (ES.doRGBPropagation) {
             RGBUpdate(tasks);
         }
-        if (ES.doSunPropagation()) {
+        if (ES.doSunPropagation) {
             SunUpdate(tasks);
         }
     }
@@ -80,9 +80,9 @@ export async function PaintAndUpdate(data) {
         return false;
     const raw = data[1];
     const isOpaque = voxel.isOpaque();
-    let doRGB = ES.doRGBPropagation();
-    let doSun = ES.doSunPropagation();
-    lighttest: if (ES.doLight()) {
+    let doRGB = ES.doRGBPropagation;
+    let doSun = ES.doSunPropagation;
+    lighttest: if (ES.doLight) {
         const light = voxel.getLight();
         if (light <= 0)
             break lighttest;
@@ -104,24 +104,19 @@ export async function PaintAndUpdate(data) {
     if (id < 0)
         return false;
     voxel.setId(id);
-    voxel.setState(raw[2]);
-    const substance = voxel.getSubstance();
-    if (substance > -1 && !voxel.isAir()
-        ? substanceData.setSubstance(voxel.getSubstance()).isLiquid()
-        : false) {
-        voxel.setLevel(7);
-    }
+    voxel.setLevel(raw[2]);
+    voxel.setState(raw[3]);
     voxel.setMod(raw[4]);
     if (raw[3] > 0 && voxel.canHaveSecondaryVoxel()) {
         voxel.setSecondary(true);
-        voxel.setId(raw[3]);
+        voxel.setId(raw[5]);
         voxel.setSecondary(false);
     }
     if (voxel.isLightSource() && voxel.getLightSourceValue()) {
         voxel.setLight(voxel.getLightSourceValue());
     }
-    voxel.updateHeightMap(0);
-    if (ES.doLight()) {
+    voxel.updateVoxel(0);
+    if (ES.doLight) {
         updateLightTask(tasks);
         if (doRGB) {
             tasks.rgb.update.push(x, y, z);
@@ -132,7 +127,7 @@ export async function PaintAndUpdate(data) {
         }
     }
     voxel = tasks.sDataCursor.getVoxel(x, y, z);
-    if (ES.doFlow()) {
+    if (ES.doFlow) {
         if (!voxel.isAir() &&
             substanceData.setSubstance(voxel.getSubstance()).isLiquid()) {
             FlowUpdate(tasks);
@@ -146,9 +141,9 @@ export async function VoxelUpdate(data) {
     const voxel = tasks.sDataCursor.getVoxel(x, y, z);
     if (!voxel)
         return false;
-    let doRGB = ES.doRGBPropagation();
-    let doSun = ES.doSunPropagation();
-    if (ES.doLight()) {
+    let doRGB = ES.doRGBPropagation;
+    let doSun = ES.doSunPropagation;
+    if (ES.doLight) {
         updateLightTask(tasks);
         if (doRGB) {
             tasks.rgb.update.push(x, y, z);
@@ -159,7 +154,7 @@ export async function VoxelUpdate(data) {
             SunUpdate(tasks);
         }
     }
-    if (ES.doFlow()) {
+    if (ES.doFlow) {
         if (substanceData.setSubstance(voxel.getSubstance()).isLiquid()) {
             FlowUpdate(tasks);
         }

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

@@ -11,4 +11,5 @@ export declare class TemplateVoxelCursor extends VoxelCursorInterface {
     get mod(): Uint16Array;
     constructor(dataCursor: TemplateCursor);
     loadIn(): void;
+    updateVoxel(mode: 0 | 1): void;
 }

package/Templates/Cursor/TemplateVoxelCursor.js

@@ -31,4 +31,5 @@ export class TemplateVoxelCursor extends VoxelCursorInterface {
         this._index = this.dataCursor._voxelIndex;
         this.process();
     }
+    updateVoxel(mode) { }
 }