@divinevoxel/vlox 0.0.0

package/Mesher/Tools/OutlinedVoxelTool.js

@@ -0,0 +1,186 @@
+import { DVEMesher } from "../Mesher.js";
+import { VoxelFaceDirections, VoxelFaces } from "../../Math/index.js";
+/*
+0 -> normal direction
+1 -> top right
+2 -> top left
+*/
+const uvsSets = {
+    //top bottom faces
+    north: {
+        0b0: 0,
+        0b101: 1,
+        0b011: 2,
+        0b001: 3,
+    },
+    south: {
+        0b0: 4,
+        0b101: 5,
+        0b011: 6,
+        0b001: 7,
+    },
+    east: {
+        0b0: 8,
+    },
+    west: {
+        0b0: 9,
+    },
+    //side faces
+    top: {
+        0b0: 0,
+        0b101: 1,
+        0b011: 2,
+        0b001: 3,
+    },
+    bottom: {
+        0b0: 4,
+        0b101: 5,
+        0b011: 6,
+        0b001: 7,
+    },
+    right: {
+        0b0: 8,
+    },
+    left: {
+        0b0: 9,
+    },
+};
+const topAndDown = {
+    north: [
+        [0, 0, 1],
+        [1, 0, 1],
+        [-1, 0, 1],
+    ],
+    south: [
+        [0, 0, -1],
+        [1, 0, -1],
+        [-1, 0, -1],
+    ],
+    east: [[1, 0, 0]],
+    west: [[-1, 0, 0]],
+};
+const eastAndWest = {
+    top: [
+        [0, 1, 0],
+        [0, 1, 1],
+        [0, 1, -1],
+    ],
+    bottom: [
+        [0, -1, 0],
+        [0, -1, 1],
+        [0, -1, -1],
+    ],
+    right: [[0, 0, 1]],
+    left: [[0, 0, -1]],
+};
+const northAndSouth = {
+    top: [
+        [0, 1, 0],
+        [1, 1, 0],
+        [-1, 1, 0],
+    ],
+    bottom: [
+        [0, -1, 0],
+        [1, -1, 0],
+        [-1, -1, 0],
+    ],
+    right: [[1, 0, 0]],
+    left: [[-1, 0, 0]],
+};
+const CheckSets = {
+    [VoxelFaces.Up]: topAndDown,
+    [VoxelFaces.Down]: topAndDown,
+    [VoxelFaces.East]: eastAndWest,
+    [VoxelFaces.West]: eastAndWest,
+    [VoxelFaces.North]: northAndSouth,
+    [VoxelFaces.South]: northAndSouth,
+};
+const generateCheck = (direction, tool, normal, sets) => {
+    const { x, y, z } = tool.voxel;
+    let key = 0b0;
+    for (let i = 0; i < sets.length; i++) {
+        const set = sets[i];
+        const cx = x + set[0];
+        const cy = y + set[1];
+        const cz = z + set[2];
+        tool.nVoxel.loadInAt(cx, cy, cz);
+        const sameLevelCheck = tool.voxel.isSameVoxel(tool.nVoxel);
+        let normalCheck = true;
+        if (tool.nVoxel.loadInAt(cx + normal[0], cy + normal[1], cz + normal[2])) {
+            if (tool.nVoxel.isRenderable() && tool.nVoxel.isOpaque()) {
+                normalCheck = false;
+            }
+        }
+        if (sameLevelCheck && normalCheck) {
+            key |= 0b1 << i;
+        }
+        else {
+            key |= 0b0 << i;
+            if (i == 0)
+                break;
+        }
+    }
+    if (uvsSets[direction][key] == undefined)
+        return 0;
+    const index = uvsSets[direction][key];
+    return OutlinedVoxelTool._currentTexts[index];
+};
+export class OutlinedVoxelTool {
+    static _currentTexts = [];
+    static setCurrentTextures(textures) {
+        this._currentTexts = textures;
+    }
+    static addTo = {
+        top: (tool) => {
+            const normal = VoxelFaceDirections[VoxelFaces.Up];
+            const set = CheckSets[VoxelFaces.Up];
+            tool
+                .getOverlayTextures()
+                .set(generateCheck("north", tool, normal, set.north), generateCheck("south", tool, normal, set.south), generateCheck("east", tool, normal, set.east), generateCheck("west", tool, normal, set.west));
+        },
+        bottom: (tool) => {
+            const normal = VoxelFaceDirections[VoxelFaces.Down];
+            const set = CheckSets[VoxelFaces.Down];
+            tool
+                .getOverlayTextures()
+                .set(generateCheck("north", tool, normal, set.north), generateCheck("south", tool, normal, set.south), generateCheck("east", tool, normal, set.east), generateCheck("west", tool, normal, set.west));
+        },
+        north: (tool) => {
+            const normal = VoxelFaceDirections[VoxelFaces.North];
+            const set = CheckSets[VoxelFaces.North];
+            tool
+                .getOverlayTextures()
+                .set(generateCheck("top", tool, normal, set.top), generateCheck("bottom", tool, normal, set.bottom), generateCheck("left", tool, normal, set.left), generateCheck("right", tool, normal, set.right));
+        },
+        south: (tool) => {
+            const normal = VoxelFaceDirections[VoxelFaces.South];
+            const set = CheckSets[VoxelFaces.South];
+            tool
+                .getOverlayTextures()
+                .set(generateCheck("top", tool, normal, set.top), generateCheck("bottom", tool, normal, set.bottom), generateCheck("left", tool, normal, set.left), generateCheck("right", tool, normal, set.right));
+        },
+        east: (tool) => {
+            const normal = VoxelFaceDirections[VoxelFaces.East];
+            const set = CheckSets[VoxelFaces.East];
+            tool
+                .getOverlayTextures()
+                .set(generateCheck("top", tool, normal, set.top), generateCheck("bottom", tool, normal, set.bottom), generateCheck("left", tool, normal, set.left), generateCheck("right", tool, normal, set.right));
+        },
+        west: (tool) => {
+            const normal = VoxelFaceDirections[VoxelFaces.West];
+            const set = CheckSets[VoxelFaces.West];
+            tool
+                .getOverlayTextures()
+                .set(generateCheck("top", tool, normal, set.top), generateCheck("bottom", tool, normal, set.bottom), generateCheck("left", tool, normal, set.left), generateCheck("right", tool, normal, set.right));
+        },
+    };
+    static getOutlineUVs(texture, onRegister) {
+        const overlayTextures = [];
+        DVEMesher.observers.texturesRegistered.subscribeOnce((textureManager) => {
+            const type = texture[0];
+            const id = texture[1];
+            overlayTextures.push(textureManager.getTextureUV([type, id, "top"], true) /** */, textureManager.getTextureUV([type, id, "corner-top-right"], true), textureManager.getTextureUV([type, id, "corner-top-left"], true), textureManager.getTextureUV([type, id, "corner-top-left-top-right"], true), textureManager.getTextureUV([type, id, "bottom"], true), textureManager.getTextureUV([type, id, "corner-bottom-right"], true), textureManager.getTextureUV([type, id, "corner-bottom-left"], true), textureManager.getTextureUV([type, id, "corner-bottom-left-bottom-right"], true), textureManager.getTextureUV([type, id, "right"], true), textureManager.getTextureUV([type, id, "left"], true));
+            onRegister(overlayTextures);
+        });
+    }
+}

