@divinevoxel/vlox 0.0.4 → 0.0.5

package/Tasks/Propagation/Illumanation/{Functions/SunUpdate.js → SunUpdate.js}

@@ -1,4 +1,4 @@
-import { LightData } from "../../../../Voxels/LightData";
+import { isLessThanForSunAdd, getMinusOneForSun, isLessThanForSunAddDown, getSunLightForUnderVoxel, removeSunLight, isLessThanForSunRemove, isGreaterOrEqualThanForSunRemove, sunLightCompareForDownSunRemove, } from "./CommonFunctions";
 const FloodOutPositions = [
     [1, 0, 0],
     [-1, 0, 0],
@@ -27,9 +27,9 @@ export function SunUpdate(tasks) {
             const nVoxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
             if (nVoxel) {
                 const nl = nVoxel.getLight();
-                if (nl > -1 && LightData.isLessThanForSunAdd(nl, sl)) {
+                if (nl > -1 && isLessThanForSunAdd(nl, sl)) {
                     queue.push(nx, ny, nz);
-                    nVoxel.setLight(LightData.getMinusOneForSun(sl, nl));
+                    nVoxel.setLight(getMinusOneForSun(sl, nl));
                 }
             }
         }
@@ -37,15 +37,15 @@ export function SunUpdate(tasks) {
             const nVoxel = tasks.nDataCursor.getVoxel(x, y - 1, z);
             if (nVoxel) {
                 const nl = nVoxel.getLight();
-                if (nl > -1 && LightData.isLessThanForSunAddDown(nl, sl)) {
+                if (nl > -1 && isLessThanForSunAddDown(nl, sl)) {
                     if (nVoxel.isAir()) {
                         queue.push(x, y - 1, z);
-                        nVoxel.setLight(LightData.getSunLightForUnderVoxel(sl, nl));
+                        nVoxel.setLight(getSunLightForUnderVoxel(sl, nl));
                     }
                     else {
                         if (!nVoxel.isOpaque()) {
                             queue.push(x, y - 1, z);
-                            nVoxel.setLight(LightData.getMinusOneForSun(sl, nl));
+                            nVoxel.setLight(getMinusOneForSun(sl, nl));
                         }
                     }
                 }
@@ -82,10 +82,10 @@ export function SunRemove(tasks, clearUpdateMap = true) {
             if (nVoxel) {
                 const nl = nVoxel.getLight();
                 if (nl > 0) {
-                    if (LightData.isLessThanForSunRemove(nl, sl)) {
+                    if (isLessThanForSunRemove(nl, sl)) {
                         remove.push(nx, ny, nz);
                     }
-                    else if (LightData.isGreaterOrEqualThanForSunRemove(nl, sl) &&
+                    else if (isGreaterOrEqualThanForSunRemove(nl, sl) &&
                         !updateMap.has(nx, ny, nz)) {
                         updateMap.add(nx, ny, nz);
                         update.push(nx, ny, nz);
@@ -98,10 +98,10 @@ export function SunRemove(tasks, clearUpdateMap = true) {
             if (nVoxel) {
                 const nl = nVoxel.getLight();
                 if (nl > 0) {
-                    if (LightData.sunLightCompareForDownSunRemove(nl, sl)) {
+                    if (sunLightCompareForDownSunRemove(nl, sl)) {
                         remove.push(x, y - 1, z);
                     }
-                    else if (LightData.isGreaterOrEqualThanForSunRemove(nl, sl) &&
+                    else if (isGreaterOrEqualThanForSunRemove(nl, sl) &&
                         !updateMap.has(x, y - 1, z)) {
                         updateMap.add(x, y - 1, z);
                         update.push(x, y - 1, z);
@@ -110,7 +110,7 @@ export function SunRemove(tasks, clearUpdateMap = true) {
             }
         }
         tasks.bounds.update(x, y, z);
-        voxel.setLight(LightData.removeSunLight(sl));
+        voxel.setLight(removeSunLight(sl));
     }
     removeMap.clear();
 }

package/Tasks/Propagation/Illumanation/WorldRGB.d.ts

@@ -0,0 +1,2 @@
+import { UpdateTask } from "../../../Tasks/Update/UpdateTask";
+export declare function WorldRGB(task: UpdateTask): false | undefined;

package/Tasks/Propagation/Illumanation/WorldRGB.js

@@ -0,0 +1,44 @@
+import { WorldSpaces } from "../../../World/WorldSpaces";
+import { WorldRegister } from "../../../World/WorldRegister";
+import { SectionCursor } from "../../../World/Cursor/SectionCursor";
+import { SectionHeightMap } from "../../../World/Section/SectionHeightMap";
+import { EngineSettings } from "../../../Settings/EngineSettings";
+import { RGBUpdate } from "./RGBUpdate";
+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]);
+    if (!sector) {
+        console.error(`Tried running world rgb on a sector that does not exist ${task.origin.toString()}`);
+        return false;
+    }
+    let maxX = WorldSpaces.section.bounds.x + sector.position[0];
+    let maxZ = WorldSpaces.section.bounds.z + sector.position[2];
+    for (let i = 0; i < sector.sections.length; i++) {
+        const section = sector.sections[i];
+        if (!section)
+            continue;
+        sectionCursor.setSection(section);
+        let [minY, maxY] = SectionHeightMap.setSection(section).getMinMax();
+        const cx = sector.position[0];
+        const cy = sector.position[1] + i * WorldSpaces.section.bounds.y;
+        const cz = sector.position[2];
+        if (Math.abs(minY) == Infinity && Math.abs(maxY) == Infinity)
+            continue;
+        for (let y = cy + minY; y <= cy + maxY; y++) {
+            for (let x = cx; x < maxX; x++) {
+                for (let z = cz; z < maxZ; z++) {
+                    const voxel = sectionCursor.getVoxel(x, y, z);
+                    if (!voxel || voxel.isAir())
+                        continue;
+                    if (voxel.isLightSource()) {
+                        task.rgb.update.push(x, y, z);
+                    }
+                }
+            }
+        }
+    }
+    RGBUpdate(task);
+}

package/Tasks/Propagation/Illumanation/WorldSun.d.ts

@@ -0,0 +1,2 @@
+import { UpdateTask } from "../../Update/UpdateTask.js";
+export declare function RunWorldSun(tasks: UpdateTask): void;

package/Tasks/Propagation/Illumanation/WorldSun.js

@@ -0,0 +1,119 @@
+//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";
+import { VoxelLightData } from "../../../Voxels/Cursor/VoxelLightData.js";
+import { getMinusOneForSun, getSunLightForUnderVoxel, isLessThanForSunAddDown, isLessThanForSunAdd, } from "./CommonFunctions.js";
+const FloodOutPositions = [
+    [1, 0, 0],
+    [-1, 0, 0],
+    [0, 0, 1],
+    [0, 0, -1],
+    [0, 1, 0],
+];
+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 maxZ = cz + WorldSpaces.sector.bounds.z;
+    const sectorCursor = tasks.nDataCursor.getSector(tasks.origin[1], tasks.origin[2], tasks.origin[3]);
+    if (!sectorCursor) {
+        console.warn("Could not load sector when running world sun at ", tasks.origin.toString());
+        return;
+    }
+    const minY = AmaxY - 1 < 0 ? 0 : AmaxY;
+    //fill
+    for (let iy = minY; iy < maxY; iy++) {
+        for (let ix = cx; ix < maxX; ix++) {
+            for (let iz = cz; iz < maxZ; iz++) {
+                const voxel = sectorCursor.getVoxel(ix, iy, iz);
+                if (!voxel)
+                    continue;
+                const l = voxel.getLight();
+                if (l < 0)
+                    continue;
+                voxel.setLight(lightData.setS(0xf, l));
+            }
+        }
+    }
+    const maxAcculamteY = AmaxY == RmaxY ? RmaxY + 1 : RmaxY;
+    let index = queue.length;
+    //accumulate
+    for (let iy = minY; iy <= maxAcculamteY; iy++) {
+        for (let ix = cx; ix < maxX; ix++) {
+            for (let iz = cz; iz < maxZ; iz++) {
+                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];
+                    const nx = ix + n[0];
+                    const ny = iy + n[1];
+                    const nz = iz + n[2];
+                    const nVoxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
+                    if (!nVoxel)
+                        continue;
+                    const nl = nVoxel.getLight();
+                    if (nl > -1 && lightData.getS(nl) < 0xf) {
+                        queue[index++] = ix;
+                        queue[index++] = iy;
+                        queue[index++] = iz;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    //flood
+    while (queue.length) {
+        const x = queue.shift();
+        const y = queue.shift();
+        const z = queue.shift();
+        const sl = tasks.sDataCursor.getVoxel(x, y, z)?.getLight();
+        if (!sl || sl < 0)
+            continue;
+        for (let i = 0; i < 5; i++) {
+            const nx = x + FloodOutPositions[i][0];
+            const ny = y + FloodOutPositions[i][1];
+            const nz = z + FloodOutPositions[i][2];
+            const nVoxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
+            if (nVoxel) {
+                const nl = nVoxel.getLight();
+                if (nl > -1 && isLessThanForSunAdd(nl, sl)) {
+                    queue.push(nx);
+                    queue.push(ny);
+                    queue.push(nz);
+                    nVoxel.setLight(getMinusOneForSun(sl, nl));
+                }
+            }
+        }
+        const nVoxel = tasks.nDataCursor.getVoxel(x, y - 1, z);
+        if (nVoxel) {
+            const nl = nVoxel.getLight();
+            if (nl > -1 && isLessThanForSunAddDown(nl, sl)) {
+                if (nVoxel.isAir()) {
+                    queue.push(x);
+                    queue.push(y - 1);
+                    queue.push(z);
+                    nVoxel.setLight(getSunLightForUnderVoxel(sl, nl));
+                }
+                else {
+                    if (!nVoxel.isOpaque()) {
+                        queue.push(x);
+                        queue.push(y - 1);
+                        queue.push(z);
+                        nVoxel.setLight(getMinusOneForSun(sl, nl));
+                    }
+                }
+            }
+        }
+    }
+}

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