@divinevoxel/vlox 0.0.80 → 0.0.81

package/Mesher/Voxels/Models/VoxelGeometryBuilderCacheSpaceN.js

@@ -0,0 +1,204 @@
+import { VoxelCursor } from "../../../Voxels/Cursor/VoxelCursor";
+import { GetYXZOrderArrayIndex } from "../../../Math/Indexing";
+import { VoxelSchemas } from "../../../Voxels/State/VoxelSchemas";
+import { VoxelLUT } from "../../../Voxels/Data/VoxelLUT";
+export class VoxelGeometryBuilderCacheSpace {
+    bounds;
+    foundHash;
+    lightCache;
+    //cache of the voxel ids
+    voxelCache;
+    //cache of the true voxel ids
+    trueVoxelCache;
+    //cache of the reltional voxel ids
+    reltionalVoxelCache;
+    //cache of the reltional state
+    reltionalStateCache;
+    //cache of the secondary voxel ids
+    secondaryVoxelCache;
+    //cache of the true secondary voxel ids
+    secondaryTrueVoxelCache;
+    //cache of the reltional secondary voxel ids
+    secondaryReltionalVoxelCache;
+    //cache of the secondary reltional state
+    secondaryReltionalStateCache;
+    hasSecondary;
+    noCastAO;
+    secondaryNoCastAO;
+    fullBlock;
+    offset = [0, 0, 0];
+    voxelCursor = new VoxelCursor();
+    constructor(bounds) {
+        this.bounds = bounds;
+        const volume = bounds.x * bounds.y * bounds.z;
+        this.foundHash = new Uint8Array(volume);
+        this.lightCache = new Int32Array(volume);
+        this.voxelCache = new Uint16Array(volume);
+        this.trueVoxelCache = new Uint16Array(volume);
+        this.reltionalVoxelCache = new Uint16Array(volume);
+        this.reltionalStateCache = new Uint16Array(volume);
+        this.secondaryVoxelCache = new Uint16Array(volume);
+        this.secondaryTrueVoxelCache = new Uint16Array(volume);
+        this.secondaryReltionalVoxelCache = new Uint16Array(volume);
+        this.secondaryReltionalStateCache = new Uint16Array(volume);
+        this.fullBlock = new Uint8Array(volume);
+        this.hasSecondary = new Uint8Array(volume);
+        this.noCastAO = new Uint8Array(volume);
+        this.secondaryNoCastAO = new Uint8Array(volume);
+    }
+    start(x, y, z) {
+        this.offset[0] = x;
+        this.offset[1] = y;
+        this.offset[2] = z;
+        this.fullBlock.fill(0);
+        this.lightCache.fill(0);
+        this.foundHash.fill(0);
+        this.voxelCache.fill(0);
+        this.trueVoxelCache.fill(0);
+        this.reltionalVoxelCache.fill(0);
+        this.reltionalStateCache.fill(0);
+        this.secondaryVoxelCache.fill(0);
+        this.secondaryTrueVoxelCache.fill(0);
+        this.secondaryReltionalVoxelCache.fill(0);
+        this.secondaryReltionalStateCache.fill(0);
+        this.hasSecondary.fill(0);
+        this.noCastAO.fill(0);
+        this.secondaryNoCastAO.fill(0);
+    }
+    getIndex(x, y, z) {
+        return GetYXZOrderArrayIndex(x - this.offset[0], y - this.offset[1], z - this.offset[2], this.bounds.x, this.bounds.y, this.bounds.z);
+    }
+    getHash(dataCursor, x, y, z) {
+        const hashed = this.getIndex(x, y, z);
+        if (this.foundHash[hashed] == 0) {
+            this.hashState(dataCursor, hashed, x, y, z);
+        }
+        return hashed;
+    }
+    getNoCastAO(index, secondary = false) {
+        return ((secondary ? this.secondaryNoCastAO[index] : this.noCastAO[index]) == 1);
+    }
+    getTrueVoxelId(index, secondary = false) {
+        return secondary
+            ? this.secondaryTrueVoxelCache[index]
+            : this.trueVoxelCache[index];
+    }
+    getVoxelId(index, secondary = false) {
+        return secondary ? this.secondaryVoxelCache[index] : this.voxelCache[index];
+    }
+    getRelationalState(index, secondary = false) {
+        return secondary
+            ? this.secondaryReltionalStateCache[index]
+            : this.reltionalStateCache[index];
+    }
+    getRelationalVoxelId(index, secondary = false) {
+        return secondary
+            ? this.secondaryReltionalVoxelCache[index]
+            : this.reltionalVoxelCache[index];
+    }
+    getHasSecondary(index) {
+        return this.hasSecondary[index];
+    }
+    hashState(dataCursor, index, x, y, z) {
+        if (this.foundHash[index] > 0)
+            return;
+        const voxel = dataCursor.getVoxel(x, y, z);
+        if (voxel) {
+            this.lightCache[index] = voxel.getLight();
+        }
+        if (!voxel) {
+            this.foundHash[index] = 1;
+            return;
+        }
+        const canHaveSecondary = voxel.canHaveSecondaryVoxel();
+        voxel.setSecondary(true);
+        const hasSecondary = canHaveSecondary && voxel.getStringId() !== "dve_air";
+        voxel.setSecondary(false);
+        if (!voxel.isRenderable() || !hasSecondary) {
+            this.foundHash[index] = 1;
+            return;
+        }
+        const trueVoxelId = voxel.getVoxelId();
+        const voxelId = voxel.getId();
+        this.trueVoxelCache[index] = trueVoxelId;
+        this.voxelCache[index] = voxelId;
+        let secondaryOpaque = false;
+        let secondaryTrueVoxelId = 0;
+        let secondaryVoxelId = 0;
+        if (hasSecondary) {
+            voxel.setSecondary(true);
+            secondaryOpaque = voxel.isOpaque();
+            secondaryTrueVoxelId = voxel.getVoxelId();
+            secondaryVoxelId = voxel.getId();
+            this.hasSecondary[index] = 1;
+            this.secondaryVoxelCache[index] = secondaryVoxelId;
+            this.secondaryTrueVoxelCache[index] = secondaryTrueVoxelId;
+            voxel.setSecondary(false);
+        }
+        if (voxel.isOpaque() || secondaryOpaque) {
+            this.foundHash[index] = 2;
+        }
+        else {
+            this.foundHash[index] = 3;
+        }
+        this.fullBlock[index] = voxel.tags["dve_full_block"] ? 1 : 0;
+        //no ao
+        this.noCastAO[index] = voxel.isLightSource() || voxel.noAO() ? 1 : 0;
+        if (hasSecondary) {
+            voxel.setSecondary(true);
+            this.secondaryNoCastAO[index] =
+                voxel.isLightSource() || voxel.noAO() ? 1 : 0;
+            voxel.setSecondary(false);
+        }
+        this.voxelCursor.copy(voxel).process();
+        let secondaryRelationalState = 0;
+        let secondaryRelationalMod = 0;
+        const relationalBuilder = VoxelSchemas.reltionalStateBuilderMap[VoxelLUT.modelsIndex[trueVoxelId]];
+        relationalBuilder.position.x = x;
+        relationalBuilder.position.y = y;
+        relationalBuilder.position.z = z;
+        relationalBuilder.voxel = this.voxelCursor;
+        relationalBuilder.dataCursor = dataCursor;
+        const reltionalState = relationalBuilder.buildState();
+        this.reltionalStateCache[index] = reltionalState;
+        if (hasSecondary) {
+            const relationalBuilder = VoxelSchemas.reltionalStateBuilderMap[VoxelLUT.modelsIndex[secondaryTrueVoxelId]];
+            relationalBuilder.position.x = x;
+            relationalBuilder.position.y = y;
+            relationalBuilder.position.z = z;
+            relationalBuilder.voxel = this.voxelCursor;
+            relationalBuilder.dataCursor = dataCursor;
+            this.voxelCursor.setSecondary(true);
+            secondaryRelationalState = relationalBuilder.buildState();
+            this.secondaryReltionalStateCache[index] = secondaryRelationalState;
+            this.voxelCursor.setSecondary(false);
+        }
+        const relationalModBuilder = VoxelSchemas.reltionalModBuilderMap[trueVoxelId];
+        let reltionalMod = 0;
+        if (relationalModBuilder) {
+            relationalModBuilder.position.x = x;
+            relationalModBuilder.position.y = y;
+            relationalModBuilder.position.z = z;
+            relationalModBuilder.voxel = this.voxelCursor;
+            relationalModBuilder.dataCursor = dataCursor;
+            reltionalMod = relationalModBuilder.buildState();
+        }
+        if (hasSecondary) {
+            const relationalModBuilder = VoxelSchemas.reltionalModBuilderMap[secondaryTrueVoxelId];
+            if (relationalModBuilder) {
+                relationalModBuilder.position.x = x;
+                relationalModBuilder.position.y = y;
+                relationalModBuilder.position.z = z;
+                relationalModBuilder.voxel = this.voxelCursor;
+                relationalModBuilder.dataCursor = dataCursor;
+                this.voxelCursor.setSecondary(true);
+                secondaryRelationalMod = relationalModBuilder.buildState();
+                this.voxelCursor.setSecondary(false);
+            }
+        }
+        this.reltionalVoxelCache[index] = VoxelLUT.getReltionalVoxelId(trueVoxelId, reltionalState, reltionalMod);
+        if (hasSecondary) {
+            this.secondaryReltionalVoxelCache[index] = VoxelLUT.getReltionalVoxelId(secondaryTrueVoxelId, secondaryRelationalState, secondaryRelationalMod);
+        }
+    }
+}