package/Mesher/Tools/VoxelMesherDataTool.d.ts

@@ -0,0 +1,31 @@
+import type { FaceDataOverride } from "../Types/Override.types";
+import { BuilderDataTool } from "./BuilderDataTool.js";
+import { MesherDataTool } from "@amodx/meshing/Tools/MesherDataTools";
+import { QuadScalarVertexData } from "@amodx/meshing/Classes/QuadVertexData";
+import { VoxelTemplateDataTool } from "./VoxelTemplateDataTool.js";
+import { VoxelFaces } from "../../Math";
+import { QuadVerticies } from "@amodx/meshing/Geometry.types";
+export declare class VoxelMesherDataTool extends MesherDataTool {
+    template: VoxelTemplateDataTool;
+    voxel: BuilderDataTool;
+    nVoxel: BuilderDataTool;
+    dataCalculated: Record<VoxelFaces, boolean>;
+    condiotnalGeometryData: Record<VoxelFaces, Record<QuadVerticies, [number[][], number[][], number[][]]>>;
+    lightData: Record<VoxelFaces, Record<QuadVerticies, number>>;
+    faceDataOverride: FaceDataOverride;
+    constructor();
+    calculateFaceData(direction: VoxelFaces): true | undefined;
+    clearCalculatedData(): void;
+    calculateLight(direction: VoxelFaces, ignoreAO?: boolean): void;
+    calculateFlow(): void;
+    getAnimationData(): QuadScalarVertexData;
+    getWorldLight(): QuadScalarVertexData;
+    getWorldAO(): QuadScalarVertexData;
+    getWorldLevel(): QuadScalarVertexData;
+    getOverlayTextures(): QuadScalarVertexData;
+    setTexture(uv: number): this;
+    getTexture(): number;
+    setFaceFlipped(value: boolean): this;
+    isFaceFlipped(): boolean;
+    isFaceExposed(face: VoxelFaces): boolean;
+}

