@divinevoxel/vlox 0.0.0

package/Propagation/Flow/FlowManager.d.ts

@@ -0,0 +1,66 @@
+import { DataTool } from "../../Tools/Data/DataTool.js";
+import { BrushTool } from "../../Tools/Brush/Brush.js";
+import type { FlowTaskRequests } from "../../Contexts/Constructor/Tasks/TasksRequest";
+import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
+export declare class FlowManager {
+    static lightData: {
+        SRS: number;
+        _lightValues: [s: number, r: number, g: number, b: number];
+        sumRGB(value: number): number;
+        getS(value: number): number;
+        getR(value: number): number;
+        getG(value: number): number;
+        getB(value: number): number;
+        setS(value: number, sl: number): number;
+        setR(value: number, sl: number): number;
+        setG(value: number, sl: number): number;
+        setB(value: number, sl: number): number;
+        removeS(sl: number): number;
+        hasRGBLight(sl: number): boolean;
+        hasSunLight(sl: number): boolean;
+        mixLight(l1: number, l2: number): number;
+        getRGB(sl: number): number;
+        setRGB(value: number, sl: number): number;
+        decodeLightFromVoxelData(voxelData: number): number;
+        encodeLightIntoVoxelData(voxelData: number, encodedLight: number): number;
+        setLightValues(values: ArrayLike<number>): number;
+        getLightValues(value: number): [s: number, r: number, g: number, b: number];
+        getLightValuesToRef(value: number, values: [s: number, r: number, g: number, b: number]): [s: number, r: number, g: number, b: number];
+        isLessThanForRGBRemove(n1: number, n2: number): boolean;
+        isLessThanForRGBAdd(n1: number, n2: number): boolean;
+        isGreaterOrEqualThanForRGBRemove(n1: number, n2: number): boolean;
+        getMinusOneForRGB(sl: number, nl: number): number;
+        removeRGBLight(sl: number): number;
+        getFullSunLight(sl: number): number;
+        isLessThanForSunAdd(n1: number, n2: number): boolean;
+        isLessThanForSunAddDown(n1: number, n2: number): boolean;
+        isLessThanForSunAddUp(n1: number, n2: number): boolean;
+        getSunLightForUnderVoxel(sl: number, nl: number): number;
+        getMinusOneForSun(sl: number, nl: number): number;
+        isLessThanForSunRemove(n1: number, sl: number): boolean;
+        isGreaterOrEqualThanForSunRemove(n1: number, sl: number): boolean;
+        sunLightCompareForDownSunRemove(n1: number, sl: number): boolean;
+        removeSunLight(sl: number): number;
+        minusOneForAll(sl: number): number;
+        addLightValues(sl: number, sl2: number): number;
+        divideLightValue(sl: number, divisor: number): number;
+    };
+    static _brush: BrushTool;
+    static _sDataTool: DataTool;
+    static _nDataTool: DataTool;
+    static _substanceTool: SubstanceDataTool;
+    static setVoxel(tasks: FlowTaskRequests, vox: string, level: number, levelState: number, x: number, y: number, z: number): void;
+    static setDimension(dimension: string): void;
+    static removeVoxel(tasks: FlowTaskRequests, x: number, y: number, z: number): void;
+    static getFlowRate(substance: string): number;
+    static getVoxel(x: number, y: number, z: number): false | DataTool;
+    static setLevel(level: number, x: number, y: number, z: number): void;
+    static getLevel(vox: string, x: number, y: number, z: number): number;
+    static getLevelState(vox: string, x: number, y: number, z: number): number;
+    static canFlowOutwardTest(vox: string, x: number, y: number, z: number): boolean;
+    static flowDownTest(vox: string, x: number, y: number, z: number): boolean;
+    static wait(ms: number): Promise<unknown>;
+    static _lightValues: [s: number, r: number, g: number, b: number];
+    static getAbsorbLight(x: number, y: number, z: number): number;
+    static sunCheck(tasks: FlowTaskRequests, x: number, y: number, z: number): void;
+}

package/Propagation/Flow/FlowManager.js

