@divinevoxel/vlox 0.0.4 → 0.0.6

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;

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

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

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

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

package/Tasks/Propagation/Illumanation/WorldRGB.js

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

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

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

package/Tasks/Propagation/Illumanation/WorldSun.js

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