package/Mesher/Tools/VoxelMesherDataTool.js

@@ -0,0 +1,166 @@
+//objects
+import { LightGradient } from "../Calc/Light/LightGradient.js";
+import { FlowGradient } from "../Calc/Flow/FlowGradient.js";
+import { OverrideManager } from "../Rules/Overrides/OverridesManager.js";
+import { SubstanceRules } from "../Rules/SubstanceRules.js";
+//tools
+import { BuilderDataTool } from "./BuilderDataTool.js";
+import { MesherDataTool } from "@amodx/meshing/Tools/MesherDataTools";
+//data
+import { QuadScalarVertexData } from "@amodx/meshing/Classes/QuadVertexData";
+import { VoxelTemplateDataTool } from "./VoxelTemplateDataTool.js";
+import { BinaryNumberTypes } from "@amodx/binary";
+import { VoxelFaces, VoxelFaceDirections, VoxelFacesArray, } from "../../Math";
+import { QuadVerticies } from "@amodx/meshing/Geometry.types";
+import { FaceDataCalc } from "../Calc/Light/FaceDataCalc";
+export class VoxelMesherDataTool extends MesherDataTool {
+    template = new VoxelTemplateDataTool();
+    voxel = new BuilderDataTool();
+    nVoxel = new BuilderDataTool();
+    dataCalculated;
+    condiotnalGeometryData;
+    lightData;
+    faceDataOverride = {
+        face: VoxelFaces.South,
+        default: false,
+        currentVoxel: {},
+        neighborVoxel: {},
+    };
+    constructor() {
+        super();
+        this.faceDataOverride.currentVoxel = this.voxel;
+        this.faceDataOverride.neighborVoxel = this.nVoxel;
+        this.dataCalculated = [];
+        for (const face of VoxelFacesArray) {
+            this.dataCalculated[face] = false;
+        }
+        this.condiotnalGeometryData = [];
+        for (const face of VoxelFacesArray) {
+            this.condiotnalGeometryData[face] = [];
+            this.condiotnalGeometryData[face][QuadVerticies.TopRight] = [[], [], []];
+            this.condiotnalGeometryData[face][QuadVerticies.TopLeft] = [[], [], []];
+            this.condiotnalGeometryData[face][QuadVerticies.BottomLeft] = [
+                [],
+                [],
+                [],
+            ];
+            this.condiotnalGeometryData[face][QuadVerticies.BottomRight] = [
+                [],
+                [],
+                [],
+            ];
+        }
+        this.lightData = [];
+        for (const face of VoxelFacesArray) {
+            this.lightData[face] = [];
+            this.lightData[face][QuadVerticies.TopRight] = 0;
+            this.lightData[face][QuadVerticies.TopLeft] = 0;
+            this.lightData[face][QuadVerticies.BottomLeft] = 0;
+            this.lightData[face][QuadVerticies.BottomRight] = 0;
+        }
+        [
+            ["voxelData", [[], 1, BinaryNumberTypes.Float32]],
+            ["uv", [[], 2, BinaryNumberTypes.Float32]],
+            ["textureIndex", [[], 3, BinaryNumberTypes.Float32]],
+            ["colors", [[], 3, BinaryNumberTypes.Float32]],
+        ].forEach(([key, data]) => this.attributes.set(key, data));
+        [
+            ["light", new QuadScalarVertexData()],
+            ["ao", new QuadScalarVertexData()],
+            ["animation", new QuadScalarVertexData()],
+            ["level", new QuadScalarVertexData()],
+            ["overlay-uvs", new QuadScalarVertexData()],
+        ].forEach(([key, data]) => this.quadVertexData.set(key, data));
+        [
+            ["face-flipped", 0],
+            ["texture-index", 0],
+        ].forEach(([key, data]) => this.vars.set(key, data));
+    }
+    calculateFaceData(direction) {
+        if (this.dataCalculated[direction])
+            return true;
+        FaceDataCalc.calculate(direction, this);
+        this.dataCalculated[direction] = true;
+    }
+    clearCalculatedData() {
+        this.dataCalculated[VoxelFaces.Up] = false;
+        this.dataCalculated[VoxelFaces.Down] = false;
+        this.dataCalculated[VoxelFaces.North] = false;
+        this.dataCalculated[VoxelFaces.South] = false;
+        this.dataCalculated[VoxelFaces.East] = false;
+        this.dataCalculated[VoxelFaces.West] = false;
+    }
+    calculateLight(direction, ignoreAO = false) {
+        /*     if (this.template.isAcive()) {
+          this.template._light = this.template._lights[direction];
+          this.template._ao = this.template._aos[direction];
+          return;
+        } */
+        LightGradient.calculate(direction, this, ignoreAO);
+    }
+    calculateFlow() {
+        if (this.template.isAcive()) {
+            return;
+        }
+        FlowGradient.calculate(this);
+    }
+    getAnimationData() {
+        return this.quadVertexData.get("animation");
+    }
+    getWorldLight() {
+        if (this.template.isAcive()) {
+            return this.template._light;
+        }
+        return this.quadVertexData.get("light");
+    }
+    getWorldAO() {
+        if (this.template.isAcive()) {
+            return this.template._ao;
+        }
+        return this.quadVertexData.get("ao");
+    }
+    getWorldLevel() {
+        if (this.template.isAcive()) {
+            return this.template._level;
+        }
+        return this.quadVertexData.get("level");
+    }
+    getOverlayTextures() {
+        return this.quadVertexData.get("overlay-uvs");
+    }
+    setTexture(uv) {
+        this.vars.set("texture-index", uv);
+        return this;
+    }
+    getTexture() {
+        return this.vars.get("texture-index");
+    }
+    setFaceFlipped(value) {
+        this.vars.set("face-flipped", value ? 1 : 0);
+        return this;
+    }
+    isFaceFlipped() {
+        return this.vars.get("face-flipped") == 1;
+    }
+    isFaceExposed(face) {
+        /*     if (this.template.isAcive()) {
+          return this.template.isFaceExposed(face);
+        } */
+        const voxelExists = this.nVoxel.loadInAt(VoxelFaceDirections[face][0] + this.voxel.x, VoxelFaceDirections[face][1] + this.voxel.y, VoxelFaceDirections[face][2] + this.voxel.z);
+        if (!voxelExists || !this.nVoxel.isRenderable())
+            return true;
+        let finalResult = false;
+        let substanceRuleResult = SubstanceRules.exposedCheck(this.voxel.getSubstance(), this.nVoxel.getSubstance());
+        this.faceDataOverride.face = face;
+        this.faceDataOverride.default = substanceRuleResult;
+        finalResult = substanceRuleResult;
+        this.faceDataOverride.default = finalResult;
+        finalResult = OverrideManager.FaceExposedShapeCheck.run(this.voxel.getShapeId(), OverrideManager.ANY, this.faceDataOverride);
+        this.faceDataOverride.default = finalResult;
+        finalResult = OverrideManager.FaceExposedShapeCheck.run(this.voxel.getShapeId(), this.nVoxel.getShapeId(), this.faceDataOverride);
+        this.faceDataOverride.default = finalResult;
+        finalResult = OverrideManager.FaceExposedVoxelCheck.run(this.voxel.getId(true), OverrideManager.ANY, this.faceDataOverride);
+        finalResult = OverrideManager.FaceExposedVoxelCheck.run(this.voxel.getId(true), this.nVoxel.getId(true), this.faceDataOverride);
+        return finalResult;
+    }
+}