@@ -0,0 +1,154 @@
+import { $3dCardinalNeighbors } from "../../Math/Constants/CardinalNeighbors.js";
+import { LightData } from "../../Data/LightData.js";
+import { DataTool } from "../../Tools/Data/DataTool.js";
+import { BrushTool } from "../../Tools/Brush/Brush.js";
+import { SunRemove, SunUpdate } from "../Illumanation/Functions/SunUpdate.js";
+import { RGBRemove, RGBUpdate } from "../Illumanation/Functions/RGBUpdate.js";
+import { IlluminationManager } from "../Illumanation/IlluminationManager.js";
+import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
+export class FlowManager {
+    static lightData = LightData;
+    static _brush = new BrushTool();
+    static _sDataTool = new DataTool();
+    static _nDataTool = new DataTool();
+    static _substanceTool = new SubstanceDataTool();
+    static setVoxel(tasks, vox, level, levelState, x, y, z) {
+        this.sunCheck(tasks, x, y, z);
+        SunRemove(tasks);
+        this._brush.setId(vox).setXYZ(x, y, z).paint();
+        this._sDataTool.loadInAt(x, y, z);
+        this._sDataTool
+            .setLevel(level)
+            .setLevelState(levelState)
+            .setLight(this.getAbsorbLight(x, y, z))
+            .commit();
+        SunUpdate(tasks);
+    }
+    static setDimension(dimension) {
+        this._sDataTool.setDimension(dimension);
+        this._nDataTool.setDimension(dimension);
+        this._brush.setDimension(dimension);
+        IlluminationManager.setDimension(dimension);
+    }
+    static removeVoxel(tasks, x, y, z) {
+        for (const n of $3dCardinalNeighbors) {
+            const nx = x + n[0];
+            const ny = y + n[1];
+            const nz = z + n[2];
+            if (!this._nDataTool.loadInAt(nx, ny, nz))
+                continue;
+            const l = this._nDataTool.getLight();
+            if (l <= 0)
+                continue;
+            if (this.lightData.getS(l) > 0) {
+                tasks.queues.sun.update.push(nx, ny, nz);
+            }
+            if (this.lightData.hasRGBLight(l)) {
+                tasks.queues.rgb.update.push(nx, ny, nz);
+            }
+        }
+        this._nDataTool.loadInAt(x, y, z);
+        const currentLight = this._nDataTool.getLight();
+        this._brush.setXYZ(x, y, z).erase();
+        this._nDataTool.clear().loadInAt(x, y, z);
+        this._nDataTool.setLight(currentLight).commit();
+        tasks.queues.rgb.remove.push(x, y, z);
+        RGBRemove(tasks);
+        SunUpdate(tasks);
+        RGBUpdate(tasks);
+    }
+    static getFlowRate(substance) {
+        this._substanceTool.setSubstanceFromString(substance);
+        return this._substanceTool.getFlowRate();
+    }
+    static getVoxel(x, y, z) {
+        if (!this._sDataTool.loadInAt(x, y, z))
+            return false;
+        if (!this._sDataTool.isRenderable())
+            return false;
+        const substance = this._sDataTool.getSubstnaceData();
+        if (!substance.isLiquid())
+            return false;
+        return this._sDataTool;
+    }
+    static setLevel(level, x, y, z) {
+        this._nDataTool.loadInAt(x, y, z);
+        this._nDataTool.setLevel(level).commit();
+    }
+    static getLevel(vox, x, y, z) {
+        if (!this._nDataTool.loadInAt(x, y, z))
+            return -2;
+        const voxel = this._nDataTool.getStringId();
+        if (this._nDataTool.isAir()) {
+            return 0;
+        }
+        if (voxel == vox) {
+            return this._nDataTool.getLevel();
+        }
+        return -1;
+    }
+    static getLevelState(vox, x, y, z) {
+        if (!this._nDataTool.loadInAt(x, y, z))
+            return -2;
+        const voxel = this._nDataTool.getStringId();
+        if (voxel == vox) {
+            return this._nDataTool.getLevelState();
+        }
+        if (this._nDataTool.isAir()) {
+            return -1;
+        }
+        return -3;
+    }
+    static canFlowOutwardTest(vox, x, y, z) {
+        const level = this.getLevel(vox, x, y - 1, z);
+        if (level == -1) {
+            return true;
+        }
+        return false;
+    }
+    static flowDownTest(vox, x, y, z) {
+        const level = this.getLevel(vox, x, y - 1, z);
+        if (level >= 0) {
+            return true;
+        }
+        return false;
+    }
+    static wait(ms) {
+        return new Promise((resolve, reject) => setTimeout(resolve, ms));
+    }
+    static _lightValues = [
+        0, 0, 0, 0,
+    ];
+    static getAbsorbLight(x, y, z) {
+        for (const n of $3dCardinalNeighbors) {
+            if (!n[0] && !n[1] && !n[2])
+                continue;
+            if (!this._nDataTool.loadInAt(x + n[0], y + n[1], z + n[2]))
+                continue;
+            let l = this._nDataTool.getLight();
+            if (l <= 0)
+                continue;
+            const v = this.lightData.getLightValues(l);
+            for (let i = 0; i < 4; i++) {
+                if (this._lightValues[i] < v[i]) {
+                    this._lightValues[i] = v[i];
+                }
+            }
+        }
+        let brightest = this.lightData.setLightValues(this._lightValues);
+        for (let i = 0; i < 4; i++) {
+            this._lightValues[i] = 0;
+        }
+        return this.lightData.minusOneForAll(brightest);
+    }
+    static sunCheck(tasks, x, y, z) {
+        if (!this._nDataTool.loadInAt(x, y - 1, z))
+            return;
+        if (!this._nDataTool.isAir())
+            return;
+        const l = this._nDataTool.getLight();
+        if (this.lightData.getS(l) == 0xf) {
+            tasks.queues.sun.remove.push(x, y - 1, z);
+        }
+    }
+}

