@divinevoxel/vlox 0.0.74 → 0.0.75

package/Renderer/Classes/SectorMesh.js

@@ -1,10 +1,17 @@
 import { WorldSpaces } from "../../World/WorldSpaces";
 import { SectionMesh } from "./SectionMesh";
+import { MeshManager } from "../MeshManager";
 export class SectorMesh {
-    location;
-    sections = [];
-    constructor(location) {
-        this.location = location;
+    sections = new Array(WorldSpaces.sector.sectionVolumne).fill(null);
+    position = [0, 0, 0];
+    dipose() {
+        MeshManager._sectorPool.push(this);
+        for (const section of this.sections) {
+            if (!section)
+                continue;
+            section.dispose();
+        }
+        this.sections.fill(null);
     }
     getSection(x, y, z) {
         return this.sections[WorldSpaces.section.getIndex(x, y, z)];
@@ -13,7 +20,11 @@ export class SectorMesh {
         const index = WorldSpaces.section.getIndex(x, y, z);
         if (this.sections[index])
             return this.sections[index];
-        const section = new SectionMesh(this, index);
+        const section = MeshManager._sectionPool.length
+            ? MeshManager._sectionPool.shift()
+            : new SectionMesh();
+        section.sector = this;
+        section.index = index;
         this.sections[index] = section;
         return section;
     }
@@ -22,7 +33,7 @@ export class SectorMesh {
         if (!this.sections[index])
             return false;
         const section = this.sections[index];
-        delete this.sections[index];
+        this.sections[index] = null;
         return section;
     }
 }

package/Renderer/InitTasks.d.ts

@@ -1,2 +1 @@
-import { Thread, ThreadPool } from "@amodx/threads/";
-export default function RendererTasks(threads: Thread | ThreadPool): void;
+export default function RendererTasks(): void;

package/Renderer/InitTasks.js

@@ -1,25 +1,19 @@
 import { Threads } from "@amodx/threads/";
 import { MeshManager } from "./MeshManager";
 import { MeshRegister } from "./MeshRegister";
-import { TaskTool } from "../Tools/Tasks/TasksTool";
 import { EngineSettings } from "../Settings/EngineSettings";
-export default function RendererTasks(threads) {
-    const tasks = new TaskTool(threads);
+import { getLocationData } from "../Util/LocationData";
+export default function RendererTasks() {
     Threads.registerTask("set-section", (data, origin) => {
         MeshManager.updateSection(data);
         if (!EngineSettings.settings.rendererSettings.cpuBound) {
             origin.sendMessage([], [data]);
         }
     });
-    Threads.registerTask("remove-sector", (data) => {
-        MeshManager.removeSector(data);
+    Threads.registerBinaryTask("remove-sector", (data) => {
+        MeshManager.removeSector(...getLocationData(data));
     });
     Threads.registerTask("clear-all", (data) => {
         MeshRegister.clearAll();
     });
-    Threads.registerTask("build-queue", ([dim, sections]) => {
-        for (const position of sections) {
-            tasks.build.section.run([dim, ...position]);
-        }
-    });
 }

package/Renderer/MeshManager.d.ts

@@ -1,9 +1,14 @@
 import type { SetSectionMeshTask } from "../Mesher/Types/Mesher.types";
 import { LocationData } from "../Math/index.js";
 import { DVESectionMeshes } from "./Classes/DVESectionMeshes";
+import { SectorMesh } from "./Classes/SectorMesh";
+import { SectionMesh } from "./Classes/SectionMesh";
 export declare class MeshManager {
+    static _sectorPool: SectorMesh[];
+    static _sectionPool: SectionMesh[];
     static sectorMeshes: DVESectionMeshes;
     static runningUpdate: boolean;
     static updateSection(data: SetSectionMeshTask): void;
-    static removeSector(data: LocationData): false | undefined;
+    static removeSector(dimensionId: number, x: number, y: number, z: number): false | undefined;
+    static removeSectorAt(data: LocationData): false | undefined;
 }

package/Renderer/MeshManager.js

@@ -1,17 +1,19 @@
 import { MeshRegister } from "./MeshRegister.js";
-import { CompactedSectionVoxelMesh, } from "../Mesher/Geomtry/CompactedSectionVoxelMesh";
+import { CompactedSectionVoxelMesh } from "../Mesher/Geomtry/CompactedSectionVoxelMesh";
 const added = new Set();
 const compacted = new CompactedSectionVoxelMesh();
 const location = [0, 0, 0, 0];
 export class MeshManager {
+    static _sectorPool = [];
+    static _sectionPool = [];
     static sectorMeshes;
     static runningUpdate = false;
     static updateSection(data) {
         compacted.setData(data);
         compacted.getLocation(location);
-        let sector = MeshRegister.sectors.get(location);
+        let sector = MeshRegister.sectors.getAt(location);
         if (!sector) {
-            sector = MeshRegister.sectors.add(location);
+            sector = MeshRegister.sectors.addAt(location);
         }
         let section = sector.getSection(location[1], location[2], location[3]);
         if (!section) {
@@ -42,18 +44,13 @@ export class MeshManager {
      */
         this.sectorMeshes.updateVertexData(section, compacted);
     }
-    static removeSector(data) {
-        const sector = MeshRegister.sectors.remove(data);
+    static removeSector(dimensionId, x, y, z) {
+        const sector = MeshRegister.sectors.remove(dimensionId, x, y, z);
         if (!sector)
             return false;
-        for (const section of sector.sections) {
-            if (!section)
-                continue;
-            section.dispose();
-            for (const [, mesh] of section.meshes) {
-                this.sectorMeshes.returnMesh(mesh);
-            }
-            section.meshes.clear();
-        }
+        sector.dipose();
+    }
+    static removeSectorAt(data) {
+        return this.removeSector(...data);
     }
 }

package/Renderer/MeshRegister.d.ts

@@ -2,14 +2,16 @@ import { type LocationData } from "../Math/index.js";
 import { SectorMesh } from "./Classes/SectorMesh.js";
 export type MeshRegisterDimensions = Map<number, Map<string, SectorMesh>>;
 declare class Sectors {
-    static add(location: LocationData): SectorMesh;
-    static remove(location: LocationData): false | SectorMesh;
-    static get(location: LocationData): false | SectorMesh | undefined;
+    static add(dimensionId: number, x: number, y: number, z: number): SectorMesh;
+    static addAt(location: LocationData): SectorMesh;
+    static remove(dimensionId: number, x: number, y: number, z: number): false | SectorMesh;
+    static removeAt(location: LocationData): false | SectorMesh;
+    static get(dimensionId: number, x: number, y: number, z: number): false | SectorMesh | undefined;
+    static getAt(location: LocationData): false | SectorMesh | undefined;
 }
 declare class Dimensions {
     static add(id: number): Map<any, any>;
     static get(id: number): Map<string, SectorMesh> | undefined;
-    static getAllMeshes(id: number): Generator<[location: LocationData, substance: string, mesh: any]>;
     static remove(id: number): boolean;
 }
 export declare class MeshRegister {

package/Renderer/MeshRegister.js

@@ -1,36 +1,52 @@
+import { Vector3Like } from "@amodx/math";
 import { WorldSpaces } from "../World/WorldSpaces.js";
 import { SectorMesh } from "./Classes/SectorMesh.js";
+import { MeshManager } from "./MeshManager.js";
+const tempVec3 = Vector3Like.Create();
+const tempVec3Array = [0, 0, 0];
 class Sectors {
-    static add(location) {
-        let dimension = MeshRegister.dimensions.get(location[0]);
+    static add(dimensionId, x, y, z) {
+        let dimension = MeshRegister.dimensions.get(dimensionId);
         if (!dimension)
-            dimension = MeshRegister.dimensions.add(location[0]);
-        const sector = new SectorMesh([
-            location[0],
-            ...WorldSpaces.sector.getPositionVec3Array(location[1], location[2], location[3]),
-        ]);
-        dimension.set(WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(location[1], location[2], location[3])), sector);
+            dimension = MeshRegister.dimensions.add(dimensionId);
+        const sector = MeshManager._sectorPool.length
+            ? MeshManager._sectorPool.shift()
+            : new SectorMesh();
+        const posoiton = WorldSpaces.sector.getPositionVec3Array(x, y, z, tempVec3Array);
+        sector.position[0] = posoiton[0];
+        sector.position[1] = posoiton[1];
+        sector.position[2] = posoiton[2];
+        dimension.set(WorldSpaces.hash.hashVec3Array(sector.position), sector);
         return sector;
     }
-    static remove(location) {
-        let dimension = MeshRegister.dimensions.get(location[0]);
+    static addAt(location) {
+        return this.add(...location);
+    }
+    static remove(dimensionId, x, y, z) {
+        let dimension = MeshRegister.dimensions.get(dimensionId);
         if (!dimension)
             return false;
-        const key = WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(location[1], location[2], location[3]));
+        const key = WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(x, y, z, tempVec3));
         const sector = dimension.get(key);
         if (!sector)
             return false;
         dimension.delete(key);
         if (dimension.size == 0) {
-            MeshRegister.dimensions.remove(location[0]);
+            MeshRegister.dimensions.remove(dimensionId);
         }
         return sector;
     }
-    static get(location) {
-        let dimension = MeshRegister.dimensions.get(location[0]);
+    static removeAt(location) {
+        return this.remove(...location);
+    }
+    static get(dimensionId, x, y, z) {
+        let dimension = MeshRegister.dimensions.get(dimensionId);
         if (!dimension)
             return false;
-        return dimension.get(WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(location[1], location[2], location[3])));
+        return dimension.get(WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(x, y, z, tempVec3)));
+    }
+    static getAt(location) {
+        return this.get(...location);
     }
 }
 class Dimensions {
@@ -42,38 +58,13 @@ class Dimensions {
     static get(id) {
         return MeshRegister._dimensions.get(id);
     }
-    static *getAllMeshes(id) {
-        const dimension = MeshRegister._dimensions.get(id);
-        if (!dimension)
-            return;
-        for (const [key, sector] of dimension) {
-            for (let i = 0; i < sector.sections.length; i++) {
-                for (const [substance, mesh] of sector.sections[i].meshes) {
-                    yield [
-                        [
-                            sector.location[0],
-                            sector.location[1],
-                            sector.location[2] + i * WorldSpaces.section.bounds.y,
-                            sector.location[3],
-                        ],
-                        substance,
-                        mesh,
-                    ];
-                }
-            }
-        }
-    }
     static remove(id) {
         const dimension = MeshRegister._dimensions.get(id);
         if (!dimension)
             return false;
-        dimension.forEach((sector) => {
-            sector.sections.forEach((section) => {
-                section.meshes.forEach((sectionMeshes) => {
-                    sectionMeshes.dispose();
-                });
-            });
-        });
+        for (const [, sector] of dimension) {
+            sector.dipose();
+        }
         MeshRegister._dimensions.delete(id);
         return true;
     }

package/Settings/EngineSettings.js

@@ -52,3 +52,6 @@ class EngineSettingsClass extends TypedEventTarget {
     }
 }
 export const EngineSettings = new EngineSettingsClass();
+if (typeof SharedArrayBuffer === "undefined") {
+    EngineSettings.settings.memoryAndCPU.useSharedMemory = false;
+}

package/Settings/EngineSettings.types.d.ts

@@ -13,7 +13,7 @@ export interface RenderSettingsData {
 export declare class RenderSettingsData {
     /**Set the mode to change how mesh data is generated based on the underlying rendering API. */
     mode: "webgl" | "webgpu";
-    /**If set to try the engine will not try to send vertex buffers to woerks for GC. */
+    /**If set to try the engine will not try to send vertex buffers to workers for GC. */
     cpuBound: boolean;
 }
 export interface UpdatingSettings {
@@ -40,7 +40,13 @@ export declare class PropagationSettings {
     flowEnabled: boolean;
     powerEnabled: boolean;
 }
+export interface MemoryAndCPUSettings {
+}
+export declare class MemoryAndCPUSettings {
+    useSharedMemory: boolean;
+}
 export declare class EngineSettingsData {
+    memoryAndCPU: MemoryAndCPUSettings;
     mesher: MesherSettingsData;
     rendererSettings: RenderSettingsData;
     updating: UpdatingSettings;

package/Settings/EngineSettings.types.js

@@ -9,7 +9,7 @@ export class MesherSettingsData {
 export class RenderSettingsData {
     /**Set the mode to change how mesh data is generated based on the underlying rendering API. */
     mode = "webgl";
-    /**If set to try the engine will not try to send vertex buffers to woerks for GC. */
+    /**If set to try the engine will not try to send vertex buffers to workers for GC. */
     cpuBound = false;
 }
 export class UpdatingSettings {
@@ -30,7 +30,11 @@ export class PropagationSettings {
     flowEnabled = true;
     powerEnabled = true;
 }
+export class MemoryAndCPUSettings {
+    useSharedMemory = true;
+}
 export class EngineSettingsData {
+    memoryAndCPU = new MemoryAndCPUSettings();
     mesher = new MesherSettingsData();
     rendererSettings = new RenderSettingsData();
     updating = new UpdatingSettings();

package/Stats/EngineStats.d.ts

@@ -0,0 +1,19 @@
+declare class GeomtryStats {
+    /**The total geomtry faces */
+    faces: number;
+}
+declare class PaletteStats {
+    /**The final voxel palette id size. */
+    paletteSize: number;
+}
+/**
+ * Stores data from the results of the engine building data and other things.
+ */
+export declare class EngineStats {
+    /** Stats to do with the vlox model system. */
+    static geomtry: GeomtryStats;
+    /** Stats to do with the vloxel palette system. */
+    static palette: PaletteStats;
+    static log(): string;
+}
+export {};

package/Stats/EngineStats.js

@@ -0,0 +1,27 @@
+class GeomtryStats {
+    /**The total geomtry faces */
+    faces = 0;
+}
+class PaletteStats {
+    /**The final voxel palette id size. */
+    paletteSize = 0;
+}
+/**
+ * Stores data from the results of the engine building data and other things.
+ */
+export class EngineStats {
+    /** Stats to do with the vlox model system. */
+    static geomtry = new GeomtryStats();
+    /** Stats to do with the vloxel palette system. */
+    static palette = new PaletteStats();
+    static log() {
+        let output = "DVE Stats\n";
+        //geomtry
+        output += "Geomtry\n";
+        output += `Faces: ${this.geomtry.faces}\n`;
+        //palettes
+        output += "Palette\n";
+        output += `Paltte Size: ${this.palette.paletteSize}\n`;
+        return output;
+    }
+}

package/Tasks/Paint/Common.d.ts

@@ -0,0 +1,7 @@
+import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
+import { VoxelUpdateData } from "../../Tasks/Tasks.types.js";
+export declare const updatePowerTask: (tasks: VoxelUpdateTask) => void;
+export declare const canUpdate: (x: number, y: number, z: number, data: VoxelUpdateData) => boolean;
+/**Checks if the given voxel needs a light update and adds it to the needed queues */
+export declare const checkLightUpdate: (x: number, y: number, z: number, tasks: VoxelUpdateTask) => void;
+export declare const updateArea: (tasks: VoxelUpdateTask, sx: number, sy: number, sz: number, ex: number, ey: number, ez: number) => void;

package/Tasks/Paint/Common.js

@@ -0,0 +1,200 @@
+import { CardinalNeighbors3D } from "../../Math/CardinalNeighbors.js";
+import { VoxelLightData } from "../../Voxels/Cursor/VoxelLightData.js";
+import { RGBRemove, RGBUpdate, SunRemove, SunUpdate, } from "../Propagation/index.js";
+export const updatePowerTask = (tasks) => {
+    const [dimension, x, y, z] = tasks.origin;
+    tasks.nDataCursor.setFocalPoint(dimension, x, y, z);
+    for (const n of CardinalNeighbors3D) {
+        const nx = n[0] + x;
+        const ny = n[1] + y;
+        const nz = n[2] + z;
+        const nVoxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
+        if (!nVoxel)
+            continue;
+        if (nVoxel.getPower() > 0) {
+            tasks.power.update.push(nx, ny, nz);
+        }
+    }
+};
+const lightData = new VoxelLightData();
+export const canUpdate = (x, y, z, data) => {
+    const { includedAreas, excludeAreas } = data;
+    // Check if includedAreas is set and not empty
+    if (includedAreas && includedAreas.length > 0) {
+        let insideIncluded = false;
+        for (let i = 0; i < includedAreas.length; i++) {
+            const min = includedAreas[i][0];
+            const max = includedAreas[i][1];
+            if (x >= min[0] &&
+                x <= max[0] &&
+                y >= min[1] &&
+                y <= max[1] &&
+                z >= min[2] &&
+                z <= max[2]) {
+                insideIncluded = true;
+                break;
+            }
+        }
+        if (!insideIncluded)
+            return false;
+    }
+    // Check if excludeAreas is set and not empty
+    if (excludeAreas && excludeAreas.length > 0) {
+        for (let i = 0; i < excludeAreas.length; i++) {
+            const min = excludeAreas[i][0];
+            const max = excludeAreas[i][1];
+            if (x >= min[0] &&
+                x <= max[0] &&
+                y >= min[1] &&
+                y <= max[1] &&
+                z >= min[2] &&
+                z <= max[2]) {
+                return false;
+            }
+        }
+    }
+    return true;
+};
+/**Checks if the given voxel needs a light update and adds it to the needed queues */
+export const checkLightUpdate = (x, y, z, tasks) => {
+    let needSunRemove = false;
+    let needSunUpdate = false;
+    let needRGBRemove = false;
+    let needRGBUpdate = false;
+    const voxel = tasks.nDataCursor.getVoxel(x, y, z);
+    const lightValue = voxel.getLight();
+    const sunValue = lightData.getS(lightValue);
+    if (sunValue == 15) {
+        const voxel = tasks.nDataCursor.getVoxel(x, y + 1, z);
+        if (voxel) {
+            const light = voxel.getLight();
+            const v = lightData.getS(light);
+            if (light < 0 || v != 15) {
+                needSunRemove = true;
+            }
+        }
+    }
+    const redValue = lightData.getR(lightValue);
+    const greenValue = lightData.getG(lightValue);
+    const blueValue = lightData.getB(lightValue);
+    const hasSunLight = sunValue > 0;
+    const hasRGBLight = voxel.hasRGBLight();
+    let foundHigherSun = false;
+    let foundHigherRed = false;
+    let foundHigherGreen = false;
+    let foundHigherBlue = false;
+    let lowestSunValue = Infinity;
+    let lowestRedValue = Infinity;
+    let lowestGreenValue = Infinity;
+    let lowestBlueValue = Infinity;
+    for (let i = 0; i < CardinalNeighbors3D.length; i++) {
+        const n = CardinalNeighbors3D[i];
+        const nx = n[0] + x;
+        const ny = n[1] + y;
+        const nz = n[2] + z;
+        const nVoxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
+        if (!nVoxel)
+            continue;
+        const nLight = nVoxel.getLight();
+        if (nLight === -1)
+            continue;
+        if (hasSunLight) {
+            const nSunValue = lightData.getS(nLight);
+            if (nSunValue < lowestSunValue) {
+                lowestSunValue = nSunValue;
+            }
+            if (nSunValue > sunValue) {
+                foundHigherSun = true;
+            }
+        }
+        if (hasRGBLight) {
+            const nRedValue = lightData.getR(nLight);
+            if (nRedValue > lowestRedValue) {
+                lowestRedValue = nRedValue;
+            }
+            if (nRedValue > redValue) {
+                foundHigherRed = true;
+            }
+            const nGreenValue = lightData.getG(nLight);
+            if (nGreenValue < lowestGreenValue) {
+                lowestGreenValue = nGreenValue;
+            }
+            if (nGreenValue > greenValue) {
+                foundHigherGreen = true;
+            }
+            const nBlueValue = lightData.getB(nLight);
+            if (nBlueValue > lowestBlueValue) {
+                lowestBlueValue = nBlueValue;
+            }
+            if (nBlueValue < blueValue) {
+                foundHigherBlue = true;
+            }
+        }
+    }
+    if (hasSunLight) {
+        //sun
+        if (sunValue != 15 && sunValue != 0 && !foundHigherSun) {
+            needSunRemove = true;
+        }
+        if ((foundHigherSun || sunValue == 15) &&
+            lowestSunValue < sunValue - VoxelLightData.SunFallOffValue) {
+            needSunUpdate = true;
+        }
+    }
+    if (hasRGBLight) {
+        //red
+        if (redValue != 15 && !foundHigherRed) {
+            needRGBRemove = true;
+        }
+        if ((foundHigherRed || redValue == 15) && lowestRedValue < redValue - 1) {
+            needRGBUpdate = true;
+        }
+        //green
+        if (greenValue != 15 && !foundHigherGreen) {
+            needRGBRemove = true;
+        }
+        if ((foundHigherGreen || greenValue == 15) &&
+            lowestGreenValue < greenValue - 1) {
+            needRGBUpdate = true;
+        }
+        //blue
+        if (blueValue != 15 && !foundHigherBlue) {
+            needRGBRemove = true;
+        }
+        if ((foundHigherBlue || blueValue == 15) &&
+            lowestBlueValue < blueValue - 1) {
+            needRGBUpdate = true;
+        }
+    }
+    if (needSunRemove) {
+        tasks.sun.remove.push(x, y, z);
+    }
+    if (needSunUpdate && !needSunRemove) {
+        tasks.sun.update.push(x, y, z);
+    }
+    if (needRGBRemove) {
+        tasks.rgb.remove.push(x, y, z);
+    }
+    if (needRGBUpdate && !needRGBRemove) {
+        tasks.rgb.update.push(x, y, z);
+    }
+};
+export const updateArea = (tasks, sx, sy, sz, ex, ey, ez) => {
+    for (let x = sx - 1; x < ex + 1; x++) {
+        for (let y = sy - 1; y < ey + 1; y++) {
+            for (let z = sz - 1; z < ez + 1; z++) {
+                const voxel = tasks.sDataCursor.getVoxel(x, y, z);
+                if (!voxel)
+                    continue;
+                voxel.updateVoxel(2);
+                checkLightUpdate(x, y, z, tasks);
+                tasks.bounds.updateDisplay(x, y, z);
+            }
+        }
+    }
+    SunRemove(tasks);
+    RGBRemove(tasks);
+    SunUpdate(tasks);
+    RGBUpdate(tasks);
+    tasks.bounds.markDisplayDirty();
+};

package/Tasks/Paint/Erase/EraseVoxel.d.ts

@@ -0,0 +1,3 @@
+import { VoxelUpdateData } from "../../../Tasks/Tasks.types.js";
+import type { LocationData } from "../../../Math/Location";
+export declare function EraseVoxel(location: LocationData, updateData: VoxelUpdateData): void;

package/Tasks/Paint/Erase/EraseVoxel.js

@@ -0,0 +1,31 @@
+import { EngineSettings as ES } from "../../../Settings/EngineSettings.js";
+import { VoxelUpdateTask } from "../../VoxelUpdateTask.js";
+import { canUpdate, updateArea } from "../Common.js";
+import { PowerRemove, PowerUpdate, } from "../../Propagation/Power/PowerUpdate.js";
+const tasks = new VoxelUpdateTask();
+export function EraseVoxel(location, updateData) {
+    const [dimension, x, y, z] = location;
+    if (!canUpdate(x, y, z, updateData))
+        return;
+    tasks.setOriginAt(location);
+    let voxel = tasks.sDataCursor.getVoxel(x, y, z);
+    if (!voxel)
+        return;
+    const foundPower = voxel.getPower();
+    voxel.ids[voxel._index] = 0;
+    voxel.level[voxel._index] = 0;
+    voxel.secondary[voxel._index] = 0;
+    voxel.light[voxel._index] = 0;
+    voxel.updateVoxel(1);
+    updateArea(tasks, x, y, z, x, y, z);
+    voxel = tasks.sDataCursor.getVoxel(x, y, z);
+    if (ES.doPower) {
+        if (foundPower > -1) {
+            voxel.setLevel(foundPower);
+            tasks.power.remove.push(x, y, z);
+            PowerRemove(tasks);
+            PowerUpdate(tasks);
+        }
+    }
+    tasks.bounds.markDisplayDirty();
+}

package/Tasks/Paint/Erase/EraseVoxelPath.d.ts

@@ -0,0 +1,4 @@
+import { VoxelUpdateData } from "../../Tasks.types";
+import { Vec3Array } from "@amodx/math";
+import { VoxelPathData } from "../../../Templates/Path/VoxelPath.types";
+export default function EraseVoxelPath(dimension: number, [ox, oy, oz]: Vec3Array, voxelPathData: VoxelPathData, updateData: VoxelUpdateData): void;