@divinevoxel/vlox 0.0.4 → 0.0.6

package/Tasks/Propagation/InitTasks.js

@@ -1,23 +1,39 @@
 import { Threads } from "@amodx/threads";
 import { TasksIds } from "../TasksIds";
 import { UpdateTask } from "../Update/UpdateTask";
-import { PaintAndUpdate } from "../Update/VoxelUpdate";
-import { Propagation } from "./Propagation";
+import { WorldSpaces } from "../../World/WorldSpaces";
+import { RunWorldSun } from "./Illumanation/WorldSun";
+import { ExplosionManager } from "./Explosion/ExplosionManager";
+import { WorldRGB } from "./Illumanation/WorldRGB";
 export default function InitTasks() {
-    const propagation = new Propagation();
-    Threads.registerTasks(TasksIds.VoxelPaint, async (data, onDone) => {
-        await PaintAndUpdate(data);
-        if (onDone)
-            onDone();
-    }, "deferred");
-    Threads.registerTasks(TasksIds.Explosion, async (data) => {
-        await propagation.explosion(new UpdateTask(), data[1]);
+    Threads.registerTask(TasksIds.Propagation, async (location) => {
+        const task = new UpdateTask();
+        task.setOrigin(location);
+        WorldRGB(task);
+        //  task.setOrigin(location);
+        // WorldFlow(task);
+    });
+    Threads.registerTask(TasksIds.Explosion, async (data) => {
+        const location = data[0];
+        const sectorPosition = WorldSpaces.sector.getPosition(location[1], location[2], location[3]);
+        const task = new UpdateTask();
+        task.setOrigin([
+            location[0],
+            sectorPosition.x,
+            sectorPosition.y,
+            sectorPosition.z,
+        ]);
+        ExplosionManager.runExplosion(task, data[1]);
     });
-    Threads.registerTasks(TasksIds.WorldSun, (data, onDone) => {
+    Threads.registerTask(TasksIds.WorldSun, (location) => {
+        const sectorPosition = WorldSpaces.sector.getPosition(location[1], location[2], location[3]);
         const task = new UpdateTask();
-        task.setOrigin(data[0]);
-        propagation.worldSun(task);
-        if (onDone)
-            onDone();
-    }, "deferred");
+        task.setOrigin([
+            location[0],
+            sectorPosition.x,
+            sectorPosition.y,
+            sectorPosition.z,
+        ]);
+        RunWorldSun(task);
+    });
 }

package/Tasks/Propagation/index.d.ts

@@ -1 +1,2 @@
-export * from "./Propagation.js";
+export * from "./Illumanation/RGBUpdate";
+export * from "./Illumanation/SunUpdate";

package/Tasks/Propagation/index.js

@@ -1 +1,2 @@
-export * from "./Propagation.js";
+export * from "./Illumanation/RGBUpdate";
+export * from "./Illumanation/SunUpdate";

package/Tasks/Tasks.types.d.ts

@@ -1,86 +1,15 @@
 import type { LocationData } from "../Math/index.js";
 import type { Vec3Array } from "@amodx/math";
-import type { RawVoxelData } from "../Voxels/Voxel.types.js";
-import { ChunkData, ColumnData, RegionData } from "Data/World/Classes";
-export type Priorities = 0 | 1 | 2 | 3;
-export type PriorityTask<T> = {
-    data: T;
-    priority: Priorities;
-};
+import type { RawVoxelData } from "../Voxels/Types/Voxel.types.js";
+import { SectorData } from "World/index.js";
 export type WorldLockTasks = [
     dimension: string,
     start: Vec3Array,
     end: Vec3Array
 ];
-export type LightUpdateTask = [number, number, number];
-export type WorldSunTask = [location: LocationData, originThread: string];
-export type UpdateTasks = [
-    location: LocationData,
-    buildQueue: string,
-    originThread: string
-];
-export type VoxelUpdateTasks = [
-    location: LocationData,
-    raw: RawVoxelData,
-    buildQueue: string,
-    originThread: string
-];
-export type AnaylzerTask = [
-    location: LocationData,
-    buildQueue: string,
-    originThread: string
-];
-export type AddToRebuildQueue = [
-    location: LocationData,
-    buildQueue: string,
-    priority: Priorities
-];
+export type VoxelUpdateTasks = [location: LocationData, raw: RawVoxelData];
 export type RunRebuildTasks = [buildQueue: string];
-export type RunBuildQueue = [dimension: string, chunks: Vec3Array[]];
-export type BuildTasks = [location: LocationData, LOD: number];
+export type RunBuildQueue = [dimension: string, sections: Vec3Array[]];
 export type GenerateTasks = [location: LocationData, data: any];
-export type ExplosionTasks = [
-    location: LocationData,
-    radius: number,
-    buildQueue: string,
-    originThread: string
-];
-export type LoadChunkDataTasks = [location: LocationData, chunk: ChunkData];
-export type LoadColumnDataTasks = [location: LocationData, column: ColumnData];
-export type LoadRegionDataTasks = [location: LocationData, region: RegionData];
-export type LoadRegionHeadertasks = [
-    location: LocationData,
-    data: SharedArrayBuffer
-];
-export type GetRichDataTasks = [location: LocationData, segment: string];
-export type SetRichDataTasks = [
-    location: LocationData,
-    segment: string,
-    objectBuffer: ArrayBuffer
-];
-export type SetRichColumnTasks = [
-    location: LocationData,
-    objectBuffer: ArrayBuffer
-];
-export type RequestLightUpdateQueueData = {
-    rgb: {
-        update: number[][];
-        rmeove: number[][];
-    };
-    sun: {
-        update: number[][];
-        rmeove: number[][];
-    };
-};
-export type RequestFlowUpdateQueueData = {
-    flow: {
-        update: number[][];
-        rmeove: number[][];
-    };
-} & RequestLightUpdateQueueData;
-export type RequestsVoxelUpdateQueuesData = {
-    flow: {
-        update: number[][];
-        rmeove: number[][];
-    };
-} & RequestLightUpdateQueueData;
+export type ExplosionTasks = [location: LocationData, radius: number];
+export type LoadSectorDataTasks = [location: LocationData, sector: SectorData];

package/Tasks/TasksIds.d.ts

@@ -1,6 +1,6 @@
 export declare enum TasksIds {
-    BuildChunk = 0,
-    BuildColumn = 1,
+    BuildSection = 0,
+    BuildSector = 1,
     Generate = 2,
     Decorate = 3,
     RGBlightUpdate = 4,
@@ -8,7 +8,7 @@ export declare enum TasksIds {
     WorldSun = 6,
     SunLightUpdate = 7,
     SunLightRemove = 8,
-    AnalyzerPropagation = 9,
+    Propagation = 9,
     AnalyzerUpdate = 10,
     FlowUpdate = 11,
     FlowRemove = 12,

package/Tasks/TasksIds.js

@@ -1,7 +1,7 @@
 export var TasksIds;
 (function (TasksIds) {
-    TasksIds[TasksIds["BuildChunk"] = 0] = "BuildChunk";
-    TasksIds[TasksIds["BuildColumn"] = 1] = "BuildColumn";
+    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";
@@ -9,7 +9,7 @@ export var TasksIds;
     TasksIds[TasksIds["WorldSun"] = 6] = "WorldSun";
     TasksIds[TasksIds["SunLightUpdate"] = 7] = "SunLightUpdate";
     TasksIds[TasksIds["SunLightRemove"] = 8] = "SunLightRemove";
-    TasksIds[TasksIds["AnalyzerPropagation"] = 9] = "AnalyzerPropagation";
+    TasksIds[TasksIds["Propagation"] = 9] = "Propagation";
     TasksIds[TasksIds["AnalyzerUpdate"] = 10] = "AnalyzerUpdate";
     TasksIds[TasksIds["FlowUpdate"] = 11] = "FlowUpdate";
     TasksIds[TasksIds["FlowRemove"] = 12] = "FlowRemove";

package/Tasks/Update/InitTasks.js

@@ -2,37 +2,22 @@ import { Threads } from "@amodx/threads";
 import { TasksIds } from "../TasksIds";
 import { VoxelUpdate, EreaseAndUpdate, PaintAndUpdate } from "./VoxelUpdate";
 export default function (props) {
-    Threads.registerTasks(TasksIds.VoxelUpdate, async (data, onDone) => {
+    Threads.registerTask(TasksIds.VoxelUpdate, async (data) => {
         const tasks = await VoxelUpdate(data);
-        if (!tasks) {
-            if (onDone)
-                onDone();
+        if (!tasks)
             return;
-        }
         props.onDone(tasks);
-        if (onDone)
-            onDone();
-    }, "deferred");
-    Threads.registerTasks(TasksIds.VoxelErease, async (data, onDone) => {
+    });
+    Threads.registerTask(TasksIds.VoxelErease, async (data) => {
         const tasks = await EreaseAndUpdate(data);
-        if (!tasks) {
-            if (onDone)
-                onDone();
+        if (!tasks)
             return;
-        }
         props.onDone(tasks);
-        if (onDone)
-            onDone();
-    }, "deferred");
-    Threads.registerTasks(TasksIds.VoxelPaint, async (data, onDone) => {
+    });
+    Threads.registerTask(TasksIds.VoxelPaint, async (data) => {
         const tasks = await PaintAndUpdate(data);
-        if (!tasks) {
-            if (onDone)
-                onDone();
+        if (!tasks)
             return;
-        }
         props.onDone(tasks);
-        if (onDone)
-            onDone();
-    }, "deferred");
+    });
 }

package/Tasks/Update/UpdateTask.d.ts

@@ -1,4 +1,4 @@
-import { WorldCursor } from "../../Data/Cursor/World/WorldCursor";
+import { WorldCursor } from "../../World/Cursor/WorldCursor";
 import { Vec3Array, Vector3Like } from "@amodx/math";
 import { LocationData } from "../../Math";
 export declare class TaskMap {
@@ -18,7 +18,7 @@ declare class UpdatedBounds {
     constructor(_task: UpdateTask);
     reset(): void;
     update(x: number, y: number, z: number): void;
-    getChunks(): Vec3Array[];
+    getSections(): Vec3Array[];
 }
 export declare class UpdateTask {
     flow: FlowQueues;

package/Tasks/Update/UpdateTask.js

@@ -1,6 +1,6 @@
-import { WorldCursor } from "../../Data/Cursor/World/WorldCursor";
+import { WorldCursor } from "../../World/Cursor/WorldCursor";
 import { Vector3Like } from "@amodx/math";
-import { WorldSpaces } from "../../Data/World/WorldSpaces";
+import { WorldSpaces } from "../../World/WorldSpaces";
 export class TaskMap {
     _map = [];
     get size() {
@@ -29,6 +29,7 @@ export class TaskMap {
 }
 const NegativeInfinityVec3 = Vector3Like.Create(-Infinity, -Infinity, -Infinity);
 const InfinityVec3 = Vector3Like.Create(Infinity, Infinity, Infinity);
+const tempPosition = Vector3Like.Create();
 class UpdatedBounds {
     _task;
     min = Vector3Like.Clone(InfinityVec3);
@@ -54,26 +55,26 @@ class UpdatedBounds {
         if (z > this.max.z)
             this.max.z = z;
     }
-    getChunks() {
-        const minChunkPos = WorldSpaces.chunk.getPositionXYZ(this.min.x - 1, this.min.y - 1, this.min.z - 1);
-        const minX = minChunkPos.x;
-        const minY = minChunkPos.y;
-        const minZ = minChunkPos.z;
-        const maxChunkPos = WorldSpaces.chunk.getPositionXYZ(this.max.x + 1, this.max.y + 1, this.max.z + 1);
-        const maxX = maxChunkPos.x;
-        const maxY = maxChunkPos.y;
-        const maxZ = maxChunkPos.z;
-        const chunkPositions = [];
-        for (let x = minX; x <= maxX; x += WorldSpaces.chunk._bounds.x) {
-            for (let y = minY; y <= maxY; y += WorldSpaces.chunk._bounds.y) {
-                for (let z = minZ; z <= maxZ; z += WorldSpaces.chunk._bounds.z) {
+    getSections() {
+        const minSectionPos = WorldSpaces.section.getPosition(this.min.x - 1, this.min.y - 1, this.min.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 maxX = maxSectionPos.x;
+        const maxY = maxSectionPos.y;
+        const maxZ = maxSectionPos.z;
+        const sectionPositions = [];
+        for (let x = minX; x <= maxX; x += WorldSpaces.section.bounds.x) {
+            for (let y = minY; y <= maxY; y += WorldSpaces.section.bounds.y) {
+                for (let z = minZ; z <= maxZ; z += WorldSpaces.section.bounds.z) {
                     if (!this._task.nDataCursor.inBounds(x, y, z))
                         continue;
-                    chunkPositions.push([x, y, z]);
+                    sectionPositions.push([x, y, z]);
                 }
             }
         }
-        return chunkPositions;
+        return sectionPositions;
     }
 }
 export class UpdateTask {

package/Tasks/Update/VoxelUpdate.d.ts

@@ -1,5 +1,6 @@
-import { UpdateTasks, VoxelUpdateTasks } from "../Tasks.types.js";
+import { VoxelUpdateTasks } from "../Tasks.types.js";
 import { UpdateTask } from "./UpdateTask.js";
-export declare function EreaseAndUpdate(data: UpdateTasks): Promise<false | UpdateTask>;
+import { LocationData } from "../../Math/index.js";
+export declare function EreaseAndUpdate(location: LocationData): Promise<false | UpdateTask>;
 export declare function PaintAndUpdate(data: VoxelUpdateTasks): Promise<false | UpdateTask>;
 export declare function VoxelUpdate(data: VoxelUpdateTasks): Promise<false | UpdateTask>;

package/Tasks/Update/VoxelUpdate.js

@@ -1,8 +1,11 @@
 import { EngineSettings as ES } from "../../Settings/EngineSettings.js";
-import { $3dCardinalNeighbors } from "../../Math/Constants/CardinalNeighbors.js";
-import { Propagation } from "../../Tasks/Propagation/Propagation.js";
+import { $3dCardinalNeighbors } from "../../Math/CardinalNeighbors.js";
 import { UpdateTask } from "./UpdateTask.js";
 import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
+import { RGBRemove, RGBUpdate } from "../Propagation/Illumanation/RGBUpdate.js";
+import { SunRemove, SunUpdate } from "../Propagation/Illumanation/SunUpdate.js";
+import { FlowUpdate } from "../Propagation/Flow/FlowUpdate.js";
+import { FlowRemove } from "../Propagation/Flow/FlowRemove.js";
 const tasks = new UpdateTask();
 const substanceData = new SubstanceDataTool();
 const updateLightTask = (tasks) => {
@@ -29,16 +32,16 @@ const updateLightTask = (tasks) => {
         }
     }
 };
-export async function EreaseAndUpdate(data) {
-    const [dimension, x, y, z] = data[0];
-    tasks.setOrigin(data[0]);
+export async function EreaseAndUpdate(location) {
+    const [dimension, x, y, z] = location;
+    tasks.setOrigin(location);
     let voxel = tasks.sDataCursor.getVoxel(x, y, z);
     if (!voxel)
         return false;
     substanceData.setSubstance(voxel.getSubstance());
     if (!voxel.isAir() && ES.doFlow() && voxel.isRenderable()) {
         if (substanceData.isLiquid()) {
-            await Propagation.instance.flowRemove(tasks);
+            FlowRemove(tasks);
             return tasks;
         }
     }
@@ -51,20 +54,20 @@ export async function EreaseAndUpdate(data) {
         .setId(0)
         .setLevel(0)
         .setLevelState(0)
-        .setShapeState(0)
+        .setState(0)
         .setMod(0)
         .updateHeightMap(1);
     if (ES.doLight()) {
         if (ES.doRGBPropagation() && isLightSource) {
             tasks.rgb.remove.push(x, y, z);
-            Propagation.instance.rgbRemove(tasks);
+            RGBRemove(tasks);
         }
         updateLightTask(tasks);
         if (ES.doRGBPropagation()) {
-            Propagation.instance.rgbUpdate(tasks);
+            RGBUpdate(tasks);
         }
         if (ES.doSunPropagation()) {
-            Propagation.instance.sunUpdate(tasks);
+            SunUpdate(tasks);
         }
     }
     return tasks;
@@ -86,13 +89,13 @@ export async function PaintAndUpdate(data) {
         if (doSun) {
             if (voxel.hasSunLight()) {
                 tasks.sun.remove.push(x, y, z);
-                Propagation.instance.sunRemove(tasks);
+                SunRemove(tasks);
             }
         }
         if (doRGB) {
             if (voxel.hasRGBLight() && isOpaque) {
                 tasks.rgb.remove.push(x, y, z);
-                Propagation.instance.rgbRemove(tasks);
+                RGBRemove(tasks);
             }
         }
     }
@@ -101,7 +104,7 @@ export async function PaintAndUpdate(data) {
     if (id < 0)
         return false;
     voxel.setId(id);
-    voxel.setShapeState(raw[2]);
+    voxel.setState(raw[2]);
     const substance = voxel.getSubstance();
     if (substance > -1 && !voxel.isAir()
         ? substanceData.setSubstance(voxel.getSubstance()).isLiquid()
@@ -122,17 +125,17 @@ export async function PaintAndUpdate(data) {
         updateLightTask(tasks);
         if (doRGB) {
             tasks.rgb.update.push(x, y, z);
-            Propagation.instance.rgbUpdate(tasks);
+            RGBUpdate(tasks);
         }
         if (doSun) {
-            Propagation.instance.sunUpdate(tasks);
+            SunUpdate(tasks);
         }
     }
     voxel = tasks.sDataCursor.getVoxel(x, y, z);
     if (ES.doFlow()) {
         if (!voxel.isAir() &&
             substanceData.setSubstance(voxel.getSubstance()).isLiquid()) {
-            Propagation.instance.flowUpdate(tasks);
+            FlowUpdate(tasks);
         }
     }
     return tasks;
@@ -149,15 +152,16 @@ export async function VoxelUpdate(data) {
         updateLightTask(tasks);
         if (doRGB) {
             tasks.rgb.update.push(x, y, z);
-            Propagation.instance.rgbUpdate(tasks);
+            RGBUpdate(tasks);
         }
         if (doSun) {
-            Propagation.instance.sunUpdate(tasks);
+            tasks.sun.update.push(x, y, z);
+            SunUpdate(tasks);
         }
     }
     if (ES.doFlow()) {
         if (substanceData.setSubstance(voxel.getSubstance()).isLiquid()) {
-            Propagation.instance.flowUpdate(tasks);
+            FlowUpdate(tasks);
         }
     }
     return tasks;

package/Tasks/WorldGeneration/InitTasks.js

@@ -2,14 +2,6 @@ import { Threads } from "@amodx/threads";
 import { WorldGeneration } from "./WorldGeneration";
 import { TasksIds } from "../../Tasks/TasksIds";
 export default function () {
-    Threads.registerTasks(TasksIds.Generate, (data, onDone) => {
-        if (!onDone)
-            return;
-        WorldGeneration.generate(data, "generate", onDone);
-    }, "deferred");
-    Threads.registerTasks(TasksIds.Decorate, (data, onDone) => {
-        if (!onDone)
-            return;
-        WorldGeneration.generate(data, "decorate", onDone);
-    }, "deferred");
+    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)));
 }

package/Tasks/WorldGeneration/WorldGenBrush.d.ts

@@ -7,10 +7,10 @@ export declare class WorldGenBrush extends BrushTool {
     tasks: UpdateTask;
     start(dimension: string, x: number, y: number, z: number): this;
     paint(): this;
-    getUpdatedChunks(): Vec3Array[];
+    getUpdatedSections(): Vec3Array[];
     update(): false | undefined;
     erase(): this;
     runUpdates(): void;
-    worldAlloc(start: Vec3Array, end: Vec3Array): Promise<boolean>;
-    worldDealloc(start: Vec3Array, end: Vec3Array): Promise<boolean>;
+    worldAlloc(start: Vec3Array, end: Vec3Array): Promise<any>;
+    worldDealloc(start: Vec3Array, end: Vec3Array): Promise<any>;
 }

package/Tasks/WorldGeneration/WorldGenBrush.js

@@ -1,11 +1,12 @@
 import { WorldGenRegister } from "./WorldGenRegister.js";
 import { BrushTool } from "../../Tools/Brush/Brush.js";
-import { LightData } from "../../Voxels/LightData.js";
+import { VoxelLightData } from "../../Voxels/Cursor/VoxelLightData.js";
 import { WorldGeneration } from "./WorldGeneration.js";
-import { SafePromise } from "@amodx/core/Promises/SafePromise.js";
-import { Propagation } from "../Propagation/Propagation.js";
 import { DivineVoxelEngineConstructor } from "../../Contexts/Constructor/DivineVoxelEngineConstructor.js";
 import { UpdateTask } from "../Update/UpdateTask.js";
+import { RGBRemove, RGBUpdate } from "../Propagation/Illumanation/RGBUpdate.js";
+import { SunRemove, SunUpdate } from "../Propagation/Illumanation/SunUpdate.js";
+const lightData = new VoxelLightData();
 export class WorldGenBrush extends BrushTool {
     constructor() {
         super();
@@ -40,21 +41,21 @@ export class WorldGenBrush extends BrushTool {
         if (sl > 0 || !voxel.isAir()) {
             this._erase();
             voxel.setLight(sl < 0 ? 0 : sl);
-            if (LightData.hasRGBLight(sl)) {
+            if (lightData.hasRGBLight(sl)) {
                 this.tasks.rgb.remove.push(this.x, this.y, this.z);
-                Propagation.instance.rgbRemove(this.tasks);
+                RGBRemove(this.tasks);
             }
-            if (LightData.hasSunLight(sl)) {
+            if (lightData.hasSunLight(sl)) {
                 this.tasks.sun.remove.push(this.x, this.y, this.z);
-                Propagation.instance.sunRemove(this.tasks);
+                SunRemove(this.tasks);
             }
         }
         this._paint();
         this.tasks.bounds.update(this.x, this.y, this.z);
         return this;
     }
-    getUpdatedChunks() {
-        const queue = this.tasks.bounds.getChunks();
+    getUpdatedSections() {
+        const queue = this.tasks.bounds.getSections();
         this.tasks.bounds.reset();
         return queue;
     }
@@ -63,11 +64,11 @@ export class WorldGenBrush extends BrushTool {
         if (!voxel)
             return false;
         const sl = voxel.getLight();
-        if (LightData.hasRGBLight(sl)) {
+        if (lightData.hasRGBLight(sl)) {
             this.tasks.rgb.update.push(this.x, this.y, this.z);
             //    Propagation.instance.rgbUpdate(this.tasks);
         }
-        if (LightData.hasSunLight(sl)) {
+        if (lightData.hasSunLight(sl)) {
             this.tasks.sun.update.push(this.x, this.y, this.z);
             //  Propagation.instance.sunUpdate(this.tasks);
         }
@@ -81,35 +82,27 @@ export class WorldGenBrush extends BrushTool {
         this._erase();
         voxel = this.dataCursor.getVoxel(this.x, this.y, this.z);
         voxel.setLight(sl > 0 ? sl : 0);
-        if (LightData.hasRGBLight(sl)) {
+        if (lightData.hasRGBLight(sl)) {
             this.tasks.rgb.remove.push(this.x, this.y, this.z);
-            Propagation.instance.rgbRemove(this.tasks);
+            RGBRemove(this.tasks);
         }
-        if (LightData.hasSunLight(sl)) {
+        if (lightData.hasSunLight(sl)) {
             this.tasks.sun.remove.push(this.x, this.y, this.z);
-            Propagation.instance.sunRemove(this.tasks);
+            SunRemove(this.tasks);
         }
         this.tasks.bounds.update(this.x, this.y, this.z);
         return this;
     }
     runUpdates() {
-        Propagation.instance.rgbUpdate(this.tasks);
-        Propagation.instance.sunUpdate(this.tasks);
+        RGBUpdate(this.tasks);
+        SunUpdate(this.tasks);
         this.tasks.rgb.removeMap.clear();
         this.tasks.sun.removeMap.clear();
     }
     worldAlloc(start, end) {
-        return new SafePromise("worldAlloc", (resolve) => {
-            DivineVoxelEngineConstructor.instance.threads.world.runPromiseTasks("world-alloc", [this.dimension, start, end], [], () => {
-                resolve(true);
-            });
-        }).run();
+        return DivineVoxelEngineConstructor.instance.threads.world.runTaskAsync("world-alloc", [this.dimension, start, end]);
     }
     worldDealloc(start, end) {
-        return new SafePromise("worldDealloc", (resolve) => {
-            DivineVoxelEngineConstructor.instance.threads.world.runPromiseTasks("world-dealloc", [this.dimension, start, end], [], () => {
-                resolve(true);
-            });
-        }).run();
+        return DivineVoxelEngineConstructor.instance.threads.world.runTaskAsync("world-dealloc", [this.dimension, start, end]);
     }
 }

package/Tasks/WorldGeneration/WorldGenRegister.d.ts

@@ -1,11 +1,11 @@
 import type { LocationData } from "../../Math";
-import { RawVoxelData } from "../../Voxels/Voxel.types";
+import { RawVoxelData } from "../../Voxels/Types/Voxel.types";
 export declare class WorldGenRegister {
     static MAX_ATTEMPTS: number;
     static _requests: Map<string, {
         attempts: number;
         dimension: string;
-        chunks: Map<string, [x: number, y: number, z: number]>;
+        sections: Map<string, [x: number, y: number, z: number]>;
         voxels: [x: number, y: number, z: number, data: RawVoxelData][];
     }>;
     static registerRequest(location: LocationData): string;