package/Propagation/Flow/Functions/FlowRemove.d.ts

@@ -0,0 +1,2 @@
+import type { FlowTaskRequests } from "../../../Contexts/Constructor/Tasks/TasksRequest";
+export declare function FlowRemove(tasks: FlowTaskRequests): Promise<void>;

package/Propagation/Flow/Functions/FlowRemove.js

@@ -0,0 +1,162 @@
+import { FlowUpdate } from "./FlowUpdate.js";
+import { FlowManager as FM } from "../FlowManager.js";
+import { EngineSettings } from "../../../Data/Settings/EngineSettings.js";
+function RunRemoveCheck(tasks, vox) {
+    const [dimension, x, y, z] = tasks.origin;
+    const queue = tasks.queues.flow.remove.queue;
+    const cl = FM.getLevel(vox, x, y, z);
+    queue.push([x, y, z]);
+    const n1 = FM.getLevel(vox, x + 1, y, z);
+    const n1s = FM.getLevelState(vox, x + 1, y, z);
+    if ((n1 > -1 && n1 < cl) || n1s == 1) {
+        queue.push([x + 1, y, z]);
+    }
+    const n2 = FM.getLevel(vox, x - 1, y, z);
+    const n2s = FM.getLevelState(vox, x - 1, y, z);
+    if ((n2 > -1 && n2 < cl) || n2s == 1) {
+        queue.push([x - 1, y, z]);
+    }
+    const n3 = FM.getLevel(vox, x, y, z + 1);
+    const n3s = FM.getLevelState(vox, x, y, z + 1);
+    if ((n3 > -1 && n3 < cl) || n3s == 1) {
+        queue.push([x, y, z + 1]);
+    }
+    const n4 = FM.getLevel(vox, x, y, z - 1);
+    const n4s = FM.getLevelState(vox, x, y, z - 1);
+    if ((n4 > -1 && n4 < cl) || n4s == 1) {
+        queue.push([x, y, z - 1]);
+    }
+}
+export async function FlowRemove(tasks) {
+    const [dimension, x, y, z] = tasks.origin;
+    FM.setDimension(dimension);
+    const vox = FM.getVoxel(x, y, z);
+    if (!vox)
+        return;
+    const voxId = vox.getStringId();
+    const flowRate = vox.getSubstnaceData().getFlowRate();
+    RunRemoveCheck(tasks, voxId);
+    const noRemoveMap = tasks.queues.flow.remove.noRemoveMap;
+    while (tasks.queues.flow.remove.queue.length != 0) {
+        FM.setDimension(dimension);
+        RunRemovePropagation(tasks, voxId);
+        RunFlowReduce(tasks, voxId);
+        await FlowUpdate(tasks, false);
+        noRemoveMap.clear();
+        tasks.runRebuildQueue();
+        await FM.wait(EngineSettings.settings.flow.baseFlowLimit * flowRate);
+    }
+}
+function RunRemovePropagation(tasks, vox) {
+    const removeQ = tasks.queues.flow.remove.queue;
+    const updateQ = tasks.queues.flow.update.queue;
+    const map = tasks.queues.flow.update.map;
+    const noRemoveMap = tasks.queues.flow.remove.noRemoveMap;
+    for (let i = 0; i < removeQ.length; i++) {
+        const node = removeQ[i];
+        const x = node[0];
+        const y = node[1];
+        const z = node[2];
+        const l = FM.getLevel(vox, x, y, z);
+        const s = FM.getLevelState(vox, x, y, z);
+        map.add(x, y, z);
+        if (noRemoveMap.inMap(x, y, z))
+            continue;
+        n1t: if (!map.inMap(x + 1, y, z)) {
+            const n1 = FM.getLevel(vox, x + 1, y, z);
+            const n1s = FM.getLevelState(vox, x + 1, y, z);
+            if (n1 <= 0 || n1s == 1)
+                break n1t;
+            if (n1 < l && l > 0 && n1 > 0) {
+                removeQ.push([x + 1, y, z]);
+            }
+            if (n1 > l) {
+                updateQ.push([x + 1, y, z]);
+            }
+        }
+        n2t: if (!map.inMap(x - 1, y, z)) {
+            const n2 = FM.getLevel(vox, x - 1, y, z);
+            const n2s = FM.getLevelState(vox, x - 1, y, z);
+            if (n2 <= 0 || n2s == 1)
+                break n2t;
+            if (n2 < l && l > 0 && n2 > 0) {
+                removeQ.push([x - 1, y, z]);
+            }
+            if (n2 > l) {
+                updateQ.push([x - 1, y, z]);
+            }
+        }
+        n3t: if (!map.inMap(x, y, z + 1)) {
+            const n3 = FM.getLevel(vox, x, y, z + 1);
+            const n3s = FM.getLevelState(vox, x, y, z + 1);
+            if (n3 <= 0 || n3s == 1)
+                break n3t;
+            if (n3 < l && l > 0 && n3 > 0) {
+                removeQ.push([x, y, z + 1]);
+            }
+            if (n3 > l) {
+                updateQ.push([x, y, z + 1]);
+            }
+        }
+        n4t: if (!map.inMap(x, y, z - 1)) {
+            const n4 = FM.getLevel(vox, x, y, z - 1);
+            const n4s = FM.getLevelState(vox, x, y, z - 1);
+            if (n4 <= 0 || n4s == 1)
+                break n4t;
+            if (n4 < l && l > 0 && n4 > 0) {
+                removeQ.push([x, y, z - 1]);
+            }
+            if (n4 > l) {
+                updateQ.push([x, y, z - 1]);
+            }
+        }
+        if (!map.inMap(x, y - 1, z)) {
+            const n5 = FM.getLevel(vox, x, y - 1, z);
+            if (n5 < 0)
+                continue;
+            const n5s = FM.getLevelState(vox, x, y - 1, z);
+            let add = false;
+            if (s == 1 && n5s == 1) {
+                if (l <= 1) {
+                    add = true;
+                }
+            }
+            if (s == 0 && l <= 1) {
+                add = true;
+            }
+            if (add) {
+                removeQ.push([x, y - 1, z]);
+            }
+        }
+    }
+    map.clear();
+}
+function RunFlowReduce(tasks, vox) {
+    const queue = tasks.queues.flow.remove.queue;
+    const map = tasks.queues.flow.remove.map;
+    const reque = [];
+    while (queue.length != 0) {
+        const node = queue.shift();
+        if (!node) {
+            break;
+        }
+        const x = node[0];
+        const y = node[1];
+        const z = node[2];
+        if (map.inMap(x, y, z))
+            continue;
+        map.add(x, y, z);
+        const l = FM.getLevel(vox, x, y, z);
+        if (l <= 1) {
+            FM.removeVoxel(tasks, x, y, z);
+            reque.push([x, y, z]);
+        }
+        else {
+            FM.setLevel(l - 1, x, y, z);
+            reque.push([x, y, z]);
+        }
+        tasks.addToRebuildQueue(x, y, z);
+    }
+    tasks.queues.flow.remove.queue = reque;
+    map.clear();
+}

