@divinevoxel/vlox 0.0.74 → 0.0.76

package/Tasks/Propagation/Illumanation/RGBUpdate.js

@@ -1,4 +1,4 @@
-import { $3dCardinalNeighbors } from "../../../Math/CardinalNeighbors";
+import { CardinalNeighbors3D } from "../../../Math/CardinalNeighbors";
 import { getMinusOneForRGB, isGreaterOrEqualThanForRGBRemove, isLessThanForRGBAdd, isLessThanForRGBRemove, removeRGBLight, } from "./CommonFunctions";
 //@todo change array to not use push and shift
 export function RGBUpdate(tasks) {
@@ -14,9 +14,9 @@ export function RGBUpdate(tasks) {
         if (sl <= 0)
             continue;
         for (let i = 0; i < 6; i++) {
-            const nx = $3dCardinalNeighbors[i][0] + x;
-            const ny = $3dCardinalNeighbors[i][1] + y;
-            const nz = $3dCardinalNeighbors[i][2] + z;
+            const nx = CardinalNeighbors3D[i][0] + x;
+            const ny = CardinalNeighbors3D[i][1] + y;
+            const nz = CardinalNeighbors3D[i][2] + z;
             if (!tasks.nDataCursor.inBounds(nx, ny, nz))
                 continue;
             const voxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
@@ -28,7 +28,7 @@ export function RGBUpdate(tasks) {
                 voxel.setLight(getMinusOneForRGB(sl, nl));
             }
         }
-        tasks.bounds.update(x, y, z);
+        tasks.bounds.updateDisplay(x, y, z);
     }
 }
 export function RGBRemove(tasks) {
@@ -50,9 +50,9 @@ export function RGBRemove(tasks) {
         if (sl <= 0)
             continue;
         for (let i = 0; i < 6; i++) {
-            const nx = $3dCardinalNeighbors[i][0] + x;
-            const ny = $3dCardinalNeighbors[i][1] + y;
-            const nz = $3dCardinalNeighbors[i][2] + z;
+            const nx = CardinalNeighbors3D[i][0] + x;
+            const ny = CardinalNeighbors3D[i][1] + y;
+            const nz = CardinalNeighbors3D[i][2] + z;
             if (!tasks.nDataCursor.inBounds(nx, ny, nz))
                 continue;
             const voxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
@@ -75,7 +75,7 @@ export function RGBRemove(tasks) {
                 }
             }
         }
-        tasks.bounds.update(x, y, z);
+        tasks.bounds.updateDisplay(x, y, z);
         voxel.setLight(removeRGBLight(sl));
     }
     removeMap.clear();

package/Tasks/Propagation/Illumanation/SunUpdate.js

@@ -1,3 +1,4 @@
+import { VoxelLightData } from "../../../Voxels/Cursor/VoxelLightData";
 import { isLessThanForSunAdd, getMinusOneForSun, isLessThanForSunAddDown, getSunLightForUnderVoxel, removeSunLight, isLessThanForSunRemove, isGreaterOrEqualThanForSunRemove, sunLightCompareForDownSunRemove, } from "./CommonFunctions";
 const FloodOutPositions = [
     [1, 0, 0],
@@ -27,9 +28,9 @@ export function SunUpdate(tasks) {
             const nVoxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
             if (nVoxel) {
                 const nl = nVoxel.getLight();
-                if (nl > -1 && isLessThanForSunAdd(nl, sl)) {
+                if (nl > -1 && isLessThanForSunAdd(nl, sl, VoxelLightData.SunFallOffValue)) {
                     queue.push(nx, ny, nz);
-                    nVoxel.setLight(getMinusOneForSun(sl, nl));
+                    nVoxel.setLight(getMinusOneForSun(sl, nl, VoxelLightData.SunFallOffValue));
                 }
             }
         }
@@ -37,21 +38,21 @@ export function SunUpdate(tasks) {
             const nVoxel = tasks.nDataCursor.getVoxel(x, y - 1, z);
             if (nVoxel) {
                 const nl = nVoxel.getLight();
-                if (nl > -1 && isLessThanForSunAddDown(nl, sl)) {
+                if (nl > -1 && isLessThanForSunAddDown(nl, sl, VoxelLightData.SunFallOffValue)) {
                     if (nVoxel.isAir()) {
                         queue.push(x, y - 1, z);
-                        nVoxel.setLight(getSunLightForUnderVoxel(sl, nl));
+                        nVoxel.setLight(getSunLightForUnderVoxel(sl, nl, VoxelLightData.SunFallOffValue));
                     }
                     else {
                         if (!nVoxel.isOpaque()) {
                             queue.push(x, y - 1, z);
-                            nVoxel.setLight(getMinusOneForSun(sl, nl));
+                            nVoxel.setLight(getMinusOneForSun(sl, nl, VoxelLightData.SunFallOffValue));
                         }
                     }
                 }
             }
         }
-        tasks.bounds.update(x, y, z);
+        tasks.bounds.updateDisplay(x, y, z);
     }
 }
 export function SunRemove(tasks, clearUpdateMap = true) {
@@ -109,7 +110,7 @@ export function SunRemove(tasks, clearUpdateMap = true) {
                 }
             }
         }