package/Mesher/Tools/VoxelTemplateDataTool.d.ts

@@ -0,0 +1,15 @@
+import type { DirectionNames } from "../../Types/Util.types.js";
+import { QuadScalarVertexData } from "@amodx/meshing/Classes/QuadVertexData";
+export declare class VoxelTemplateDataTool {
+    _active: boolean;
+    _faces: Record<DirectionNames, number>;
+    _lights: Record<DirectionNames, QuadScalarVertexData>;
+    _aos: Record<DirectionNames, QuadScalarVertexData>;
+    _light: QuadScalarVertexData;
+    _level: QuadScalarVertexData;
+    _ao: QuadScalarVertexData;
+    isAcive(): boolean;
+    setActive(active: boolean): void;
+    load(template: Uint32Array, index: number): void;
+    isFaceExposed(face: DirectionNames): boolean;
+}

package/Mesher/Tools/VoxelTemplateDataTool.js

@@ -0,0 +1,112 @@
+//data
+import { QuadScalarVertexData } from "@amodx/meshing/Classes/QuadVertexData";
+export class VoxelTemplateDataTool {
+    _active = false;
+    _faces = {
+        up: 0,
+        down: 0,
+        west: 0,
+        east: 0,
+        north: 0,
+        south: 0,
+    };
+    _lights = {
+        up: new QuadScalarVertexData(),
+        down: new QuadScalarVertexData(),
+        west: new QuadScalarVertexData(),
+        east: new QuadScalarVertexData(),
+        north: new QuadScalarVertexData(),
+        south: new QuadScalarVertexData(),
+    };
+    _aos = {
+        up: new QuadScalarVertexData(),
+        down: new QuadScalarVertexData(),
+        west: new QuadScalarVertexData(),
+        east: new QuadScalarVertexData(),
+        north: new QuadScalarVertexData(),
+        south: new QuadScalarVertexData(),
+    };
+    _light = new QuadScalarVertexData();
+    _level = new QuadScalarVertexData();
+    _ao = new QuadScalarVertexData();
+    isAcive() {
+        return this._active;
+    }
+    setActive(active) {
+        this._active = active;
+    }
+    load(template, index) {
+        const segment2 = template[index + 1];
+        const faceByte = segment2 & 0xff;
+        this._faces.up = (faceByte & (0b1 << 0)) >> 0;
+        this._faces.down = (faceByte & (0b1 << 1)) >> 1;
+        this._faces.west = (faceByte & (0b1 << 2)) >> 2;
+        this._faces.east = (faceByte & (0b1 << 3)) >> 3;
+        this._faces.north = (faceByte & (0b1 << 4)) >> 4;
+        this._faces.south = (faceByte & (0b1 << 5)) >> 5;
+        //deocde light
+        let lightIndex = index + 2;
+        {
+            const light1 = template[lightIndex];
+            const light2 = template[lightIndex + 1];
+            this._lights.up.set(light1 & 0xffff, ((0xffff << 16) & light1) >>> 16, light2 & 0xffff, ((0xffff << 16) & light2) >>> 16);
+        }
+        {
+            const light1 = template[lightIndex + 2];
+            const light2 = template[lightIndex + 3];
+            this._lights.down.set(light1 & 0xffff, ((0xffff << 16) & light1) >>> 16, light2 & 0xffff, ((0xffff << 16) & light2) >>> 16);
+        }
+        {
+            const light1 = template[lightIndex + 4];
+            const light2 = template[lightIndex + 5];
+            this._lights.west.set(light1 & 0xffff, ((0xffff << 16) & light1) >>> 16, light2 & 0xffff, ((0xffff << 16) & light2) >>> 16);
+        }
+        {
+            const light1 = template[lightIndex + 6];
+            const light2 = template[lightIndex + 7];
+            this._lights.east.set(light1 & 0xffff, ((0xffff << 16) & light1) >>> 16, light2 & 0xffff, ((0xffff << 16) & light2) >>> 16);
+        }
+        {
+            const light1 = template[lightIndex + 8];
+            const light2 = template[lightIndex + 9];
+            this._lights.north.set(light1 & 0xffff, ((0xffff << 16) & light1) >>> 16, light2 & 0xffff, ((0xffff << 16) & light2) >>> 16);
+        }
+        {
+            const light1 = template[lightIndex + 10];
+            const light2 = template[lightIndex + 11];
+            this._lights.south.set(light1 & 0xffff, ((0xffff << 16) & light1) >>> 16, light2 & 0xffff, ((0xffff << 16) & light2) >>> 16);
+        }
+        let aoIndex = lightIndex + 12;
+        //decode ao
+        {
+            const ao = template[aoIndex];
+            this._aos.up.set(ao & 0xf, ((0xf << 4) & ao) >>> 4, ((0xf << 8) & ao) >>> 8, ((0xf << 12) & ao) >>> 12);
+        }
+        {
+            const ao = ((0xffff << 16) & template[aoIndex]) >> 16;
+            this._aos.down.set(ao & 0xf, ((0xf << 4) & ao) >>> 4, ((0xf << 8) & ao) >>> 8, ((0xf << 12) & ao) >>> 12);
+        }
+        {
+            const ao = template[aoIndex + 1];
+            this._aos.west.set(ao & 0xf, ((0xf << 4) & ao) >>> 4, ((0xf << 8) & ao) >>> 8, ((0xf << 12) & ao) >>> 12);
+        }
+        {
+            const ao = ((0xffff << 16) & template[aoIndex + 1]) >> 16;
+            this._aos.east.set(ao & 0xf, ((0xf << 4) & ao) >>> 4, ((0xf << 8) & ao) >>> 8, ((0xf << 12) & ao) >>> 12);
+        }
+        {
+            const ao = template[aoIndex + 2];
+            this._aos.north.set(ao & 0xf, ((0xf << 4) & ao) >>> 4, ((0xf << 8) & ao) >>> 8, ((0xf << 12) & ao) >>> 12);
+        }
+        {
+            const ao = ((0xffff << 16) & template[aoIndex + 2]) >> 16;
+            this._aos.south.set(ao & 0xf, ((0xf << 4) & ao) >>> 4, ((0xf << 8) & ao) >>> 8, ((0xf << 12) & ao) >>> 12);
+        }
+        //   this._light.setAll(LightData.setRGB(0xf0f, 0));
+        //   this._ao.setAll(1);
+        this._level.setAll(0xf);
+    }
+    isFaceExposed(face) {
+        return this._faces[face] == 1;
+    }
+}

