@divinevoxel/vlox 0.0.4 → 0.0.5

package/Tasks/Propagation/Flow/FlowUpdate.js

@@ -0,0 +1,98 @@
+import { FlowManager as FM } from "./FlowManager.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.flow.update.queue.push([x, y, z, level, levelState]);
+      while (tasks.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.flow.update.queue;
+      const noRemoveMap = tasks.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.flow.update.queue;
+    const map = tasks.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.has(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.bounds.update(x, y, z);
+    }
+    //@ts-ignore
+    tasks.queues.flow.update.queue = reque;
+    map.clear();
+}

package/Tasks/Propagation/Flow/WorldFlow.d.ts

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

package/Tasks/Propagation/Flow/WorldFlow.js

@@ -0,0 +1,153 @@
+import { WorldSpaces } from "../../../World/WorldSpaces";
+import { WorldRegister } from "../../../World/WorldRegister";
+import { SectionHeightMap } from "../../../World/Section/SectionHeightMap";
+import { EngineSettings } from "../../../Settings/EngineSettings";
+import { SunRemove, SunUpdate } from "../Illumanation/SunUpdate";
+import { RGBRemove, RGBUpdate } from "../Illumanation/RGBUpdate";
+import { WorldBounds } from "../../../World/WorldBounds";
+const flowUpdateChecks = [
+    [0, -1, 0],
+    [1, 0, 0],
+    [-1, 0, 0],
+    [0, 0, 1],
+    [0, 0, -1],
+];
+const queue = [];
+const floodOutChecks = [
+    [1, 0, 0],
+    [-1, 0, 0],
+    [0, 0, 1],
+    [0, 0, -1],
+];
+function Flood(task, voxel) {
+    const voxelId = voxel.id;
+    while (queue.length) {
+        const x = queue.shift();
+        const y = queue.shift();
+        const z = queue.shift();
+        const voxel = task.sDataCursor.getVoxel(x, y, z);
+        if (!voxel)
+            continue;
+        const level = voxel.getLevel();
+        if (level <= 1)
+            continue;
+        const levelState = voxel.getLevelState();
+        const hasBottomVoxel = !task.nDataCursor.getVoxel(x, y - 1, z)?.isAir() || false;
+        if (hasBottomVoxel && !levelState) {
+            for (let i = 0; i < 4; i++) {
+                const nx = floodOutChecks[i][0] + x;
+                const ny = floodOutChecks[i][1] + y;
+                const nz = floodOutChecks[i][2] + z;
+                const downVoxel = task.nDataCursor.getVoxel(nx, ny - 1, nz);
+                const downAir = downVoxel?.isAir() || false;
+                const downSameVoxel = downVoxel?.getId() == voxelId;
+                let nVoxel = task.nDataCursor.getVoxel(nx, ny, nz);
+                if (!nVoxel)
+                    continue;
+                const nLevel = nVoxel.isAir() ? 0 : nVoxel.getLevel();
+                const nState = nVoxel.getLevelState();
+                if (nLevel < level &&
+                    (nVoxel.id == voxelId || nVoxel.isAir()) &&
+                    nState == 0) {
+                    if (downAir && !downSameVoxel) {
+                        nVoxel.setId(voxelId);
+                        nVoxel.updateHeightMap(0);
+                        nVoxel.setLevel(7);
+                        nVoxel.setLevelState(1);
+                    }
+                    else if (!downSameVoxel) {
+                        nVoxel.setId(voxelId);
+                        nVoxel.updateHeightMap(0);
+                        nVoxel.setLevel(level - 1);
+                        nVoxel.setLevelState(0);
+                    }
+                    if (nVoxel.hasSunLight()) {
+                        task.sun.remove.push(nx, ny, nz);
+                    }
+                    if (nVoxel.hasRGBLight()) {
+                        task.rgb.remove.push(nx, ny, nz);
+                    }
+                    queue.push(nx, ny, nz);
+                }
+            }
+            continue;
+        }
+        if (!WorldBounds.inBounds(x, y - 1, z) && levelState != 1)
+            continue;
+        let nVoxel = task.nDataCursor.getVoxel(x, y - 1, z);
+        const nLevel = nVoxel.isAir()
+            ? 0
+            : nVoxel.getId() == voxelId
+                ? nVoxel.getLevel()
+                : -1;
+        const nState = nVoxel.getLevelState();
+        const nAir = nVoxel.isAir();
+        if (nLevel < 0 || nState == 1)
+            continue;
+        let state = nState;
+        if (nAir) {
+            const down = task.nDataCursor.getVoxel(x, y - 2, z);
+            if (down && !down.isAir()) {
+                state = 0;
+            }
+        }
+        nVoxel = task.nDataCursor.getVoxel(x, y - 1, z);
+        if (nVoxel.hasSunLight()) {
+            task.sun.remove.push(x, y - 1, z);
+        }
+        if (nVoxel.hasRGBLight()) {
+            task.rgb.remove.push(x, y - 1, z);
+        }
+        nVoxel.setId(voxelId);
+        nVoxel.updateHeightMap(0);
+        nVoxel.setLevel(7);
+        nVoxel.setLevelState(state);
+        queue.push(x, y - 1, z);
+    }
+}
+export function WorldFlow(task) {
+    if (!EngineSettings.doFlow())
+        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 flow 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 = sector.sections.length - 1; i >= 0; i--) {
+        const section = sector.sections[i];
+        if (!section)
+            continue;
+        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 + maxY; y >= cy + minY; y--) {
+            for (let z = cz; z < maxZ; z++) {
+                for (let x = cx; x < maxX; x++) {
+                    const voxel = task.nDataCursor.getVoxel(x, y, z);
+                    if (!voxel || voxel.isAir())
+                        continue;
+                    if (voxel.getSubstanceData().isLiquid()) {
+                        for (let i = 0; i < 5; i++) {
+                            const nVoxel = task.nDataCursor.getVoxel(x + flowUpdateChecks[i][0], y + flowUpdateChecks[i][1], z + flowUpdateChecks[i][2]);
+                            if (nVoxel && nVoxel.isAir()) {
+                                queue.push(x, y, z);
+                                Flood(task, voxel);
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    SunRemove(task);
+    RGBRemove(task);
+    SunUpdate(task);
+    RGBUpdate(task);
+}

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

@@ -0,0 +1,104 @@
+/**# Is Less Than For RGB Remove
+ * ---
+ * Compares values for the RGB encoded light values.
+ * Used for RGB light remove.
+ * @param n1
+ * @param n2
+ */
+export declare function isLessThanForRGBRemove(n1: number, n2: number): boolean;
+/**# Is Less Than For RGB Add
+ * ---
+ * Compares values for the RGB encoded light values.
+ * Used for RGB light add.
+ * @param n1
+ * @param n2
+ */
+export declare function isLessThanForRGBAdd(n1: number, n2: number): boolean;
+/**# Is Greater Or Equal Than For RGB Remove
+ * ---
+ * Compares values for the RGB encoded light values.
+ * Used for RGB light remove.
+ * @param n1
+ * @param n2
+ */
+export declare function isGreaterOrEqualThanForRGBRemove(n1: number, n2: number): boolean;
+/**# Get Minus One For RGB
+ * ---
+ * Returns the RGB light values minus one.
+ * @param sl - source light value
+ */
+export declare function getMinusOneForRGB(sl: number, nl: number): number;
+/**# Remove RGB Light
+ * ---
+ * Removes all RGB light from an encoded light value.
+ * @param sl - source light value
+ */
+export declare function removeRGBLight(sl: number): number;
+/**# Get Full Sun Light
+ * --
+ * Alters the encoded light number passed to it to give it full sun light.
+ * @param sl - source light value
+ */
+export declare function getFullSunLight(sl: number): number;
+/**# Is Less Than For Sun Add
+ * ---
+ * Used to calculate sun light addition.
+ * Used to check all neighbors expect down.
+ * @param n1
+ * @param n2
+ */
+export declare function isLessThanForSunAdd(n1: number, n2: number): boolean;
+/**# Is Less Than For Sun AddDown
+ *
+ * Used to calculate sun light addition.
+ * Used to check only the down neighbor.
+ * @param n1
+ * @param n2
+ */
+export declare function isLessThanForSunAddDown(n1: number, n2: number): boolean;
+export declare function isLessThanForSunAddUp(n1: number, n2: number): boolean;
+/**# Get Sun Light For Under Voxel
+ * ---
+ * Gets the sun light value for sun light addition when setting the
+ * down neighbor.
+ * @param currentVoxel
+ */
+export declare function getSunLightForUnderVoxel(sl: number, nl: number): number;
+/**# Get Minus One For Sun
+ * ---
+ * Returns the sun light level passed to it minus one.
+ * Used for sun light addition on all neighbors expect the down one.
+ * @param sl - source light value
+ */
+export declare function getMinusOneForSun(sl: number, nl: number): number;
+/**# Is Less Than For Sun Remove
+ * ---
+ * Compares two encoded light values sun light values.
+ * Used for sun light removal.
+ * @param n1
+ * @param sl - source light value
+ */
+export declare function isLessThanForSunRemove(n1: number, sl: number): boolean;
+/**# Is Greater Or Equal Than For Sun Remove
+ * ---
+ * Compares two encoded light values sun light values.
+ * Used for sun light removal.
+ * @param n1
+ * @param sl - source light value
+ */
+export declare function isGreaterOrEqualThanForSunRemove(n1: number, sl: number): boolean;
+/**# Sun Light Compare ForDown Sun Remove
+ * ---
+ * Compares two encoded light values sun light values.
+ * Used for sun light removal in the downward direction only.
+ * @param n1
+ * @param sl - source light value
+ */
+export declare function sunLightCompareForDownSunRemove(n1: number, sl: number): boolean;
+/**# Remove Sun Light
+ * ---
+ * Removes the sun light from a light encoded value.
+ * @param sl - source light value
+ */
+export declare function removeSunLight(sl: number): number;
+export declare function minusOneForAll(sl: number): number;

package/Tasks/Propagation/Illumanation/CommonFunctions.js

@@ -0,0 +1,280 @@
+let SRS = 2;
+function getS(value) {
+    return value & 0xf;
+}
+function getR(value) {
+    return (value & (0xf << 4)) >> 4;
+}
+function getG(value) {
+    return (value & (0xf << 8)) >> 8;
+}
+function getB(value) {
+    return (value & (0xf << 12)) >> 12;
+}
+function setS(value, sl) {
+    return (sl & ~0xf) | value;
+}
+function setR(value, sl) {
+    return (sl & ~(0xf << 4)) | (value << 4);
+}
+function setG(value, sl) {
+    return (sl & ~(0xf << 8)) | (value << 8);
+}
+function setB(value, sl) {
+    return (sl & ~(0xf << 12)) | (value << 12);
+}
+/**# Is Less Than For RGB Remove
+ * ---
+ * Compares values for the RGB encoded light values.
+ * Used for RGB light remove.
+ * @param n1
+ * @param n2
+ */
+export function isLessThanForRGBRemove(n1, n2) {
+    let r1 = getR(n1);
+    let g1 = getG(n1);
+    let b1 = getB(n1);
+    let r2 = getR(n2);
+    let g2 = getG(n2);
+    let b2 = getB(n2);
+    return r1 < r2 || g1 < g2 || b1 < b2;
+}
+/**# Is Less Than For RGB Add
+ * ---
+ * Compares values for the RGB encoded light values.
+ * Used for RGB light add.
+ * @param n1
+ * @param n2
+ */
+export function isLessThanForRGBAdd(n1, n2) {
+    let r1 = getR(n1) + 2;
+    let g1 = getG(n1) + 2;
+    let b1 = getB(n1) + 2;
+    let r2 = getR(n2);
+    let g2 = getG(n2);
+    let b2 = getB(n2);
+    return r1 <= r2 || g1 <= g2 || b1 <= b2;
+}
+/**# Is Greater Or Equal Than For RGB Remove
+ * ---
+ * Compares values for the RGB encoded light values.
+ * Used for RGB light remove.
+ * @param n1
+ * @param n2
+ */
+export function isGreaterOrEqualThanForRGBRemove(n1, n2) {
+    let r1 = getR(n1);
+    let g1 = getG(n1);
+    let b1 = getB(n1);
+    let r2 = getR(n2);
+    let g2 = getG(n2);
+    let b2 = getB(n2);
+    return r1 >= r2 || g1 >= g2 || b1 >= b2;
+}
+/**# Get Minus One For RGB
+ * ---
+ * Returns the RGB light values minus one.
+ * @param sl - source light value
+ */
+export function getMinusOneForRGB(sl, nl) {
+    let s = getS(nl);
+    let r = getR(sl) - 1;
+    if (r < 0)
+        r = 0;
+    let rn = getR(nl);
+    if (r < rn) {
+        r = rn;
+    }
+    let g = getG(sl) - 1;
+    if (g < 0)
+        g = 0;
+    let gn = getG(nl);
+    if (g < gn) {
+        g = gn;
+    }
+    let b = getB(sl) - 1;
+    if (b < 0)
+        b = 0;
+    let bn = getB(nl);
+    if (b < bn) {
+        b = bn;
+    }
+    let bv = 0;
+    bv = setS(s, bv);
+    bv = setR(r, bv);
+    bv = setG(g, bv);
+    bv = setB(b, bv);
+    return bv;
+}
+/**# Remove RGB Light
+ * ---
+ * Removes all RGB light from an encoded light value.
+ * @param sl - source light value
+ */
+export function removeRGBLight(sl) {
+    let s = getS(sl);
+    let bv = 0;
+    bv = setR(0, bv);
+    bv = setG(0, bv);
+    bv = setB(0, bv);
+    bv = setS(s, bv);
+    return bv;
+}
+/**# Get Full Sun Light
+ * --
+ * Alters the encoded light number passed to it to give it full sun light.
+ * @param sl - source light value
+ */
+export function getFullSunLight(sl) {
+    return sl | 0b1111;
+}
+/**# Is Less Than For Sun Add
+ * ---
+ * Used to calculate sun light addition.
+ * Used to check all neighbors expect down.
+ * @param n1
+ * @param n2
+ */
+export function isLessThanForSunAdd(n1, n2) {
+    let sl1 = getS(n1);
+    let sl2 = getS(n2);
+    return sl1 + SRS < sl2;
+}
+/**# Is Less Than For Sun AddDown
+ *
+ * Used to calculate sun light addition.
+ * Used to check only the down neighbor.
+ * @param n1
+ * @param n2
+ */
+export function isLessThanForSunAddDown(n1, n2) {
+    let sl1 = getS(n1);
+    let sl2 = getS(n2);
+    if (sl2 == 0xf) {
+        return sl1 < sl2;
+    }
+    return sl1 + SRS < sl2;
+}
+export function isLessThanForSunAddUp(n1, n2) {
+    let sl1 = getS(n1);
+    let sl2 = getS(n2);
+    if (sl1 == sl2)
+        return false;
+    if (sl2 == 0xf || sl1 == 0xf)
+        return false;
+    return sl1 + SRS < sl2;
+}
+/**# Get Sun Light For Under Voxel
+ * ---
+ * Gets the sun light value for sun light addition when setting the
+ * down neighbor.
+ * @param currentVoxel
+ */
+export function getSunLightForUnderVoxel(sl, nl) {
+    let s = getS(sl);
+    let sn = getS(nl);
+    if (s == 15) {
+        sn = s;
+    }
+    if (s < 15) {
+        sn = s - SRS;
+    }
+    let r = getR(nl);
+    let g = getG(nl);
+    let b = getB(nl);
+    let bv = 0;
+    bv = setS(sn, bv);
+    bv = setR(r, bv);
+    bv = setG(g, bv);
+    bv = setB(b, bv);
+    return bv;
+}
+/**# Get Minus One For Sun
+ * ---
+ * Returns the sun light level passed to it minus one.
+ * Used for sun light addition on all neighbors expect the down one.
+ * @param sl - source light value
+ */
+export function getMinusOneForSun(sl, nl) {
+    let s = getS(sl) - SRS;
+    if (s < 0)
+        s = 0;
+    let sn = getS(nl);
+    if (s < sn) {
+        s = sn;
+    }
+    let r = getR(nl);
+    let g = getG(nl);
+    let b = getB(nl);
+    let bv = 0;
+    bv = setS(s, bv);
+    bv = setR(r, bv);
+    bv = setG(g, bv);
+    bv = setB(b, bv);
+    return bv;
+}
+/**# Is Less Than For Sun Remove
+ * ---
+ * Compares two encoded light values sun light values.
+ * Used for sun light removal.
+ * @param n1
+ * @param sl - source light value
+ */
+export function isLessThanForSunRemove(n1, sl) {
+    let s1 = getS(n1);
+    let s2 = getS(sl);
+    return s1 < s2;
+}
+/**# Is Greater Or Equal Than For Sun Remove
+ * ---
+ * Compares two encoded light values sun light values.
+ * Used for sun light removal.
+ * @param n1
+ * @param sl - source light value
+ */
+export function isGreaterOrEqualThanForSunRemove(n1, sl) {
+    let s1 = getS(n1);
+    let s2 = getS(sl);
+    return s1 >= s2;
+}
+/**# Sun Light Compare ForDown Sun Remove
+ * ---
+ * Compares two encoded light values sun light values.
+ * Used for sun light removal in the downward direction only.
+ * @param n1
+ * @param sl - source light value
+ */
+export function sunLightCompareForDownSunRemove(n1, sl) {
+    let s2 = getS(sl);
+    if (s2 == 0xf)
+        return true;
+    let s1 = getS(n1);
+    return s1 < s2;
+}
+/**# Remove Sun Light
+ * ---
+ * Removes the sun light from a light encoded value.
+ * @param sl - source light value
+ */
+export function removeSunLight(sl) {
+    return setS(0, sl);
+}
+export function minusOneForAll(sl) {
+    let s = getS(sl) - SRS;
+    let r = getR(sl) - 1;
+    let g = getG(sl) - 1;
+    let b = getB(sl) - 1;
+    if (s < 0)
+        s = 0;
+    if (r < 0)
+        r = 0;
+    if (g < 0)
+        g = 0;
+    if (b < 0)
+        b = 0;
+    let nl = setS(s, 0);
+    nl = setR(r, nl);
+    nl = setG(g, nl);
+    nl = setB(b, nl);
+    return nl;
+}

package/Tasks/Propagation/Illumanation/{Functions/RGBUpdate.d.ts → RGBUpdate.d.ts}

@@ -1,3 +1,3 @@
-import { UpdateTask } from "../../../Update/UpdateTask";
+import { UpdateTask } from "../../Update/UpdateTask";
 export declare function RGBUpdate(tasks: UpdateTask): void;
 export declare function RGBRemove(tasks: UpdateTask): void;

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

@@ -1,5 +1,5 @@
-import { $3dCardinalNeighbors } from "../../../../Math/Constants/CardinalNeighbors";
-import { LightData } from "../../../../Voxels/LightData";
+import { $3dCardinalNeighbors } from "../../../Math/CardinalNeighbors";
+import { getMinusOneForRGB, isGreaterOrEqualThanForRGBRemove, isLessThanForRGBAdd, isLessThanForRGBRemove, removeSunLight, } from "./CommonFunctions";
 //@todo change array to not use push and shift
 export function RGBUpdate(tasks) {
     const queue = tasks.rgb.update;
@@ -23,9 +23,9 @@ export function RGBUpdate(tasks) {
             if (!voxel)
                 continue;
             const nl = voxel.getLight();
-            if (nl > -1 && LightData.isLessThanForRGBAdd(nl, sl)) {
+            if (nl > -1 && isLessThanForRGBAdd(nl, sl)) {
                 queue.push(nx, ny, nz);
-                voxel.setLight(LightData.getMinusOneForRGB(sl, nl));
+                voxel.setLight(getMinusOneForRGB(sl, nl));
             }
         }
         tasks.bounds.update(x, y, z);
@@ -59,8 +59,8 @@ export function RGBRemove(tasks) {
             if (!voxel)
                 continue;
             const nl = voxel.getLight();
-            const n1HasRGB = LightData.hasRGBLight(nl);
-            if (n1HasRGB && LightData.isLessThanForRGBRemove(nl, sl)) {
+            const n1HasRGB = voxel.hasRGBLight();
+            if (n1HasRGB && isLessThanForRGBRemove(nl, sl)) {
                 remove.push(nx, ny, nz);
                 if (voxel.isLightSource()) {
                     update.push(nx, ny, nz);
@@ -68,7 +68,7 @@ export function RGBRemove(tasks) {
             }
             else {
                 if (n1HasRGB &&
-                    LightData.isGreaterOrEqualThanForRGBRemove(nl, sl) &&
+                    isGreaterOrEqualThanForRGBRemove(nl, sl) &&
                     !updateMap.has(nx, ny, nz)) {
                     updateMap.add(nx, ny, nz);
                     update.push(nx, ny, nz);
@@ -76,7 +76,7 @@ export function RGBRemove(tasks) {
             }
         }
         tasks.bounds.update(x, y, z);
-        voxel.setLight(LightData.removeRGBLight(sl));
+        voxel.setLight(removeSunLight(sl));
     }
     removeMap.clear();
 }

package/Tasks/Propagation/Illumanation/{Functions/SunUpdate.d.ts → SunUpdate.d.ts}

@@ -1,3 +1,3 @@
-import { UpdateTask } from "../../../Update/UpdateTask";
+import { UpdateTask } from "../../Update/UpdateTask";
 export declare function SunUpdate(tasks: UpdateTask): void;
 export declare function SunRemove(tasks: UpdateTask, clearUpdateMap?: boolean): void;