package/Propagation/Flow/Functions/FlowUpdate.d.ts

@@ -0,0 +1,2 @@
+import type { FlowTaskRequests } from "../../../Contexts/Constructor/Tasks/TasksRequest";
+export declare function FlowUpdate(tasks: FlowTaskRequests, rebuild?: boolean): Promise<void>;

package/Propagation/Flow/Functions/FlowUpdate.js

@@ -0,0 +1,96 @@
+import { FlowManager as FM } from "../FlowManager.js";
+import { EngineSettings } from "../../../Data/Settings/EngineSettings.js";
+export async function FlowUpdate(tasks, rebuild = true) {
+    const [dimension, x, y, z] = tasks.origin;
+    FM.setDimension(dimension);
+    const vox = FM.getVoxel(x, y, z);
+    if (!vox)
+        return;
+    const flowRate = vox.getSubstnaceData().getFlowRate();
+    const level = FM.getLevel(vox.getStringId(), x, y, z);
+    if (level < 0)
+        return;
+    const levelState = FM.getLevelState(vox.getStringId(), x, y, z);
+    tasks.queues.flow.update.queue.push([x, y, z, level, levelState]);
+    while (tasks.queues.flow.update.queue.length != 0) {
+        FM.setDimension(dimension);
+        RunFlowPropagation(tasks, vox.getStringId());
+        RunFlowIncrease(tasks, vox.getStringId());
+        if (rebuild) {
+            tasks.runRebuildQueue();
+            await FM.wait(EngineSettings.settings.flow.baseFlowLimit * flowRate);
+        }
+    }
+}
+function RunFlowPropagation(tasks, vox) {
+    const que = tasks.queues.flow.update.queue;
+    const noRemoveMap = tasks.queues.flow.remove.noRemoveMap;
+    for (let i = 0; i < que.length; i++) {
+        const node = que[i];
+        const x = node[0];
+        const y = node[1];
+        const z = node[2];
+        const l = FM.getLevel(vox, x, y, z);
+        const s = FM.getLevelState(vox, x, y, z);
+        noRemoveMap.add(x, y, z);
+        if (FM.canFlowOutwardTest(vox, x, y, z)) {
+            const n1 = FM.getLevel(vox, x + 1, y, z);
+            if (n1 + 1 < l && n1 >= 0) {
+                let n1l = l - 1;
+                que.push([x + 1, y, z, n1l, 0]);
+            }
+            const n2 = FM.getLevel(vox, x - 1, y, z);
+            if (n2 + 1 < l && n2 >= 0) {
+                let n2l = l - 1;
+                que.push([x - 1, y, z, n2l, 0]);
+            }
+            const n3 = FM.getLevel(vox, x, y, z + 1);
+            if (n3 + 1 < l && n3 >= 0) {
+                let n3l = l - 1;
+                que.push([x, y, z + 1, n3l, 0]);
+            }
+            const n4 = FM.getLevel(vox, x, y, z - 1);
+            if (n4 + 1 < l && n4 >= 0) {
+                let n4l = l - 1;
+                que.push([x, y, z - 1, n4l, 0]);
+            }
+        }
+        const n5 = FM.getLevel(vox, x, y - 1, z);
+        if (n5 <= l && n5 >= 0) {
+            let state = 1;
+            let level = 7;
+            if (l <= 0 && s != 1) {
+                state = 0;
+                level = l - 2;
+            }
+            que.push([x, y - 1, z, level, state]);
+        }
+    }
+}
+function RunFlowIncrease(tasks, vox) {
+    const que = tasks.queues.flow.update.queue;
+    const map = tasks.queues.flow.update.map;
+    const reque = [];
+    while (que.length != 0) {
+        const node = que.shift();
+        if (!node) {
+            break;
+        }
+        const x = node[0];
+        const y = node[1];
+        const z = node[2];
+        const level = node[3];
+        const levelState = node[4];
+        if (map.inMap(x, y, z))
+            continue;
+        map.add(x, y, z);
+        if (level > -1) {
+            FM.setVoxel(tasks, vox, level, levelState, x, y, z);
+            reque.push([x, y, z, -1]);
+        }
+        tasks.addToRebuildQueue(x, y, z);
+    }
+    //@ts-ignore
+    tasks.queues.flow.update.queue = reque;
+    map.clear();
+}