package/Mesher/Types/Override.types.d.ts

@@ -0,0 +1,8 @@
+import { BuilderDataTool } from "../Tools/BuilderDataTool";
+import { VoxelFaces } from "../../Math";
+export type FaceDataOverride = {
+    face: VoxelFaces;
+    default: boolean;
+    currentVoxel: BuilderDataTool;
+    neighborVoxel: BuilderDataTool;
+};

package/Mesher/Types/Override.types.js

@@ -0,0 +1 @@
+export {};

package/Mesher/Types/index.d.ts

@@ -0,0 +1 @@
+export * from "./Override.types.js";

package/Mesher/Types/index.js

@@ -0,0 +1 @@
+export * from "./Override.types.js";

package/Propagation/Explosion/ExplosionManager.d.ts

@@ -0,0 +1,4 @@
+import type { ExplosionTaskRequests } from "../../Contexts/Constructor/Tasks/TasksRequest";
+export declare const ExplosionManager: {
+    runExplosion(tasks: ExplosionTaskRequests): void;
+};

package/Propagation/Explosion/ExplosionManager.js

@@ -0,0 +1,120 @@
+//data
+import { $3dCardinalNeighbors } from "../../Math/Constants/CardinalNeighbors.js";
+//objects
+import { DataTool } from "../../Tools/Data/DataTool.js";
+import { LightData } from "../../Data/LightData.js";
+//functions
+import { Distance3D } from "@amodx/math/Vectors/Functions/Distance3d";
+import { RGBRemove, RGBUpdate } from "../Illumanation/Functions/RGBUpdate.js";
+import { SunRemove, SunUpdate } from "../Illumanation/Functions/SunUpdate.js";
+import { FlowManager } from "../Flow/FlowManager.js";
+const dataTool = new DataTool();
+const nDataTool = new DataTool();
+export const ExplosionManager = {
+    runExplosion(tasks) {
+        tasks.start();
+        const [dimension, sx, sy, sz] = tasks.origin;
+        FlowManager.setDimension(dimension);
+        tasks.setPriority(0);
+        const queue = tasks.queues.queue;
+        const map = tasks.queues.map;
+        queue.push([sx, sy, sz]);
+        dataTool.setDimension(dimension);
+        nDataTool.setDimension(dimension);
+        const radius = tasks.getData();
+        while (queue.length) {
+            const node = queue.shift();
+            if (!node)
+                break;
+            const x = node[0];
+            const y = node[1];
+            const z = node[2];
+            if (!map.inMap(x + 1, y, z)) {
+                if (dataTool.loadInAt(x + 1, y, z)) {
+                    const d = Distance3D(sx, sy, sz, x + 1, y, z);
+                    if (d <= radius) {
+                        queue.push([x + 1, y, z]);
+                    }
+                    map.add(x + 1, y, z);
+                }
+            }
+            if (!map.inMap(x - 1, y, z)) {
+                if (dataTool.loadInAt(x - 1, y, z)) {
+                    const d = Distance3D(sx, sy, sz, x - 1, y, z);
+                    if (d <= radius) {
+                        queue.push([x - 1, y, z]);
+                    }
+                }
+                map.add(x - 1, y, z);
+            }
+            if (!map.inMap(x, y, z + 1)) {
+                if (dataTool.loadInAt(x, y, z + 1)) {
+                    const d = Distance3D(sx, sy, sz, x, y, z + 1);
+                    if (d <= radius) {
+                        queue.push([x, y, z + 1]);
+                    }
+                }
+                map.add(x, y, z + 1);
+            }
+            if (!map.inMap(x, y, z - 1)) {
+                if (dataTool.loadInAt(x, y, z - 1)) {
+                    const d = Distance3D(sx, sy, sz, x, y, z - 1);
+                    if (d <= radius) {
+                        queue.push([x, y, z - 1]);
+                    }
+                }
+                map.add(x, y, z - 1);
+            }
+            if (!map.inMap(x, y + 1, z)) {
+                if (dataTool.loadInAt(x, y + 1, z)) {
+                    const d = Distance3D(sx, sy, sz, x, y + 1, z);
+                    if (d <= radius) {
+                        queue.push([x, y + 1, z]);
+                    }
+                }
+                map.add(x, y + 1, z);
+            }
+            if (!map.inMap(x, y - 1, z)) {
+                if (dataTool.loadInAt(x, y - 1, z)) {
+                    const d = Distance3D(sx, sy, sz, x, y - 1, z);
+                    if (d <= radius) {
+                        queue.push([x, y - 1, z]);
+                    }
+                }
+                map.add(x, y - 1, z);
+            }
+            if (dataTool.loadInAt(x, y, z)) {
+                if (dataTool.isRenderable()) {
+                    for (const n of $3dCardinalNeighbors) {
+                        const nx = x + n[0];
+                        const ny = y + n[1];
+                        const nz = z + n[2];
+                        if (nDataTool.loadInAt(nx, ny, nz)) {
+                            const l = nDataTool.getLight();
+                            if (l > 0) {
+                                if (LightData.getS(l) > 0) {
+                                    tasks.queues.sun.remove.push(nx, ny, nz);
+                                }
+                                if (LightData.hasRGBLight(l)) {
+                                    tasks.queues.rgb.remove.push(nx, ny, nz);
+                                }
+                            }
+                        }
+                    }
+                    tasks.addNeighborsToRebuildQueue(x, y, z);
+                    if (dataTool.getHardness() > 10_000 ||
+                        dataTool.getSubstnaceData().isLiquid()) {
+                        continue;
+                    }
+                    dataTool.setAir().commit(2);
+                }
+            }
+        }
+        RGBRemove(tasks);
+        SunRemove(tasks);
+        RGBUpdate(tasks);
+        SunUpdate(tasks);
+        tasks.runRebuildQueue();
+        tasks.stop();
+    },
+};