@divinevoxel/vlox 0.0.1 → 0.0.3

package/Propagation/Illumanation/Functions/RGBUpdate.js

@@ -1,169 +0,0 @@
-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

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

package/Propagation/Illumanation/Functions/SunUpdate.js

@@ -1,187 +0,0 @@
-import { IlluminationManager as IM } from "../IlluminationManager.js";
-export function SunUpdate(tasks) {
-    IM.setDimension(tasks.origin[0]);
-    const { update } = tasks.queues.sun;
-    while (update.length > 0) {
-        const x = update.shift();
-        const y = update.shift();
-        const z = update.shift();
-        if (!IM._sDataTool.loadInAt(x, y, z))
-            continue;
-        const sl = IM._sDataTool.getLight();
-        if (sl <= 0)
-            continue;
-        if (!IM.lightData.getS(sl))
-            continue;
-        if (IM._nDataTool.loadInAt(x - 1, y, z)) {
-            const nl = IM._nDataTool.getLight();
-            if (nl > -1 && IM.lightData.isLessThanForSunAdd(nl, sl)) {
-                update.push(x - 1, y, z);
-                IM._nDataTool.setLight(IM.lightData.getMinusOneForSun(sl, nl)).commit();
-            }
-        }
-        if (IM._nDataTool.loadInAt(x + 1, y, z)) {
-            const nl = IM._nDataTool.getLight();
-            if (nl > -1 && IM.lightData.isLessThanForSunAdd(nl, sl)) {
-                update.push(x + 1, y, z);
-                IM._nDataTool.setLight(IM.lightData.getMinusOneForSun(sl, nl)).commit();
-            }
-        }
-        if (IM._nDataTool.loadInAt(x, y, z - 1)) {
-            const nl = IM._nDataTool.getLight();
-            if (nl > -1 && IM.lightData.isLessThanForSunAdd(nl, sl)) {
-                update.push(x, y, z - 1);
-                IM._nDataTool.setLight(IM.lightData.getMinusOneForSun(sl, nl)).commit();
-            }
-        }
-        if (IM._nDataTool.loadInAt(x, y, z + 1)) {
-            const nl = IM._nDataTool.getLight();
-            if (nl > -1 && IM.lightData.isLessThanForSunAdd(nl, sl)) {
-                update.push(x, y, z + 1);
-                IM._nDataTool.setLight(IM.lightData.getMinusOneForSun(sl, nl)).commit();
-            }
-        }
-        if (IM._nDataTool.loadInAt(x, y - 1, z)) {
-            const nl = IM._nDataTool.getLight();
-            if (nl > -1 && IM.lightData.isLessThanForSunAddDown(nl, sl)) {
-                if (IM._nDataTool.isAir()) {
-                    update.push(x, y - 1, z);
-                    IM._nDataTool
-                        .setLight(IM.lightData.getSunLightForUnderVoxel(sl, nl))
-                        .commit();
-                }
-                else {
-                    const substance = IM._nDataTool.getSubstanceStringId();
-                    if (substance != "#dve_magma" && substance != "#dve_solid") {
-                        update.push(x, y - 1, z);
-                        IM._nDataTool
-                            .setLight(IM.lightData.getMinusOneForSun(sl, nl))
-                            .commit();
-                    }
-                }
-            }
-        }
-        if (IM._nDataTool.loadInAt(x, y + 1, z)) {
-            const nl = IM._nDataTool.getLight();
-            if (nl > -1 && IM.lightData.isLessThanForSunAdd(nl, sl)) {
-                update.push(x, y + 1, z);
-                IM._nDataTool.setLight(IM.lightData.getMinusOneForSun(sl, nl)).commit();
-            }
-        }
-        tasks.addNeighborsToRebuildQueue(x, y, z);
-    }
-}
-export function SunRemove(tasks, clearUpdateMap = true) {
-    IM.setDimension(tasks.origin[0]);
-    const { remove, update, remvoeMap, updateMap } = tasks.queues.sun;
-    while (remove.length != 0) {
-        const x = remove.shift();
-        const y = remove.shift();
-        const z = remove.shift();
-        if (remvoeMap.inMap(x, y, z))
-            continue;
-        remvoeMap.add(x, y, z);
-        if (!IM._sDataTool.loadInAt(x, y, z))
-            continue;
-        const sl = IM._sDataTool.getLight();
-        if (sl <= 0)
-            continue;
-        if (!IM.lightData.getS(sl))
-            continue;
-        if (IM._nDataTool.loadInAt(x - 1, y, z)) {
-            const nl = IM._nDataTool.getLight();
-            if (nl > 0) {
-                if (IM.lightData.isLessThanForSunRemove(nl, sl)) {
-                    remove.push(x - 1, y, z);
-                }
-                else {
-                    if (!updateMap.inMap(x - 1, y, z) &&
-                        IM.lightData.isGreaterOrEqualThanForSunRemove(nl, sl)) {
-                        update.push(x - 1, y, z);
-                        updateMap.add(x - 1, y, z);
-                    }
-                }
-            }
-        }
-        if (IM._nDataTool.loadInAt(x + 1, y, z)) {
-            const nl = IM._nDataTool.getLight();
-            if (nl > 0) {
-                if (IM.lightData.isLessThanForSunRemove(nl, sl)) {
-                    remove.push(x + 1, y, z);
-                }
-                else {
-                    if (!updateMap.inMap(x + 1, y, z) &&
-                        IM.lightData.isGreaterOrEqualThanForSunRemove(nl, sl)) {
-                        update.push(x + 1, y, z);
-                        updateMap.add(x + 1, y, z);
-                    }
-                }
-            }
-        }
-        if (IM._nDataTool.loadInAt(x, y, z - 1)) {
-            const nl = IM._nDataTool.getLight();
-            if (nl > 0) {
-                if (IM.lightData.isLessThanForSunRemove(nl, sl)) {
-                    remove.push(x, y, z - 1);
-                }
-                else {
-                    if (!updateMap.inMap(x, y, z - 1) &&
-                        IM.lightData.isGreaterOrEqualThanForSunRemove(nl, sl)) {
-                        update.push(x, y, z - 1);
-                        updateMap.add(x, y, z - 1);
-                    }
-                }
-            }
-        }
-        if (IM._nDataTool.loadInAt(x, y, z + 1)) {
-            const nl = IM._nDataTool.getLight();
-            if (nl > 0) {
-                if (IM.lightData.isLessThanForSunRemove(nl, sl)) {
-                    remove.push(x, y, z + 1);
-                }
-                else {
-                    if (!updateMap.inMap(x, y, z + 1) &&
-                        IM.lightData.isGreaterOrEqualThanForSunRemove(nl, sl)) {
-                        update.push(x, y, z + 1);
-                        updateMap.add(x, y, z + 1);
-                    }
-                }
-            }
-        }
-        if (IM._nDataTool.loadInAt(x, y - 1, z)) {
-            const nl = IM._nDataTool.getLight();
-            if (nl > 0) {
-                if (IM.lightData.sunLightCompareForDownSunRemove(nl, sl)) {
-                    remove.push(x, y - 1, z);
-                }
-                else {
-                    if (!updateMap.inMap(x, y - 1, z) &&
-                        IM.lightData.isGreaterOrEqualThanForSunRemove(nl, sl)) {
-                        update.push(x, y - 1, z);
-                        updateMap.add(x, y - 1, z);
-                    }
-                }
-            }
-        }
-        if (IM._nDataTool.loadInAt(x, y + 1, z)) {
-            const n6 = IM._nDataTool.getLight();
-            if (n6 > 0) {
-                if (IM.lightData.isLessThanForSunRemove(n6, sl)) {
-                    remove.push(x, y + 1, z);
-                }
-                else {
-                    if (!updateMap.inMap(x, y - 1, z) &&
-                        IM.lightData.isGreaterOrEqualThanForSunRemove(n6, sl)) {
-                        update.push(x, y + 1, z);
-                        updateMap.add(x, y + 1, z);
-                    }
-                }
-            }
-        }
-        tasks.addNeighborsToRebuildQueue(x, y, z);
-        IM._sDataTool.setLight(IM.lightData.removeSunLight(sl)).commit();
-    }
-    if (clearUpdateMap)
-        updateMap.clear();
-    remvoeMap.clear();
-}

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