-        tasks.bounds.update(x, y, z);
+        tasks.bounds.updateDisplay(x, y, z);
         voxel.setLight(removeSunLight(sl));
     }
     removeMap.clear();

package/Tasks/Propagation/Illumanation/WorldSun.js

@@ -1,4 +1,4 @@
-import { $3dCardinalNeighbors } from "../../../Math/CardinalNeighbors.js";
+import { CardinalNeighbors3D } from "../../../Math/CardinalNeighbors.js";
 import { WorldSpaces } from "../../../World/WorldSpaces.js";
 import { SectorHeightMap } from "../../../World/Sector/SectorHeightMap.js";
 import { VoxelLightData } from "../../../Voxels/Cursor/VoxelLightData.js";
@@ -15,7 +15,7 @@ const lightData = new VoxelLightData();
 export function RunWorldSun(tasks) {
     const [, cx, cy, cz] = tasks.origin;
     const RmaxY = SectorHeightMap.getRelative(tasks.origin);
-    const AmaxY = SectorHeightMap.getAbsolute(tasks.origin);
+    const AmaxY = SectorHeightMap.getAbsolute(...tasks.origin);
     const maxX = cx + WorldSpaces.sector.bounds.x;
     const maxY = cy + WorldSpaces.sector.bounds.y;
     const maxZ = cz + WorldSpaces.sector.bounds.z;
@@ -58,8 +58,8 @@ export function RunWorldSun(tasks) {
                 const l = sectorCursor.getVoxel(ix, iy, iz)?.getLight();
                 if (l && l < 0 && lightData.getS(l) != 0xf)
                     continue;
-                for (let i = 0; i < $3dCardinalNeighbors.length; i++) {
-                    const n = $3dCardinalNeighbors[i];
+                for (let i = 0; i < CardinalNeighbors3D.length; i++) {
+                    const n = CardinalNeighbors3D[i];
                     const nx = ix + n[0];
                     const ny = iy + n[1];
                     const nz = iz + n[2];
@@ -92,24 +92,26 @@ export function RunWorldSun(tasks) {
             const nVoxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
             if (nVoxel) {
                 const nl = nVoxel.getLight();
-                if (nl > -1 && isLessThanForSunAdd(nl, sl)) {
+                if (nl > -1 &&
+                    isLessThanForSunAdd(nl, sl, VoxelLightData.SunFallOffValue)) {
                     queue.push(nx, ny, nz);
-                    nVoxel.setLight(getMinusOneForSun(sl, nl));
+                    nVoxel.setLight(getMinusOneForSun(sl, nl, VoxelLightData.SunFallOffValue));
                 }
             }
         }
         const nVoxel = tasks.nDataCursor.getVoxel(x, y - 1, z);
         if (nVoxel) {
             const nl = nVoxel.getLight();
-            if (nl > -1 && isLessThanForSunAddDown(nl, sl)) {
+            if (nl > -1 &&
+                isLessThanForSunAddDown(nl, sl, VoxelLightData.SunFallOffValue)) {
                 if (nVoxel.isAir()) {
                     queue.push(x, y - 1, z);
-                    nVoxel.setLight(getSunLightForUnderVoxel(sl, nl));
+                    nVoxel.setLight(getSunLightForUnderVoxel(sl, nl, VoxelLightData.SunFallOffValue));
                 }
                 else {
                     if (!nVoxel.isOpaque()) {
                         queue.push(x, y - 1, z);
-                        nVoxel.setLight(getMinusOneForSun(sl, nl));
+                        nVoxel.setLight(getMinusOneForSun(sl, nl, VoxelLightData.SunFallOffValue));
                     }
                 }
             }

package/Tasks/Propagation/InitTasks.js

@@ -1,39 +1,27 @@
 import { Threads } from "@amodx/threads";
 import { TasksIds } from "../TasksIds";
 import { VoxelUpdateTask } from "../VoxelUpdateTask";
-import { WorldSpaces } from "../../World/WorldSpaces";
 import { RunWorldSun } from "./Illumanation/WorldSun";
-import { ExplosionManager } from "./Explosion/ExplosionManager";
 import { WorldRGB } from "./Illumanation/WorldRGB";
+import { WorldRegister } from "../../World/WorldRegister";
+import { Sector } from "../../World";
+import { getLocationData } from "../../Util/LocationData";
 export default function InitTasks() {
-    Threads.registerTask(TasksIds.Propagation, async (location) => {
-        const task = new VoxelUpdateTask();
-        task.setOrigin(location);
+    const task = new VoxelUpdateTask();
+    Threads.registerBinaryTask(TasksIds.WorldPropagation, (view) => {
+        const location = getLocationData(view);
+        task.setOrigin(...location);
         WorldRGB(task);
-        //  task.setOrigin(location);
-        // WorldFlow(task);
+        WorldRegister.sectors
+            .get(...location)
+            .setBitFlag(Sector.FlagIds.isWorldPropagationDone, true);
     });
-    Threads.registerTask(TasksIds.Explosion, async (data) => {
-        const location = data[0];
-        const sectorPosition = WorldSpaces.sector.getPosition(location[1], location[2], location[3]);
-        const task = new VoxelUpdateTask();
-        task.setOrigin([
-            location[0],
-            sectorPosition.x,
-            sectorPosition.y,
-            sectorPosition.z,
-        ]);
-        ExplosionManager.runExplosion(task, data[1]);
-    });
-    Threads.registerTask(TasksIds.WorldSun, (location) => {
-        const sectorPosition = WorldSpaces.sector.getPosition(location[1], location[2], location[3]);
-        const task = new VoxelUpdateTask();
-        task.setOrigin([
-            location[0],
-            sectorPosition.x,
-            sectorPosition.y,
-            sectorPosition.z,
-        ]);
+    Threads.registerBinaryTask(TasksIds.WorldSun, (view) => {
+        const location = getLocationData(view);
+        task.setOrigin(...location);
         RunWorldSun(task);
+        WorldRegister.sectors
+            .get(...location)
+            .setBitFlag(Sector.FlagIds.isWorldSunDone, true);
     });
 }

package/Tasks/Propagation/Power/PowerUpdate.js

@@ -1,4 +1,4 @@
-import { $3dCardinalNeighbors } from "../../../Math/CardinalNeighbors";
+import { CardinalNeighbors3D } from "../../../Math/CardinalNeighbors";
 //@todo change array to not use push and shift
 export function PowerUpdate(tasks) {
     const queue = tasks.power.update;
@@ -13,9 +13,9 @@ export function PowerUpdate(tasks) {
         if (sl <= 0)
             continue;
         for (let i = 0; i < 6; i++) {
-            const nx = $3dCardinalNeighbors[i][0] + x;
-            const ny = $3dCardinalNeighbors[i][1] + y;
-            const nz = $3dCardinalNeighbors[i][2] + z;
+            const nx = CardinalNeighbors3D[i][0] + x;
+            const ny = CardinalNeighbors3D[i][1] + y;
+            const nz = CardinalNeighbors3D[i][2] + z;
             if (!tasks.nDataCursor.inBounds(nx, ny, nz))
                 continue;
             const voxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
@@ -23,13 +23,13 @@ export function PowerUpdate(tasks) {
                 continue;
             const nl = voxel.getPower();
             if (nl > -1 && nl < sl) {
-                if (voxel._tags["dve_can_carry_power"]) {
+                if (voxel.tags["dve_can_carry_power"]) {
                     queue.push(nx, ny, nz);
                 }
                 voxel.setPower(sl - 1);
             }
         }
-        tasks.bounds.update(x, y, z);
+        tasks.bounds.updateDisplay(x, y, z);
     }
 }
 export function PowerRemove(tasks) {
@@ -51,9 +51,9 @@ export function PowerRemove(tasks) {
         if (sl <= 0)
             continue;
         for (let i = 0; i < 6; i++) {
-            const nx = $3dCardinalNeighbors[i][0] + x;
-            const ny = $3dCardinalNeighbors[i][1] + y;
-            const nz = $3dCardinalNeighbors[i][2] + z;
+            const nx = CardinalNeighbors3D[i][0] + x;
+            const ny = CardinalNeighbors3D[i][1] + y;
+            const nz = CardinalNeighbors3D[i][2] + z;
             if (!tasks.nDataCursor.inBounds(nx, ny, nz))
                 continue;
             const voxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
@@ -73,7 +73,7 @@ export function PowerRemove(tasks) {
                 }
             }
         }
-        tasks.bounds.update(x, y, z);
+        tasks.bounds.updateDisplay(x, y, z);
         voxel.setPower(0);
     }
     removeMap.clear();

package/Tasks/Tasks.types.d.ts

@@ -1,15 +1,31 @@
-import type { LocationData } from "../Math/index.js";
 import type { Vec3Array } from "@amodx/math";
-import type { RawVoxelData } from "../Voxels/Types/Voxel.types.js";
-import { SectorData } from "World/index.js";
+import type { VoxelPathData } from "../Templates/Path/VoxelPath.types.js";
+import type { EraseVoxel } from "./Paint/Erase/EraseVoxel.js";
+import type EraseVoxelTemplate from "./Paint/Erase/EraseVoxelTemplate.js";
+import type EraseVoxelPath from "./Paint/Erase/EraseVoxelPath.js";
+import { PaintVoxel } from "./Paint/Paint/PaintVoxel.js";
+import PaintVoxelTemplate from "./Paint/Paint/PaintVoxelTemplate.js";
+export type VoxelUpdateData = {
+    /**An array of allowed areas to update in. If not set will be ignored.*/
+    includedAreas?: [min: Vec3Array, max: Vec3Array][];
+    /**An array of excluded areas to update in. If not set will be ignored.*/
+    excludeAreas?: [min: Vec3Array, max: Vec3Array][];
+    /**Define what happens when painting a voxel and must replace it. Default is destory which will replace the voxel. Keep will keep the current voxel and not update. */
+    paintMode?: "keep" | "destory";
+};
+export type PaintVoxelTask = Parameters<typeof PaintVoxel>;
+export type PaintVoxelTemplateTask = Parameters<typeof PaintVoxelTemplate>;
+export type PaintVoxelPathTask = [
+    dimension: number,
+    start: Vec3Array,
+    pathData: VoxelPathData,
+    data: VoxelUpdateData
+];
+export type EraseVoxelTask = Parameters<typeof EraseVoxel>;
+export type EraseVoxelTemplateTask = Parameters<typeof EraseVoxelTemplate>;
+export type EraseVoxelPathTask = Parameters<typeof EraseVoxelPath>;
 export type WorldLockTasks = [
     dimension: number,
     start: Vec3Array,
     end: Vec3Array
 ];
-export type VoxelUpdateTasks = [location: LocationData, raw: RawVoxelData];
-export type RunRebuildTasks = [buildQueue: string];
-export type RunBuildQueue = [dimension: number, sections: Vec3Array[]];
-export type GenerateTasks = [location: LocationData, data: any];
-export type ExplosionTasks = [location: LocationData, radius: number];
-export type LoadSectorDataTasks = [location: LocationData, sector: SectorData];

package/Tasks/TasksIds.d.ts

@@ -1,22 +1,15 @@
 export declare enum TasksIds {
-    BuildSection = 0,
-    BuildSector = 1,
-    Generate = 2,
-    Decorate = 3,
-    RGBlightUpdate = 4,
-    RGBlightRemove = 5,
-    WorldSun = 6,
-    SunLightUpdate = 7,
-    SunLightRemove = 8,
-    Propagation = 9,
-    AnalyzerUpdate = 10,
-    FlowUpdate = 11,
-    FlowRemove = 12,
-    ConstructEntity = 13,
-    ConstructItem = 14,
-    Explosion = 15,
-    VoxelErease = 16,
-    VoxelPaint = 17,
-    VoxelUpdate = 18,
-    LogicUpdate = 19
+    BuildSection = "BuildSection",
+    BuildSectionSnapShot = "BuildSectionSnapShot",
+    BuildSector = "BuildSector",
+    Generate = "Generate",
+    Decorate = "Decorate",
+    WorldSun = "WorldSun",
+    WorldPropagation = "Propagation",
+    PaintVoxel = "PaintVoxel",
+    PaintVoxelTemplate = "PaintVoxelTemplate",
+    PaintVoxelPath = "PaintVoxelPath",
+    EraseVoxel = "EraseVoxel",
+    EraseVoxelTemplate = "EraseVoxelTemplate",
+    EraseVoxelPath = "EraseVoxelPath"
 }

package/Tasks/TasksIds.js

@@ -1,23 +1,16 @@
 export var TasksIds;
 (function (TasksIds) {
-    TasksIds[TasksIds["BuildSection"] = 0] = "BuildSection";
-    TasksIds[TasksIds["BuildSector"] = 1] = "BuildSector";
-    TasksIds[TasksIds["Generate"] = 2] = "Generate";
-    TasksIds[TasksIds["Decorate"] = 3] = "Decorate";
-    TasksIds[TasksIds["RGBlightUpdate"] = 4] = "RGBlightUpdate";
-    TasksIds[TasksIds["RGBlightRemove"] = 5] = "RGBlightRemove";
-    TasksIds[TasksIds["WorldSun"] = 6] = "WorldSun";
-    TasksIds[TasksIds["SunLightUpdate"] = 7] = "SunLightUpdate";
-    TasksIds[TasksIds["SunLightRemove"] = 8] = "SunLightRemove";
-    TasksIds[TasksIds["Propagation"] = 9] = "Propagation";
-    TasksIds[TasksIds["AnalyzerUpdate"] = 10] = "AnalyzerUpdate";
-    TasksIds[TasksIds["FlowUpdate"] = 11] = "FlowUpdate";
-    TasksIds[TasksIds["FlowRemove"] = 12] = "FlowRemove";
-    TasksIds[TasksIds["ConstructEntity"] = 13] = "ConstructEntity";
-    TasksIds[TasksIds["ConstructItem"] = 14] = "ConstructItem";
-    TasksIds[TasksIds["Explosion"] = 15] = "Explosion";
-    TasksIds[TasksIds["VoxelErease"] = 16] = "VoxelErease";
-    TasksIds[TasksIds["VoxelPaint"] = 17] = "VoxelPaint";
-    TasksIds[TasksIds["VoxelUpdate"] = 18] = "VoxelUpdate";
-    TasksIds[TasksIds["LogicUpdate"] = 19] = "LogicUpdate";
+    TasksIds["BuildSection"] = "BuildSection";
+    TasksIds["BuildSectionSnapShot"] = "BuildSectionSnapShot";
+    TasksIds["BuildSector"] = "BuildSector";
+    TasksIds["Generate"] = "Generate";
+    TasksIds["Decorate"] = "Decorate";
+    TasksIds["WorldSun"] = "WorldSun";
+    TasksIds["WorldPropagation"] = "Propagation";
+    TasksIds["PaintVoxel"] = "PaintVoxel";
+    TasksIds["PaintVoxelTemplate"] = "PaintVoxelTemplate";
+    TasksIds["PaintVoxelPath"] = "PaintVoxelPath";
+    TasksIds["EraseVoxel"] = "EraseVoxel";
+    TasksIds["EraseVoxelTemplate"] = "EraseVoxelTemplate";
+    TasksIds["EraseVoxelPath"] = "EraseVoxelPath";
 })(TasksIds || (TasksIds = {}));

package/Tasks/VoxelUpdateTask.d.ts

@@ -13,14 +13,14 @@ export declare class TaskMap {
 }
 declare class UpdatedBounds {
     _task: VoxelUpdateTask;
-    min: Vector3Like;
-    max: Vector3Like;
+    displayMin: Vector3Like;
+    displayMax: Vector3Like;
     dimension: number;
     constructor(_task: VoxelUpdateTask);
     start(dimension?: number): void;
-    update(x: number, y: number, z: number): void;
+    updateDisplay(x: number, y: number, z: number): void;
     getSections(): Vec3Array[];
-    markSectionsAsDirty(): void;
+    markDisplayDirty(): false | undefined;
 }
 export declare class VoxelUpdateTask {
     flow: FlowQueues;
@@ -31,7 +31,8 @@ export declare class VoxelUpdateTask {
     sDataCursor: WorldCursor;
     nDataCursor: WorldCursor;
     origin: LocationData;
-    setOrigin(origin: LocationData): void;
+    setOrigin(dimension: number, x: number, y: number, z: number): void;
+    setOriginAt(origin: LocationData): void;
     clear(): void;
 }
 declare class FlowQueues {

package/Tasks/VoxelUpdateTask.js

@@ -33,37 +33,37 @@ const InfinityVec3 = Vector3Like.Create(Infinity, Infinity, Infinity);
 const tempPosition = Vector3Like.Create();
 class UpdatedBounds {
     _task;
-    min = Vector3Like.Clone(InfinityVec3);
-    max = Vector3Like.Clone(NegativeInfinityVec3);
+    displayMin = Vector3Like.Clone(InfinityVec3);
+    displayMax = Vector3Like.Clone(NegativeInfinityVec3);
     dimension = 0;
     constructor(_task) {
         this._task = _task;
     }
     start(dimension) {
         this.dimension = dimension || 0;
-        Vector3Like.Copy(this.min, InfinityVec3);
-        Vector3Like.Copy(this.max, NegativeInfinityVec3);
-    }
-    update(x, y, z) {
-        if (x < this.min.x)
-            this.min.x = x;
-        if (y < this.min.y)
-            this.min.y = y;
-        if (z < this.min.z)
-            this.min.z = z;
-        if (x > this.max.x)
-            this.max.x = x;
-        if (y > this.max.y)
-            this.max.y = y;
-        if (z > this.max.z)
-            this.max.z = z;
+        Vector3Like.Copy(this.displayMin, InfinityVec3);
+        Vector3Like.Copy(this.displayMax, NegativeInfinityVec3);
+    }
+    updateDisplay(x, y, z) {
+        if (x < this.displayMin.x)
+            this.displayMin.x = x;
+        if (y < this.displayMin.y)
+            this.displayMin.y = y;
+        if (z < this.displayMin.z)
+            this.displayMin.z = z;
+        if (x > this.displayMax.x)
+            this.displayMax.x = x;
+        if (y > this.displayMax.y)
+            this.displayMax.y = y;
+        if (z > this.displayMax.z)
+            this.displayMax.z = z;
     }
     getSections() {
-        const minSectionPos = WorldSpaces.section.getPosition(this.min.x - 1, this.min.y - 1, this.min.z - 1, tempPosition);
+        const minSectionPos = WorldSpaces.section.getPosition(this.displayMin.x, this.displayMin.y, this.displayMin.z, tempPosition);
         const minX = minSectionPos.x;
         const minY = minSectionPos.y;
         const minZ = minSectionPos.z;
-        const maxSectionPos = WorldSpaces.section.getPosition(this.max.x + 1, this.max.y + 1, this.max.z + 1, tempPosition);
+        const maxSectionPos = WorldSpaces.section.getPosition(this.displayMax.x, this.displayMax.y, this.displayMax.z, tempPosition);
         const maxX = maxSectionPos.x;
         const maxY = maxSectionPos.y;
         const maxZ = maxSectionPos.z;
@@ -79,12 +79,20 @@ class UpdatedBounds {
         }
         return sectionPositions;
     }
-    markSectionsAsDirty() {
-        const minSectionPos = WorldSpaces.section.getPosition(this.min.x - 1, this.min.y - 1, this.min.z - 1, tempPosition);
+    markDisplayDirty() {
+        if (this.displayMax.x == -Infinity ||
+            this.displayMax.y == -Infinity ||
+            this.displayMax.z == -Infinity)
+            return false;
+        if (this.displayMin.x == Infinity ||
+            this.displayMin.y == Infinity ||
+            this.displayMin.z == Infinity)
+            return false;
+        const minSectionPos = WorldSpaces.section.getPosition(this.displayMin.x - 1, this.displayMin.y - 1, this.displayMin.z - 1, tempPosition);
         const minX = minSectionPos.x;
         const minY = minSectionPos.y;
         const minZ = minSectionPos.z;
-        const maxSectionPos = WorldSpaces.section.getPosition(this.max.x + 1, this.max.y + 1, this.max.z + 1, tempPosition);
+        const maxSectionPos = WorldSpaces.section.getPosition(this.displayMax.x + 1, this.displayMax.y + 1, this.displayMax.z + 1, tempPosition);
         const maxX = maxSectionPos.x;
         const maxY = maxSectionPos.y;
         const maxZ = maxSectionPos.z;
@@ -97,7 +105,9 @@ class UpdatedBounds {
                     if (!sector)
                         continue;
                     const section = sector.getSection(x, y, z);
-                    section.setDisplayDirty(true);
+                    if (!section.canRender())
+                        continue;
+                    section.incrementTick(section._Ticks.displayDirty);
                 }
             }
         }
@@ -111,21 +121,27 @@ export class VoxelUpdateTask {
     bounds = new UpdatedBounds(this);
     sDataCursor = new WorldCursor();
     nDataCursor = new WorldCursor();
-    origin;
-    setOrigin(origin) {
-        this.sDataCursor.setFocalPoint(...origin);
-        this.nDataCursor.setFocalPoint(...origin);
-        this.origin = origin;
-        this.rgb.removeMap.start(origin[1], origin[2], origin[3]);
-        this.sun.removeMap.start(origin[1], origin[2], origin[3]);
-        this.rgb.updateMap.start(origin[1], origin[2], origin[3]);
-        this.sun.updateMap.start(origin[1], origin[2], origin[3]);
-        this.flow.update.map.start(origin[1], origin[2], origin[3]);
-        this.flow.remove.map.start(origin[1], origin[2], origin[3]);
-        this.flow.remove.noRemoveMap.start(origin[1], origin[2], origin[3]);
-        this.bounds.start(origin[0]);
+    origin = [0, 0, 0, 0];
+    setOrigin(dimension, x, y, z) {
+        this.sDataCursor.setFocalPoint(dimension, x, y, z);
+        this.nDataCursor.setFocalPoint(dimension, x, y, z);
+        this.origin[0] = dimension;
+        this.origin[1] = x;
+        this.origin[2] = y;
+        this.origin[3] = z;
+        this.rgb.removeMap.start(x, y, z);
+        this.sun.removeMap.start(x, y, z);
+        this.rgb.updateMap.start(x, y, z);
+        this.sun.updateMap.start(x, y, z);
+        this.flow.update.map.start(x, y, z);
+        this.flow.remove.map.start(x, y, z);
+        this.flow.remove.noRemoveMap.start(x, y, z);
+        this.bounds.start(dimension);
         this.clear();
     }
+    setOriginAt(origin) {
+        this.setOrigin(...origin);
+    }
     clear() {
         this.rgb.clear();
         this.sun.clear();

package/Tasks/WorldGeneration/InitTasks.d.ts

@@ -1 +1,4 @@
-export default function (): void;
+import { Thread } from "@amodx/threads";
+export default function (props: {
+    worldThread: Thread;
+}): void;

package/Tasks/WorldGeneration/InitTasks.js

@@ -1,7 +1,10 @@
 import { Threads } from "@amodx/threads";
 import { WorldGeneration } from "./WorldGeneration";
 import { TasksIds } from "../../Tasks/TasksIds";
-export default function () {
-    Threads.registerTask(TasksIds.Generate, (data) => new Promise((resolve) => WorldGeneration.generate(data, "generate", resolve)));
-    Threads.registerTask(TasksIds.Decorate, (data) => new Promise((resolve) => WorldGeneration.generate(data, "decorate", resolve)));
+import { getLocationData } from "../../Util/LocationData";
+import { WorldGenRegister } from "./WorldGenRegister";
+export default function (props) {
+    WorldGenRegister._worldThread = props.worldThread;
+    Threads.registerBinaryTask(TasksIds.Generate, (data) => new Promise((resolve) => WorldGeneration.generate(getLocationData(data), "generate", resolve)));
+    Threads.registerBinaryTask(TasksIds.Decorate, (data) => new Promise((resolve) => WorldGeneration.generate(getLocationData(data), "decorate", resolve)));
 }

package/Tasks/WorldGeneration/WorldGen.types.d.ts

@@ -1,5 +1,4 @@
-import { GenerateTasks } from "../Tasks.types";
 export type WorldGenInterface = {
-    generate(data: GenerateTasks): Promise<any | void>;
-    decorate(data: GenerateTasks): Promise<any | void>;
+    generate(dimensionId: number, x: number, y: number, z: number): Promise<any | void>;
+    decorate(dimensionId: number, x: number, y: number, z: number): Promise<any | void>;
 };

package/Tasks/WorldGeneration/WorldGenBrush.js

@@ -2,7 +2,6 @@ import { WorldGenRegister } from "./WorldGenRegister.js";
 import { BrushTool } from "../../Tools/Brush/Brush.js";
 import { VoxelLightData } from "../../Voxels/Cursor/VoxelLightData.js";
 import { WorldGeneration } from "./WorldGeneration.js";
-import { DivineVoxelEngineConstructor } from "../../Contexts/Constructor/DivineVoxelEngineConstructor.js";
 import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
 import { RGBRemove, RGBUpdate } from "../Propagation/Illumanation/RGBUpdate.js";
 import { SunRemove, SunUpdate } from "../Propagation/Illumanation/SunUpdate.js";
@@ -16,7 +15,7 @@ export class WorldGenBrush extends BrushTool {
     tasks = new VoxelUpdateTask();
     start(dimension, x, y, z) {
         this.dataCursor.setFocalPoint(dimension, x, y, z);
-        this.tasks.setOrigin([dimension, x, y, z]);
+        this.tasks.setOriginAt([dimension, x, y, z]);
         this.dimension = dimension;
         this.x = x;
         this.y = y;
@@ -51,7 +50,7 @@ export class WorldGenBrush extends BrushTool {
             }
         }
         this._paint();
-        this.tasks.bounds.update(this.x, this.y, this.z);
+        this.tasks.bounds.updateDisplay(this.x, this.y, this.z);
         return this;
     }
     getUpdatedSections() {
@@ -73,7 +72,7 @@ export class WorldGenBrush extends BrushTool {
             this.tasks.sun.update.push(this.x, this.y, this.z);
             //  Propagation.instance.sunUpdate(this.tasks);
         }
-        this.tasks.bounds.update(this.x, this.y, this.z);
+        this.tasks.bounds.updateDisplay(this.x, this.y, this.z);
     }
     erase() {
         let voxel = this.dataCursor.getVoxel(this.x, this.y, this.z);
@@ -91,7 +90,7 @@ export class WorldGenBrush extends BrushTool {
             this.tasks.sun.remove.push(this.x, this.y, this.z);
             SunRemove(this.tasks);
         }
-        this.tasks.bounds.update(this.x, this.y, this.z);
+        this.tasks.bounds.updateDisplay(this.x, this.y, this.z);
         return this;
     }
     runUpdates() {
@@ -101,9 +100,9 @@ export class WorldGenBrush extends BrushTool {
         this.tasks.sun.removeMap.clear();
     }
     worldAlloc(start, end) {
-        return DivineVoxelEngineConstructor.instance.threads.world.runTaskAsync("world-alloc", [this.dimension, start, end]);
+        return WorldGenRegister._worldThread.runTaskAsync("world-alloc", [this.dimension, start, end]);
     }
     worldDealloc(start, end) {
-        return DivineVoxelEngineConstructor.instance.threads.world.runTaskAsync("world-dealloc", [this.dimension, start, end]);
+        return WorldGenRegister._worldThread.runTaskAsync("world-dealloc", [this.dimension, start, end]);
     }
 }