package/Propagation/Illumanation/Functions/RGBUpdate.d.ts

@@ -0,0 +1,3 @@
+import type { LightTaskRequest } from "../../../Contexts/Constructor/Tasks/TasksRequest";
+export declare function RGBUpdate(tasks: LightTaskRequest): void;
+export declare function RGBRemove(tasks: LightTaskRequest): void;

package/Propagation/Illumanation/Functions/RGBUpdate.js

@@ -0,0 +1,169 @@
+import { IlluminationManager as IM } from "../IlluminationManager.js";
+export function RGBUpdate(tasks) {
+    IM.setDimension(tasks.origin[0]);
+    const queue = tasks.queues.rgb.update;
+    while (queue.length != 0) {
+        const x = queue.shift();
+        const y = queue.shift();
+        const z = queue.shift();
+        if (!IM._sDataTool.loadInAt(x, y, z))
+            continue;
+        if (IM._sDataTool.isBarrier())
+            continue;
+        const sl = IM._sDataTool.getLight();
+        if (sl <= 0)
+            continue;
+        if (IM._nDataTool.loadInAt(x - 1, y, z)) {
+            const nl = IM._nDataTool.getLight();
+            if (nl > -1 && IM.lightData.isLessThanForRGBAdd(nl, sl)) {
+                queue.push(x - 1, y, z);
+                IM._nDataTool.setLight(IM.lightData.getMinusOneForRGB(sl, nl)).commit();
+            }
+        }
+        if (IM._nDataTool.loadInAt(x + 1, y, z)) {
+            const nl = IM._nDataTool.getLight();
+            if (nl > -1 && IM.lightData.isLessThanForRGBAdd(nl, sl)) {
+                queue.push(x + 1, y, z);
+                IM._nDataTool.setLight(IM.lightData.getMinusOneForRGB(sl, nl)).commit();
+            }
+        }
+        if (IM._nDataTool.loadInAt(x, y, z - 1)) {
+            const nl = IM._nDataTool.getLight();
+            if (nl > -1 && IM.lightData.isLessThanForRGBAdd(nl, sl)) {
+                queue.push(x, y, z - 1);
+                IM._nDataTool.setLight(IM.lightData.getMinusOneForRGB(sl, nl)).commit();
+            }
+        }
+        if (IM._nDataTool.loadInAt(x, y, z + 1)) {
+            const nl = IM._nDataTool.getLight();
+            if (nl > -1 && IM.lightData.isLessThanForRGBAdd(nl, sl)) {
+                queue.push(x, y, z + 1);
+                IM._nDataTool.setLight(IM.lightData.getMinusOneForRGB(sl, nl)).commit();
+            }
+        }
+        if (IM._nDataTool.loadInAt(x, y - 1, z)) {
+            const nl = IM._nDataTool.getLight();
+            if (nl > -1 && IM.lightData.isLessThanForRGBAdd(nl, sl)) {
+                queue.push(x, y - 1, z);
+                IM._nDataTool.setLight(IM.lightData.getMinusOneForRGB(sl, nl)).commit();
+            }
+        }
+        if (IM._nDataTool.loadInAt(x, y + 1, z)) {
+            const nl = IM._nDataTool.getLight();
+            if (nl > -1 && IM.lightData.isLessThanForRGBAdd(nl, sl)) {
+                queue.push(x, y + 1, z);
+                IM._nDataTool.setLight(IM.lightData.getMinusOneForRGB(sl, nl)).commit();
+            }
+        }
+        tasks.addNeighborsToRebuildQueue(x, y, z);
+    }
+}
+export function RGBRemove(tasks) {
+    IM.setDimension(tasks.origin[0]);
+    const remove = tasks.queues.rgb.remove;
+    const update = tasks.queues.rgb.update;
+    const map = tasks.queues.rgb.map;
+    while (remove.length != 0) {
+        const x = remove.shift();
+        const y = remove.shift();
+        const z = remove.shift();
+        if (map.inMap(x, y, z))
+            continue;
+        map.add(x, y, z);
+        if (!IM._sDataTool.loadInAt(x, y, z))
+            continue;
+        const sl = IM._sDataTool.getLight();
+        if (sl <= 0)
+            continue;
+        if (IM._nDataTool.loadInAt(x - 1, y, z)) {
+            const nl = IM._nDataTool.getLight();
+            const n1HasRGB = IM.lightData.hasRGBLight(nl);
+            if (n1HasRGB && IM.lightData.isLessThanForRGBRemove(nl, sl)) {
+                remove.push(x - 1, y, z);
+                if (IM._nDataTool.isLightSource()) {
+                    update.push(x - 1, y, z);
+                }
+            }
+            else {
+                if (n1HasRGB && IM.lightData.isGreaterOrEqualThanForRGBRemove(nl, sl)) {
+                    update.push(x - 1, y, z);
+                }
+            }
+        }
+        if (IM._nDataTool.loadInAt(x + 1, y, z)) {
+            const nl = IM._nDataTool.getLight();
+            const n1HasRGB = IM.lightData.hasRGBLight(nl);
+            if (n1HasRGB && IM.lightData.isLessThanForRGBRemove(nl, sl)) {
+                remove.push(x + 1, y, z);
+                if (IM._nDataTool.isLightSource()) {
+                    update.push(x + 1, y, z);
+                }
+            }
+            else {
+                if (n1HasRGB && IM.lightData.isGreaterOrEqualThanForRGBRemove(nl, sl)) {
+                    update.push(x + 1, y, z);
+                }
+            }
+        }
+        if (IM._nDataTool.loadInAt(x, y, z - 1)) {
+            const nl = IM._nDataTool.getLight();
+            const n1HasRGB = IM.lightData.hasRGBLight(nl);
+            if (n1HasRGB && IM.lightData.isLessThanForRGBRemove(nl, sl)) {
+                remove.push(x, y, z - 1);
+            }
+            else {
+                if (n1HasRGB && IM.lightData.isGreaterOrEqualThanForRGBRemove(nl, sl)) {
+                    update.push(x, y, z - 1);
+                }
+            }
+        }
+        if (IM._nDataTool.loadInAt(x, y, z + 1)) {
+            const nl = IM._nDataTool.getLight();
+            const n1HasRGB = IM.lightData.hasRGBLight(nl);
+            if (n1HasRGB && IM.lightData.isLessThanForRGBRemove(nl, sl)) {
+                remove.push(x, y, z + 1);
+                if (IM._nDataTool.isLightSource()) {
+                    update.push(x, y, z + 1);
+                }
+            }
+            else {
+                if (n1HasRGB && IM.lightData.isGreaterOrEqualThanForRGBRemove(nl, sl)) {
+                    update.push(x, y, z + 1);
+                }
+            }
+        }
+        if (IM._nDataTool.loadInAt(x, y - 1, z)) {
+            const nl = IM._nDataTool.getLight();
+            const n1HasRGB = IM.lightData.hasRGBLight(nl);
+            if (n1HasRGB && IM.lightData.isLessThanForRGBRemove(nl, sl)) {
+                remove.push(x, y - 1, z);
+                if (IM._nDataTool.isLightSource()) {
+                    update.push(x, y - 1, z);
+                }
+            }
+            else {
+                if (n1HasRGB && IM.lightData.isGreaterOrEqualThanForRGBRemove(nl, sl)) {
+                    update.push(x, y - 1, z);
+                }
+            }
+        }
+        if (IM._nDataTool.loadInAt(x, y + 1, z)) {
+            const nl = IM._nDataTool.getLight();
+            const n1HasRGB = IM.lightData.hasRGBLight(nl);
+            if (n1HasRGB && IM.lightData.isLessThanForRGBRemove(nl, sl)) {
+                remove.push(x, y + 1, z);
+                if (IM._nDataTool.isLightSource()) {
+                    update.push(x, y + 1, z);
+                }
+            }
+            else {
+                if (n1HasRGB && IM.lightData.isGreaterOrEqualThanForRGBRemove(nl, sl)) {
+                    update.push(x, y + 1, z);
+                }
+            }
+        }
+        tasks.addNeighborsToRebuildQueue(x, y, z);
+        IM._sDataTool.setLight(IM.lightData.removeRGBLight(sl)).commit();
+    }
+    map.clear();
+}

package/Propagation/Illumanation/Functions/SunUpdate.d.ts

@@ -0,0 +1,3 @@
+import type { LightTaskRequest } from "../../../Contexts/Constructor/Tasks/TasksRequest";
+export declare function SunUpdate(tasks: LightTaskRequest): void;
+export declare function SunRemove(tasks: LightTaskRequest, clearUpdateMap?: boolean): void;