@@ -1,2 +0,0 @@
-import type { WorldSunTaskRequest } from "../../../Contexts/Constructor/Tasks/TasksRequest";
-export declare function RunWorldSun(tasks: WorldSunTaskRequest): false | undefined;

package/Propagation/Illumanation/Functions/WorldSun.js

@@ -1,190 +0,0 @@
-//data
-import { WorldBounds } from "../../../Data/World/WorldBounds.js";
-import { WorldRegister } from "../../../Data/World/WorldRegister.js";
-import { $3dCardinalNeighbors } from "../../../Math/Constants/CardinalNeighbors.js";
-import { WorldSpaces } from "../../../Data/World/WorldSpaces.js";
-import { IlluminationManager as IM } from "../IlluminationManager.js";
-import { HeightMapTool } from "../../../Tools/Data/WorldData/HeightMapTool.js";
-const inColumnBounds = (cx, cz, x, z) => {
-    if (x >= cx &&
-        x <= cx + WorldSpaces.chunk._bounds.x &&
-        z >= cz &&
-        z <= cz + WorldSpaces.chunk._bounds.z)
-        return true;
-    return false;
-};
-class QueueNode {
-    x;
-    y;
-    z;
-    next = null;
-    constructor(x, y, z) {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-    }
-}
-class ReusableQueue {
-    head = null;
-    tail = null;
-    freeList = [];
-    enqueue(x, y, z) {
-        let node;
-        if (this.freeList.length) {
-            node = this.freeList.shift();
-            node.x = x;
-            node.y = y;
-            node.z = z;
-            node.next = null;
-        }
-        else {
-            node = new QueueNode(x, y, z);
-        }
-        if (this.tail) {
-            this.tail.next = node;
-        }
-        else {
-            this.head = node;
-        }
-        this.tail = node;
-    }
-    dequeue() {
-        if (!this.head)
-            return null;
-        const node = this.head;
-        this.head = this.head.next;
-        if (!this.head)
-            this.tail = null;
-        return node;
-    }
-    returnNode(node) {
-        this.freeList.push(node);
-    }
-    isEmpty() {
-        return this.head === null;
-    }
-}
-const queue = new ReusableQueue();
-const heightMapTool = new HeightMapTool();
-export function RunWorldSun(tasks) {
-    IM.setDimension(tasks.origin[0]);
-    tasks.start();
-    WorldRegister.instance.setDimension(tasks.origin[0]);
-    if (!WorldRegister.instance.column.get(tasks.origin[1], tasks.origin[2], tasks.origin[2]))
-        return false;
-    const [dimension, cx, cy, cz] = tasks.origin;
-    IM._sDataTool.setDimension(dimension);
-    const RmaxY = heightMapTool.column.getRelative(tasks.origin);
-    const AmaxY = heightMapTool.column.getAbsolute(tasks.origin);
-    //fill
-    for (let iy = AmaxY; iy < WorldBounds.bounds.MaxY; iy++) {
-        for (let iz = cz; iz < cz + WorldSpaces.chunk._bounds.z; iz++) {
-            for (let ix = cx; ix < cx + WorldSpaces.chunk._bounds.x; ix++) {
-                if (!IM._sDataTool.loadInAt(ix, iy, iz))
-                    continue;
-                const l = IM._sDataTool.getLight();
-                if (l < 0)
-                    continue;
-                IM._sDataTool.setLight(IM.lightData.setS(0xf, l)).commit();
-            }
-        }
-    }
-    //accumulate
-    for (let iy = AmaxY; iy <= RmaxY; iy++) {
-        for (let iz = cz; iz < cz + WorldSpaces.chunk._bounds.z; iz++) {
-            for (let ix = cx; ix < cx + WorldSpaces.chunk._bounds.x; ix++) {
-                if (!IM._sDataTool.loadInAt(ix, iy, iz))
-                    continue;
-                const l = IM._sDataTool.getLight();
-                if (l < 0 && IM.lightData.getS(l) != 0xf)
-                    continue;
-                let add = false;
-                for (const n of $3dCardinalNeighbors) {
-                    const nx = ix + n[0];
-                    const ny = iy + n[1];
-                    const nz = iz + n[2];
-                    if (IM._nDataTool.loadInAt(nx, ny, nz)) {
-                        const nl = IM._nDataTool.getLight();
-                        if (nl >= 0 && IM.lightData.getS(nl) < 0xf) {
-                            add = true;
-                            break;
-                        }
-                    }
-                }
-                if (add) {
-                    queue.enqueue(ix, iy, iz);
-                }
-            }
-        }
-    }
-    //flood
-    while (!queue.isEmpty()) {
-        const node = queue.dequeue();
-        if (!node)
-            break;
-        if (!IM._sDataTool.loadInAt(node.x, node.y, node.z))
-            continue;
-        const sl = IM._sDataTool.getLight();
-        if (sl <= 0)
-            continue;
-        const sunL = IM.lightData.getS(sl);
-        if (sunL >= 0xf && !inColumnBounds(cx, cz, node.x, node.z))
-            continue;
-        if (IM._nDataTool.loadInAt(node.x - 1, node.y, node.z)) {
-            const nl = IM._nDataTool.getLight();
-            if (nl > -1 && IM.lightData.isLessThanForSunAdd(nl, sl)) {
-                queue.enqueue(node.x - 1, node.y, node.z);
-                IM._nDataTool.setLight(IM.lightData.getMinusOneForSun(sl, nl)).commit();
-            }
-        }
-        if (IM._nDataTool.loadInAt(node.x + 1, node.y, node.z)) {
-            const nl = IM._nDataTool.getLight();
-            if (nl > -1 && IM.lightData.isLessThanForSunAdd(nl, sl)) {
-                queue.enqueue(node.x + 1, node.y, node.z);
-                IM._nDataTool.setLight(IM.lightData.getMinusOneForSun(sl, nl)).commit();
-            }
-        }
-        if (IM._nDataTool.loadInAt(node.x, node.y, node.z - 1)) {
-            const nl = IM._nDataTool.getLight();
-            if (nl > -1 && IM.lightData.isLessThanForSunAdd(nl, sl)) {
-                queue.enqueue(node.x, node.y, node.z - 1);
-                IM._nDataTool.setLight(IM.lightData.getMinusOneForSun(sl, nl)).commit();
-            }
-        }
-        if (IM._nDataTool.loadInAt(node.x, node.y, node.z + 1)) {
-            const nl = IM._nDataTool.getLight();
-            if (nl > -1 && IM.lightData.isLessThanForSunAdd(nl, sl)) {
-                queue.enqueue(node.x, node.y, node.z + 1);
-                IM._nDataTool.setLight(IM.lightData.getMinusOneForSun(sl, nl)).commit();
-            }
-        }
-        if (IM._nDataTool.loadInAt(node.x, node.y - 1, node.z)) {
-            const nl = IM._nDataTool.getLight();
-            if (nl > -1 && IM.lightData.isLessThanForSunAddDown(nl, sl)) {
-                if (IM._nDataTool.isAir()) {
-                    queue.enqueue(node.x, node.y - 1, node.z);
-                    IM._nDataTool
-                        .setLight(IM.lightData.getSunLightForUnderVoxel(sl, nl))
-                        .commit();
-                }
-                else {
-                    if (!IM._nDataTool.isOpaque()) {
-                        queue.enqueue(node.x, node.y - 1, node.z);
-                        IM._nDataTool
-                            .setLight(IM.lightData.getMinusOneForSun(sl, nl))
-                            .commit();
-                    }
-                }
-            }
-        }
-        if (IM._nDataTool.loadInAt(node.x, node.y + 1, node.z)) {
-            const nl = IM._nDataTool.getLight();
-            if (nl > -1 && IM.lightData.isLessThanForSunAdd(nl, sl)) {
-                queue.enqueue(node.x, node.y + 1, node.z);
-                IM._nDataTool.setLight(IM.lightData.getMinusOneForSun(sl, nl)).commit();
-            }
-        }
-        queue.returnNode(node);
-    }
-    tasks.stop();
-}