package/Mesher/Voxels/Models/{VoxelModelConstructorRegister.d.ts → VoxelGeometryConstructorRegister.d.ts}

@@ -1,14 +1,9 @@
 import { GeoemtryNodeConstructor } from "./Nodes/GeometryNode";
-import { VoxelConstructor } from "./VoxelConstructor";
 import { VoxelGeometryConstructor } from "./Nodes/VoxelGeometryConstructor";
-export declare class VoxelModelConstructorRegister {
+export declare class VoxelGeometryConstructorRegister {
     static geometry: VoxelGeometryConstructor[];
     static customNodes: Map<string, GeoemtryNodeConstructor<any, any>>;
     static registerCustomNode(id: string, node: GeoemtryNodeConstructor<any, any>): void;
     static getCustomNode(id: string): GeoemtryNodeConstructor<any, any>;
-    static constructorsPaltte: VoxelConstructor[];
-    static constructors: Map<string, VoxelConstructor>;
-    static getConstructor(id: string): VoxelConstructor;
-    static registerVoxel(voxel: VoxelConstructor | VoxelConstructor[]): void;
     static init(): void;
 }

package/Mesher/Voxels/Models/VoxelGeometryConstructorRegister.js

@@ -0,0 +1,20 @@
+import { VoxelGeometryConstructor } from "./Nodes/VoxelGeometryConstructor";
+import { GeometryLUT } from "../../../Voxels/Data/GeometryLUT";
+export class VoxelGeometryConstructorRegister {
+    static geometry = [];
+    static customNodes = new Map();
+    static registerCustomNode(id, node) {
+        this.customNodes.set(id, node);
+    }
+    static getCustomNode(id) {
+        const node = this.customNodes.get(id);
+        if (!node)
+            throw new Error(`Custom geometry node [${id}] does not exist.`);
+        return node;
+    }
+    static init() {
+        for (let i = 0; i < GeometryLUT.compiledGeometry.length; i++) {
+            this.geometry[i] = new VoxelGeometryConstructor(i);
+        }
+    }
+}

package/Mesher/Voxels/Models/VoxelModelBuilder.js

@@ -1,8 +1,7 @@
 //tools
 //data
 import { QuadScalarVertexData } from "../../Geometry/Primitives/QuadVertexData";
-import { VoxelFaces, VoxelFacesArray } from "../../../Math";
-import { QuadVerticies } from "../../Geometry/Geometry.types";
+import { VoxelFacesArray } from "../../../Math";
 import calculateFaceData from "./Common/Calc/FaceDataCalc.js";
 import { ProtoMesh } from "../../Geometry/Proto/ProtoMesh";
 import { Vector3Like, Vector4Like } from "@amodx/math";
@@ -51,14 +50,14 @@ export class VoxelModelBuilder {
         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][0 /* QuadVerticies.TopRight */] = [[], [], []];
+            this.condiotnalGeometryData[face][1 /* QuadVerticies.TopLeft */] = [[], [], []];
+            this.condiotnalGeometryData[face][2 /* QuadVerticies.BottomLeft */] = [
                 [],
                 [],
                 [],
             ];
-            this.condiotnalGeometryData[face][QuadVerticies.BottomRight] = [
+            this.condiotnalGeometryData[face][3 /* QuadVerticies.BottomRight */] = [
                 [],
                 [],
                 [],
@@ -67,10 +66,10 @@ export class VoxelModelBuilder {
         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;
+            this.lightData[face][0 /* QuadVerticies.TopRight */] = 0;
+            this.lightData[face][1 /* QuadVerticies.TopLeft */] = 0;
+            this.lightData[face][2 /* QuadVerticies.BottomLeft */] = 0;
+            this.lightData[face][3 /* QuadVerticies.BottomRight */] = 0;
         }
     }
     bounds = {
@@ -123,12 +122,12 @@ export class VoxelModelBuilder {
         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;
+        this.dataCalculated[0 /* VoxelFaces.Up */] = false;
+        this.dataCalculated[1 /* VoxelFaces.Down */] = false;
+        this.dataCalculated[2 /* VoxelFaces.North */] = false;
+        this.dataCalculated[3 /* VoxelFaces.South */] = false;
+        this.dataCalculated[4 /* VoxelFaces.East */] = false;
+        this.dataCalculated[5 /* VoxelFaces.West */] = false;
     }
     clear() {
         this.vars.reset();

package/Mesher/Voxels/Models/VoxelModelEffect.d.ts

@@ -1,7 +1,5 @@
-import { VoxelConstructor } from "./VoxelConstructor";
 import { Vector3Like } from "@amodx/math";
 export declare class VoxelModelEffect {
-    model: VoxelConstructor;
-    constructor(model: VoxelConstructor);
+    constructor();
     addEffects(state: number, origin: Vector3Like, effects: Record<string, number[]>): void;
 }

package/Mesher/Voxels/Models/VoxelModelEffect.js

@@ -1,9 +1,7 @@
 export class VoxelModelEffect {
-    model;
     /*   effects: { id: string; reader: StateTreeReader; palette: Vec3Array[][] }[] =
         []; */
-    constructor(model) {
-        this.model = model;
+    constructor() {
         /*   for (const effect of model.data.effects) {
             if (effect.type == "fx-points") {
               this.effects.push({

package/Renderer/DVERenderNode.types.d.ts

@@ -18,6 +18,7 @@ export type NodeMaterialOptions = {
     mipMapBias?: number;
     hasEffects?: boolean;
     backFaceCulling?: boolean;
+    forceDepthWrite?: boolean;
 };
 export type NodeMeshData = {
     id: string;

package/Renderer/InitTasks.js

@@ -3,6 +3,7 @@ import { MeshManager } from "./MeshManager";
 import { MeshRegister } from "./MeshRegister";
 import { EngineSettings } from "../Settings/EngineSettings";
 import { getLocationData } from "../Util/LocationData";
+import { WorldRegister } from "../World/WorldRegister";
 export default function RendererTasks() {
     Threads.registerTask("set-section", (data, origin) => {
         MeshManager.updateSection(data);
@@ -15,5 +16,6 @@ export default function RendererTasks() {
     });
     Threads.registerTask("clear-all", (data) => {
         MeshRegister.clearAll();
+        WorldRegister.clearAll();
     });
 }

package/Tasks/Paint/Erase/EraseVoxel.js

@@ -11,7 +11,6 @@ export function EraseVoxel(location, updateData) {
     let voxel = tasks.sDataCursor.getVoxel(x, y, z);
     if (!voxel)
         return;
-    const foundPower = voxel.getPower();
     voxel.ids[voxel._index] = 0;
     voxel.level[voxel._index] = 0;
     voxel.secondary[voxel._index] = 0;
@@ -20,6 +19,7 @@ export function EraseVoxel(location, updateData) {
     updateArea(tasks, x - 1, y - 1, z - 1, x + 1, y + 1, z + 1);
     voxel = tasks.sDataCursor.getVoxel(x, y, z);
     if (ES.doPower) {
+        const foundPower = voxel.getPower();
         if (foundPower > -1) {
             voxel.setLevel(foundPower);
             tasks.power.remove.push(x, y, z);

package/Tasks/Propagation/Illumanation/RGBUpdate.js

@@ -1,82 +1,225 @@
-import { CardinalNeighbors3D } from "../../../Math/CardinalNeighbors";
 import { getMinusOneForRGB, isGreaterOrEqualThanForRGBRemove, isLessThanForRGBAdd, isLessThanForRGBRemove, removeRGBLight, } from "./CommonFunctions";
-//@todo change array to not use push and shift
 export function RGBUpdate(tasks) {
     const queue = tasks.rgb.update;
-    while (queue.length) {
-        const x = queue.shift();
-        const y = queue.shift();
-        const z = queue.shift();
-        const voxel = tasks.sDataCursor.getVoxel(x, y, z);
+    const sDataCursor = tasks.sDataCursor;
+    const nDataCursor = tasks.nDataCursor;
+    const bounds = tasks.bounds;
+    let queueIndex = 0;
+    while (queueIndex < queue.length) {
+        const x = queue[queueIndex++];
+        const y = queue[queueIndex++];
+        const z = queue[queueIndex++];
+        const voxel = sDataCursor.getVoxel(x, y, z);
         if (!voxel)
             continue;
         const sl = voxel.getLight();
         if (sl <= 0)
             continue;
-        for (let i = 0; i < 6; i++) {
-            const nx = CardinalNeighbors3D[i][0] + x;
-            const ny = CardinalNeighbors3D[i][1] + y;
-            const nz = CardinalNeighbors3D[i][2] + z;
-            if (!tasks.nDataCursor.inBounds(nx, ny, nz))
-                continue;
-            const voxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
-            if (!voxel)
-                continue;
-            const nl = voxel.getLight();
-            if (nl > -1 && isLessThanForRGBAdd(nl, sl)) {
-                queue.push(nx, ny, nz);
-                voxel.setLight(getMinusOneForRGB(sl, nl));
+        let nx, ny, nz, nVoxel, nl;
+        nx = x + 1;
+        if (nDataCursor.inBounds(nx, y, z)) {
+            nVoxel = nDataCursor.getVoxel(nx, y, z);
+            if (nVoxel) {
+                nl = nVoxel.getLight();
+                if (nl > -1 && isLessThanForRGBAdd(nl, sl)) {
+                    queue.push(nx, y, z);
+                    nVoxel.setLight(getMinusOneForRGB(sl, nl));
+                }
+            }
+        }
+        nx = x - 1;
+        if (nDataCursor.inBounds(nx, y, z)) {
+            nVoxel = nDataCursor.getVoxel(nx, y, z);
+            if (nVoxel) {
+                nl = nVoxel.getLight();
+                if (nl > -1 && isLessThanForRGBAdd(nl, sl)) {
+                    queue.push(nx, y, z);
+                    nVoxel.setLight(getMinusOneForRGB(sl, nl));
+                }
+            }
+        }
+        ny = y + 1;
+        if (nDataCursor.inBounds(x, ny, z)) {
+            nVoxel = nDataCursor.getVoxel(x, ny, z);
+            if (nVoxel) {
+                nl = nVoxel.getLight();
+                if (nl > -1 && isLessThanForRGBAdd(nl, sl)) {
+                    queue.push(x, ny, z);
+                    nVoxel.setLight(getMinusOneForRGB(sl, nl));
+                }
+            }
+        }
+        ny = y - 1;
+        if (nDataCursor.inBounds(x, ny, z)) {
+            nVoxel = nDataCursor.getVoxel(x, ny, z);
+            if (nVoxel) {
+                nl = nVoxel.getLight();
+                if (nl > -1 && isLessThanForRGBAdd(nl, sl)) {
+                    queue.push(x, ny, z);
+                    nVoxel.setLight(getMinusOneForRGB(sl, nl));
+                }
             }
         }
-        tasks.bounds.updateDisplay(x, y, z);
+        nz = z + 1;
+        if (nDataCursor.inBounds(x, y, nz)) {
+            nVoxel = nDataCursor.getVoxel(x, y, nz);
+            if (nVoxel) {
+                nl = nVoxel.getLight();
+                if (nl > -1 && isLessThanForRGBAdd(nl, sl)) {
+                    queue.push(x, y, nz);
+                    nVoxel.setLight(getMinusOneForRGB(sl, nl));
+                }
+            }
+        }
+        nz = z - 1;
+        if (nDataCursor.inBounds(x, y, nz)) {
+            nVoxel = nDataCursor.getVoxel(x, y, nz);
+            if (nVoxel) {
+                nl = nVoxel.getLight();
+                if (nl > -1 && isLessThanForRGBAdd(nl, sl)) {
+                    queue.push(x, y, nz);
+                    nVoxel.setLight(getMinusOneForRGB(sl, nl));
+                }
+            }
+        }
+        bounds.updateDisplay(x, y, z);
     }
+    queue.length = 0;
 }
 export function RGBRemove(tasks) {
     const remove = tasks.rgb.remove;
     const update = tasks.rgb.update;
     const removeMap = tasks.rgb.removeMap;
     const updateMap = tasks.rgb.updateMap;
-    while (remove.length) {
-        const x = remove.shift();
-        const y = remove.shift();
-        const z = remove.shift();
+    const sDataCursor = tasks.sDataCursor;
+    const nDataCursor = tasks.nDataCursor;
+    const bounds = tasks.bounds;
+    let removeIndex = 0;
+    while (removeIndex < remove.length) {
+        const x = remove[removeIndex++];
+        const y = remove[removeIndex++];
+        const z = remove[removeIndex++];
         if (removeMap.has(x, y, z))
             continue;
         removeMap.add(x, y, z);
-        const voxel = tasks.sDataCursor.getVoxel(x, y, z);
+        const voxel = sDataCursor.getVoxel(x, y, z);
         if (!voxel)
             continue;
         const sl = voxel.getLight();
         if (sl <= 0)
             continue;
-        for (let i = 0; i < 6; i++) {
-            const nx = CardinalNeighbors3D[i][0] + x;
-            const ny = CardinalNeighbors3D[i][1] + y;
-            const nz = CardinalNeighbors3D[i][2] + z;
-            if (!tasks.nDataCursor.inBounds(nx, ny, nz))
-                continue;
-            const voxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
-            if (!voxel)
-                continue;
-            const nl = voxel.getLight();
-            const n1HasRGB = voxel.hasRGBLight();
-            if (n1HasRGB && isLessThanForRGBRemove(nl, sl)) {
-                remove.push(nx, ny, nz);
-                if (voxel.isLightSource()) {
-                    update.push(nx, ny, nz);
+        let nx, ny, nz, nVoxel, nl, n1HasRGB;
+        nx = x + 1;
+        if (nDataCursor.inBounds(nx, y, z)) {
+            nVoxel = nDataCursor.getVoxel(nx, y, z);
+            if (nVoxel) {
+                nl = nVoxel.getLight();
+                n1HasRGB = nVoxel.hasRGBLight();
+                if (n1HasRGB && isLessThanForRGBRemove(nl, sl)) {
+                    remove.push(nx, y, z);
+                    if (nVoxel.isLightSource()) {
+                        update.push(nx, y, z);
+                    }
+                }
+                else if (n1HasRGB && isGreaterOrEqualThanForRGBRemove(nl, sl) && !updateMap.has(nx, y, z)) {
+                    updateMap.add(nx, y, z);
+                    update.push(nx, y, z);
                 }
             }
-            else {
-                if (n1HasRGB &&
-                    isGreaterOrEqualThanForRGBRemove(nl, sl) &&
-                    !updateMap.has(nx, ny, nz)) {
-                    updateMap.add(nx, ny, nz);
-                    update.push(nx, ny, nz);
+        }
+        nx = x - 1;
+        if (nDataCursor.inBounds(nx, y, z)) {
+            nVoxel = nDataCursor.getVoxel(nx, y, z);
+            if (nVoxel) {
+                nl = nVoxel.getLight();
+                n1HasRGB = nVoxel.hasRGBLight();
+                if (n1HasRGB && isLessThanForRGBRemove(nl, sl)) {
+                    remove.push(nx, y, z);
+                    if (nVoxel.isLightSource()) {
+                        update.push(nx, y, z);
+                    }
+                }
+                else if (n1HasRGB && isGreaterOrEqualThanForRGBRemove(nl, sl) && !updateMap.has(nx, y, z)) {
+                    updateMap.add(nx, y, z);
+                    update.push(nx, y, z);
+                }
+            }
+        }
+        ny = y + 1;
+        if (nDataCursor.inBounds(x, ny, z)) {
+            nVoxel = nDataCursor.getVoxel(x, ny, z);
+            if (nVoxel) {
+                nl = nVoxel.getLight();
+                n1HasRGB = nVoxel.hasRGBLight();
+                if (n1HasRGB && isLessThanForRGBRemove(nl, sl)) {
+                    remove.push(x, ny, z);
+                    if (nVoxel.isLightSource()) {
+                        update.push(x, ny, z);
+                    }
+                }
+                else if (n1HasRGB && isGreaterOrEqualThanForRGBRemove(nl, sl) && !updateMap.has(x, ny, z)) {
+                    updateMap.add(x, ny, z);
+                    update.push(x, ny, z);
+                }
+            }
+        }
+        ny = y - 1;
+        if (nDataCursor.inBounds(x, ny, z)) {
+            nVoxel = nDataCursor.getVoxel(x, ny, z);
+            if (nVoxel) {
+                nl = nVoxel.getLight();
+                n1HasRGB = nVoxel.hasRGBLight();
+                if (n1HasRGB && isLessThanForRGBRemove(nl, sl)) {
+                    remove.push(x, ny, z);
+                    if (nVoxel.isLightSource()) {
+                        update.push(x, ny, z);
+                    }
+                }
+                else if (n1HasRGB && isGreaterOrEqualThanForRGBRemove(nl, sl) && !updateMap.has(x, ny, z)) {
+                    updateMap.add(x, ny, z);
+                    update.push(x, ny, z);
+                }
+            }
+        }
+        nz = z + 1;
+        if (nDataCursor.inBounds(x, y, nz)) {
+            nVoxel = nDataCursor.getVoxel(x, y, nz);
+            if (nVoxel) {
+                nl = nVoxel.getLight();
+                n1HasRGB = nVoxel.hasRGBLight();
+                if (n1HasRGB && isLessThanForRGBRemove(nl, sl)) {
+                    remove.push(x, y, nz);
+                    if (nVoxel.isLightSource()) {
+                        update.push(x, y, nz);
+                    }
+                }
+                else if (n1HasRGB && isGreaterOrEqualThanForRGBRemove(nl, sl) && !updateMap.has(x, y, nz)) {
+                    updateMap.add(x, y, nz);
+                    update.push(x, y, nz);
+                }
+            }
+        }
+        nz = z - 1;
+        if (nDataCursor.inBounds(x, y, nz)) {
+            nVoxel = nDataCursor.getVoxel(x, y, nz);
+            if (nVoxel) {
+                nl = nVoxel.getLight();
+                n1HasRGB = nVoxel.hasRGBLight();
+                if (n1HasRGB && isLessThanForRGBRemove(nl, sl)) {
+                    remove.push(x, y, nz);
+                    if (nVoxel.isLightSource()) {
+                        update.push(x, y, nz);
+                    }
+                }
+                else if (n1HasRGB && isGreaterOrEqualThanForRGBRemove(nl, sl) && !updateMap.has(x, y, nz)) {
+                    updateMap.add(x, y, nz);
+                    update.push(x, y, nz);
                 }
             }
         }
-        tasks.bounds.updateDisplay(x, y, z);
+        bounds.updateDisplay(x, y, z);
         voxel.setLight(removeRGBLight(sl));
     }
+    remove.length = 0;
     removeMap.clear();
 }

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

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