package/Propagation/Propagation.d.ts

@@ -1,13 +0,0 @@
-import { ExplosionTaskRequests, FlowTaskRequests, LightTaskRequest, WorldSunTaskRequest } from "../Contexts/Constructor/Tasks/TasksRequest";
-export declare class Propagation {
-    static instance: Propagation;
-    constructor();
-    explosion(tasks: ExplosionTaskRequests): void;
-    flowUpdate(tasks: FlowTaskRequests, rebuild?: boolean): Promise<void>;
-    flowRemove(tasks: FlowTaskRequests, rebuild?: boolean): Promise<void>;
-    worldSun(tasks: WorldSunTaskRequest): void;
-    rgbUpdate(tasks: LightTaskRequest): void;
-    rgbRemove(tasks: LightTaskRequest): void;
-    sunUpdate(tasks: LightTaskRequest): void;
-    sunRemove(tasks: LightTaskRequest, clearUpdateMap?: boolean): void;
-}

package/Shaders/Code/Functions/FogShaders.d.ts

@@ -1,2 +0,0 @@
-import type { URIShaderBuilder } from "@amodx/uri/Shaders/URIShaderBuilder";
-export declare function RegisterFogShaders(builder: typeof URIShaderBuilder): void;

package/Shaders/Code/Functions/FogShaders.js

@@ -1,59 +0,0 @@
-export function RegisterFogShaders(builder) {
-    builder.functions.create("ExponentialFog", {
-        setID: "#dve_fog",
-        inputs: [],
-        output: "float",
-        arguments: {},
-        body: {
-            GLSL: () => /* glsl */ `
-   float fogCoeff = 1.0;
-   //float fogDensity = fogOptions.y;
-   //fogCoeff = 1.0 / pow(E, fFogDistance * fogDensity);
-   return clamp(fogCoeff, 0.0, 1.0);`,
-        },
-    });
-    builder.functions.create("VolumetricFog", {
-        setID: "#dve_fog",
-        inputs: [],
-        output: "float",
-        arguments: {},
-        body: {
-            GLSL: () => /* glsl */ `
-   float fogDensity = fogOptions.y;
-   vec3 fogOrigin = cameraPOS;
-   vec3 fogDirection = normalize(worldPOS - fogOrigin);
-   float fogDepth = vDistance;
-   fogDepth *= mix(1.0, 1.0, clamp((fogDepth - 5000.0) / 5000.0,0.,1.));
-   fogDepth *= fogDepth;
-   float heightFactor = fogOptions.z;
-   float fogFactor = heightFactor * exp(-fogOrigin.y * fogDensity) * (
-   1.0 - exp(-fogDepth * fogDirection.y * fogDensity)) / fogDirection.y;
-   fogFactor = clamp(fogFactor,0.,1.);
-   return fogFactor;`,
-        },
-    });
-    builder.functions.create("AnimatedVolumetricFog", {
-        setID: "#dve_fog",
-        inputs: [],
-        output: "float",
-        arguments: {},
-        body: {
-            GLSL: () => /* glsl */ `
-   float fogDensity = fogOptions.y;
-   float fogTime = time * .01;
-   vec3 fogOrigin = cameraPOS;
-   vec3 fogDirection = normalize(worldPOS - fogOrigin);
-   float fogDepth = vDistance;
-   vec3 noiseSampleCoord = worldPOS * 0.00025 + vec3(
-   0.0, 0.0, fogTime * 0.025);
-   float noiseSample = fbm3(noiseSampleCoord + fbm3(noiseSampleCoord)) * 0.5 + 0.5;
-   fogDepth *= mix(noiseSample, 1.0, clamp((fogDepth - 5000.0) / 5000.0,0.,1.));
-   fogDepth *= fogDepth;
-   float heightFactor = fogOptions.z;
-   float fogFactor = heightFactor * exp(-fogOrigin.y * fogDensity) * (
-   1.0 - exp(-fogDepth * fogDirection.y * fogDensity)) / fogDirection.y;
-   fogFactor = clamp(fogFactor,0.,1.);
-   return fogFactor;`,
-        },
-    });
-}

package/Shaders/Code/Functions/FragmentFunctions.d.ts

@@ -1,2 +0,0 @@
-import type { URIShaderBuilder } from "@amodx/uri/Shaders/URIShaderBuilder";
-export declare function RegisterFragFunctions(builder: typeof URIShaderBuilder): string[];