@divinevoxel/vlox 0.0.2 → 0.0.4

package/{Propagation → Tasks/Propagation}/Illumanation/IlluminationManager.js

@@ -1,6 +1,6 @@
 //functions
-import { DataTool } from "../../Tools/Data/DataTool.js";
-import { LightData } from "../../Data/LightData.js";
+import { DataTool } from "../../../Tools/Data/DataTool.js";
+import { LightData } from "../../../Voxels/LightData.js";
 export const IlluminationManager = {
     lightData: LightData,
     //tools

package/Tasks/Propagation/InitTasks.d.ts

@@ -0,0 +1 @@
+export default function InitTasks(): void;

package/Tasks/Propagation/InitTasks.js

@@ -0,0 +1,23 @@
+import { Threads } from "@amodx/threads";
+import { TasksIds } from "../TasksIds";
+import { UpdateTask } from "../Update/UpdateTask";
+import { PaintAndUpdate } from "../Update/VoxelUpdate";
+import { Propagation } from "./Propagation";
+export default function InitTasks() {
+    const propagation = new Propagation();
+    Threads.registerTasks(TasksIds.VoxelPaint, async (data, onDone) => {
+        await PaintAndUpdate(data);
+        if (onDone)
+            onDone();
+    }, "deferred");
+    Threads.registerTasks(TasksIds.Explosion, async (data) => {
+        await propagation.explosion(new UpdateTask(), data[1]);
+    });
+    Threads.registerTasks(TasksIds.WorldSun, (data, onDone) => {
+        const task = new UpdateTask();
+        task.setOrigin(data[0]);
+        propagation.worldSun(task);
+        if (onDone)
+            onDone();
+    }, "deferred");
+}

package/Tasks/Propagation/Propagation.d.ts

@@ -0,0 +1,13 @@
+import { UpdateTask } from "../Update/UpdateTask.js";
+export declare class Propagation {
+    static instance: Propagation;
+    constructor();
+    explosion(tasks: UpdateTask, radius: number): void;
+    flowUpdate(tasks: UpdateTask, rebuild?: boolean): Promise<void>;
+    flowRemove(tasks: UpdateTask, rebuild?: boolean): Promise<void>;
+    worldSun(tasks: UpdateTask): void;
+    rgbUpdate(tasks: UpdateTask): void;
+    rgbRemove(tasks: UpdateTask): void;
+    sunUpdate(tasks: UpdateTask): void;
+    sunRemove(tasks: UpdateTask, clearUpdateMap?: boolean): void;
+}

package/{Propagation → Tasks/Propagation}/Propagation.js

@@ -1,3 +1,4 @@
+//objects
 import { RGBRemove, RGBUpdate } from "./Illumanation/Functions/RGBUpdate.js";
 import { SunRemove, SunUpdate } from "./Illumanation/Functions/SunUpdate.js";
 import { RunWorldSun } from "./Illumanation/Functions/WorldSun.js";
@@ -10,8 +11,8 @@ export class Propagation {
         if (!Propagation.instance)
             Propagation.instance = this;
     }
-    explosion(tasks) {
-        ExplosionManager.runExplosion(tasks);
+    explosion(tasks, radius) {
+        ExplosionManager.runExplosion(tasks, radius);
     }
     async flowUpdate(tasks, rebuild = true) {
         await FlowUpdate(tasks, rebuild);

package/{Types → Tasks}/Tasks.types.d.ts

@@ -1,6 +1,6 @@
 import type { LocationData } from "../Math/index.js";
 import type { Vec3Array } from "@amodx/math";
-import type { RawVoxelData } from "../Data/Types/VoxelData.types";
+import type { RawVoxelData } from "../Voxels/Voxel.types.js";
 import { ChunkData, ColumnData, RegionData } from "Data/World/Classes";
 export type Priorities = 0 | 1 | 2 | 3;
 export type PriorityTask<T> = {
@@ -36,6 +36,7 @@ export type AddToRebuildQueue = [
     priority: Priorities
 ];
 export type RunRebuildTasks = [buildQueue: string];
+export type RunBuildQueue = [dimension: string, chunks: Vec3Array[]];
 export type BuildTasks = [location: LocationData, LOD: number];
 export type GenerateTasks = [location: LocationData, data: any];
 export type ExplosionTasks = [

package/{Contexts/Constructor/Tasks/ConstructorTasksIds.d.ts → Tasks/TasksIds.d.ts}

@@ -1,4 +1,4 @@
-export declare enum ConstructorTasksIds {
+export declare enum TasksIds {
     BuildChunk = 0,
     BuildColumn = 1,
     Generate = 2,

package/Tasks/TasksIds.js

@@ -0,0 +1,22 @@
+export var TasksIds;
+(function (TasksIds) {
+    TasksIds[TasksIds["BuildChunk"] = 0] = "BuildChunk";
+    TasksIds[TasksIds["BuildColumn"] = 1] = "BuildColumn";
+    TasksIds[TasksIds["Generate"] = 2] = "Generate";
+    TasksIds[TasksIds["Decorate"] = 3] = "Decorate";
+    TasksIds[TasksIds["RGBlightUpdate"] = 4] = "RGBlightUpdate";
+    TasksIds[TasksIds["RGBlightRemove"] = 5] = "RGBlightRemove";
+    TasksIds[TasksIds["WorldSun"] = 6] = "WorldSun";
+    TasksIds[TasksIds["SunLightUpdate"] = 7] = "SunLightUpdate";
+    TasksIds[TasksIds["SunLightRemove"] = 8] = "SunLightRemove";
+    TasksIds[TasksIds["AnalyzerPropagation"] = 9] = "AnalyzerPropagation";
+    TasksIds[TasksIds["AnalyzerUpdate"] = 10] = "AnalyzerUpdate";
+    TasksIds[TasksIds["FlowUpdate"] = 11] = "FlowUpdate";
+    TasksIds[TasksIds["FlowRemove"] = 12] = "FlowRemove";
+    TasksIds[TasksIds["ConstructEntity"] = 13] = "ConstructEntity";
+    TasksIds[TasksIds["ConstructItem"] = 14] = "ConstructItem";
+    TasksIds[TasksIds["Explosion"] = 15] = "Explosion";
+    TasksIds[TasksIds["VoxelErease"] = 16] = "VoxelErease";
+    TasksIds[TasksIds["VoxelPaint"] = 17] = "VoxelPaint";
+    TasksIds[TasksIds["VoxelUpdate"] = 18] = "VoxelUpdate";
+})(TasksIds || (TasksIds = {}));

package/Tasks/Update/InitTasks.d.ts

@@ -0,0 +1,4 @@
+import { UpdateTask } from "./UpdateTask";
+export default function (props: {
+    onDone(taks: UpdateTask): void;
+}): void;

package/Tasks/Update/InitTasks.js

@@ -0,0 +1,38 @@
+import { Threads } from "@amodx/threads";
+import { TasksIds } from "../TasksIds";
+import { VoxelUpdate, EreaseAndUpdate, PaintAndUpdate } from "./VoxelUpdate";
+export default function (props) {
+    Threads.registerTasks(TasksIds.VoxelUpdate, async (data, onDone) => {
+        const tasks = await VoxelUpdate(data);
+        if (!tasks) {
+            if (onDone)
+                onDone();
+            return;
+        }
+        props.onDone(tasks);
+        if (onDone)
+            onDone();
+    }, "deferred");
+    Threads.registerTasks(TasksIds.VoxelErease, async (data, onDone) => {
+        const tasks = await EreaseAndUpdate(data);
+        if (!tasks) {
+            if (onDone)
+                onDone();
+            return;
+        }
+        props.onDone(tasks);
+        if (onDone)
+            onDone();
+    }, "deferred");
+    Threads.registerTasks(TasksIds.VoxelPaint, async (data, onDone) => {
+        const tasks = await PaintAndUpdate(data);
+        if (!tasks) {
+            if (onDone)
+                onDone();
+            return;
+        }
+        props.onDone(tasks);
+        if (onDone)
+            onDone();
+    }, "deferred");
+}

package/Tasks/Update/UpdateTask.d.ts

@@ -0,0 +1,53 @@
+import { WorldCursor } from "../../Data/Cursor/World/WorldCursor";
+import { Vec3Array, Vector3Like } from "@amodx/math";
+import { LocationData } from "../../Math";
+export declare class TaskMap {
+    _map: boolean[];
+    get size(): number;
+    origin: Vector3Like;
+    start(x: number, y: number, z: number): void;
+    has(x: number, y: number, z: number): boolean;
+    add(x: number, y: number, z: number): void;
+    delete(x: number, y: number, z: number): void;
+    clear(): void;
+}
+declare class UpdatedBounds {
+    _task: UpdateTask;
+    min: Vector3Like;
+    max: Vector3Like;
+    constructor(_task: UpdateTask);
+    reset(): void;
+    update(x: number, y: number, z: number): void;
+    getChunks(): Vec3Array[];
+}
+export declare class UpdateTask {
+    flow: FlowQueues;
+    rgb: LightQueue;
+    sun: LightQueue;
+    bounds: UpdatedBounds;
+    sDataCursor: WorldCursor;
+    nDataCursor: WorldCursor;
+    origin: LocationData;
+    setOrigin(origin: LocationData): void;
+    clear(): void;
+}
+declare class FlowQueues {
+    update: {
+        queue: number[][];
+        map: TaskMap;
+    };
+    remove: {
+        queue: number[][];
+        map: TaskMap;
+        noRemoveMap: TaskMap;
+    };
+    clear(): void;
+}
+declare class LightQueue {
+    update: number[];
+    remove: number[];
+    removeMap: TaskMap;
+    updateMap: TaskMap;
+    clear(): void;
+}
+export {};

package/Tasks/Update/UpdateTask.js

@@ -0,0 +1,136 @@
+import { WorldCursor } from "../../Data/Cursor/World/WorldCursor";
+import { Vector3Like } from "@amodx/math";
+import { WorldSpaces } from "../../Data/World/WorldSpaces";
+export class TaskMap {
+    _map = [];
+    get size() {
+        return this._map.length;
+    }
+    origin = Vector3Like.Create();
+    start(x, y, z) {
+        this._map.length = 0;
+        this.origin.x = x;
+        this.origin.y = y;
+        this.origin.z = z;
+    }
+    has(x, y, z) {
+        return (this._map[Vector3Like.HashXYZ(x - this.origin.x, y - this.origin.y, z - this.origin.z)] !== undefined);
+    }
+    add(x, y, z) {
+        this._map[Vector3Like.HashXYZ(x - this.origin.x, y - this.origin.y, z - this.origin.z)] = true;
+    }
+    delete(x, y, z) {
+        //@ts-ignore
+        this._map[Vector3Like.HashXYZ(x - this.origin.x, y - this.origin.y, z - this.origin.z)] = undefined;
+    }
+    clear() {
+        this._map.length = 0;
+    }
+}
+const NegativeInfinityVec3 = Vector3Like.Create(-Infinity, -Infinity, -Infinity);
+const InfinityVec3 = Vector3Like.Create(Infinity, Infinity, Infinity);
+class UpdatedBounds {
+    _task;
+    min = Vector3Like.Clone(InfinityVec3);
+    max = Vector3Like.Clone(NegativeInfinityVec3);
+    constructor(_task) {
+        this._task = _task;
+    }
+    reset() {
+        Vector3Like.Copy(this.min, InfinityVec3);
+        Vector3Like.Copy(this.max, NegativeInfinityVec3);
+    }
+    update(x, y, z) {
+        if (x < this.min.x)
+            this.min.x = x;
+        if (y < this.min.y)
+            this.min.y = y;
+        if (z < this.min.z)
+            this.min.z = z;
+        if (x > this.max.x)
+            this.max.x = x;
+        if (y > this.max.y)
+            this.max.y = y;
+        if (z > this.max.z)
+            this.max.z = z;
+    }
+    getChunks() {
+        const minChunkPos = WorldSpaces.chunk.getPositionXYZ(this.min.x - 1, this.min.y - 1, this.min.z - 1);
+        const minX = minChunkPos.x;
+        const minY = minChunkPos.y;
+        const minZ = minChunkPos.z;
+        const maxChunkPos = WorldSpaces.chunk.getPositionXYZ(this.max.x + 1, this.max.y + 1, this.max.z + 1);
+        const maxX = maxChunkPos.x;
+        const maxY = maxChunkPos.y;
+        const maxZ = maxChunkPos.z;
+        const chunkPositions = [];
+        for (let x = minX; x <= maxX; x += WorldSpaces.chunk._bounds.x) {
+            for (let y = minY; y <= maxY; y += WorldSpaces.chunk._bounds.y) {
+                for (let z = minZ; z <= maxZ; z += WorldSpaces.chunk._bounds.z) {
+                    if (!this._task.nDataCursor.inBounds(x, y, z))
+                        continue;
+                    chunkPositions.push([x, y, z]);
+                }
+            }
+        }
+        return chunkPositions;
+    }
+}
+export class UpdateTask {
+    flow = new FlowQueues();
+    rgb = new LightQueue();
+    sun = new LightQueue();
+    bounds = new UpdatedBounds(this);
+    sDataCursor = new WorldCursor();
+    nDataCursor = new WorldCursor();
+    origin;
+    setOrigin(origin) {
+        this.sDataCursor.setFocalPoint(...origin);
+        this.nDataCursor.setFocalPoint(...origin);
+        this.origin = origin;
+        this.rgb.removeMap.start(origin[1], origin[2], origin[3]);
+        this.sun.removeMap.start(origin[1], origin[2], origin[3]);
+        this.rgb.updateMap.start(origin[1], origin[2], origin[3]);
+        this.sun.updateMap.start(origin[1], origin[2], origin[3]);
+        this.flow.update.map.start(origin[1], origin[2], origin[3]);
+        this.flow.remove.map.start(origin[1], origin[2], origin[3]);
+        this.flow.remove.noRemoveMap.start(origin[1], origin[2], origin[3]);
+        this.clear();
+    }
+    clear() {
+        this.rgb.clear();
+        this.sun.clear();
+        this.flow.clear();
+        this.bounds.reset();
+    }
+}
+class FlowQueues {
+    update = {
+        queue: [],
+        map: new TaskMap(),
+    };
+    remove = {
+        queue: [],
+        map: new TaskMap(),
+        noRemoveMap: new TaskMap(),
+    };
+    clear() {
+        this.update.queue.length = 0;
+        this.update.map.clear();
+        this.remove.queue.length = 0;
+        this.remove.map.clear();
+        this.remove.noRemoveMap.clear();
+    }
+}
+class LightQueue {
+    update = [];
+    remove = [];
+    removeMap = new TaskMap();
+    updateMap = new TaskMap();
+    clear() {
+        this.update.length = 0;
+        this.remove.length = 0;
+        this.removeMap.clear();
+        this.updateMap.clear();
+    }
+}

package/{Contexts/Constructor/Tasks → Tasks/Update}/VoxelUpdate.d.ts

@@ -1,4 +1,5 @@
-import { UpdateTasks, VoxelUpdateTasks } from "Types/Tasks.types";
-export declare function EreaseAndUpdate(data: UpdateTasks): Promise<boolean>;
-export declare function PaintAndUpdate(data: VoxelUpdateTasks): Promise<false | undefined>;
-export declare function VoxelUpdate(data: VoxelUpdateTasks): Promise<false | undefined>;
+import { UpdateTasks, VoxelUpdateTasks } from "../Tasks.types.js";
+import { UpdateTask } from "./UpdateTask.js";
+export declare function EreaseAndUpdate(data: UpdateTasks): Promise<false | UpdateTask>;
+export declare function PaintAndUpdate(data: VoxelUpdateTasks): Promise<false | UpdateTask>;
+export declare function VoxelUpdate(data: VoxelUpdateTasks): Promise<false | UpdateTask>;

package/Tasks/Update/VoxelUpdate.js

@@ -0,0 +1,164 @@
+import { EngineSettings as ES } from "../../Settings/EngineSettings.js";
+import { $3dCardinalNeighbors } from "../../Math/Constants/CardinalNeighbors.js";
+import { Propagation } from "../../Tasks/Propagation/Propagation.js";
+import { UpdateTask } from "./UpdateTask.js";
+import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
+const tasks = new UpdateTask();
+const substanceData = new SubstanceDataTool();
+const updateLightTask = (tasks) => {
+    let doRGB = ES.doRGBPropagation();
+    let doSun = ES.doSunPropagation();
+    const [dimension, x, y, z] = tasks.origin;
+    tasks.nDataCursor.setFocalPoint(dimension, x, y, z);
+    for (const n of $3dCardinalNeighbors) {
+        const nx = n[0] + x;
+        const ny = n[1] + y;
+        const nz = n[2] + z;
+        const nVoxel = tasks.nDataCursor.getVoxel(nx, ny, nz);
+        if (!nVoxel)
+            continue;
+        if (doRGB) {
+            if (nVoxel.hasRGBLight()) {
+                tasks.rgb.update.push(nx, ny, nz);
+            }
+        }
+        if (doSun) {
+            if (nVoxel.hasSunLight()) {
+                tasks.sun.update.push(nx, ny, nz);
+            }
+        }
+    }
+};
+export async function EreaseAndUpdate(data) {
+    const [dimension, x, y, z] = data[0];
+    tasks.setOrigin(data[0]);
+    let voxel = tasks.sDataCursor.getVoxel(x, y, z);
+    if (!voxel)
+        return false;
+    substanceData.setSubstance(voxel.getSubstance());
+    if (!voxel.isAir() && ES.doFlow() && voxel.isRenderable()) {
+        if (substanceData.isLiquid()) {
+            await Propagation.instance.flowRemove(tasks);
+            return tasks;
+        }
+    }
+    voxel = tasks.sDataCursor.getVoxel(x, y, z);
+    const light = voxel.getLight();
+    const isLightSource = voxel.isLightSource();
+    voxel.setSecondary(true).setId(0).setSecondary(false);
+    voxel
+        .setLight(light > 0 ? light : 0)
+        .setId(0)
+        .setLevel(0)
+        .setLevelState(0)
+        .setShapeState(0)
+        .setMod(0)
+        .updateHeightMap(1);
+    if (ES.doLight()) {
+        if (ES.doRGBPropagation() && isLightSource) {
+            tasks.rgb.remove.push(x, y, z);
+            Propagation.instance.rgbRemove(tasks);
+        }
+        updateLightTask(tasks);
+        if (ES.doRGBPropagation()) {
+            Propagation.instance.rgbUpdate(tasks);
+        }
+        if (ES.doSunPropagation()) {
+            Propagation.instance.sunUpdate(tasks);
+        }
+    }
+    return tasks;
+}
+export async function PaintAndUpdate(data) {
+    const [dimension, x, y, z] = data[0];
+    tasks.setOrigin(data[0]);
+    let voxel = tasks.sDataCursor.getVoxel(x, y, z);
+    if (!voxel)
+        return false;
+    const raw = data[1];
+    const isOpaque = voxel.isOpaque();
+    let doRGB = ES.doRGBPropagation();
+    let doSun = ES.doSunPropagation();
+    lighttest: if (ES.doLight()) {
+        const light = voxel.getLight();
+        if (light <= 0)
+            break lighttest;
+        if (doSun) {
+            if (voxel.hasSunLight()) {
+                tasks.sun.remove.push(x, y, z);
+                Propagation.instance.sunRemove(tasks);
+            }
+        }
+        if (doRGB) {
+            if (voxel.hasRGBLight() && isOpaque) {
+                tasks.rgb.remove.push(x, y, z);
+                Propagation.instance.rgbRemove(tasks);
+            }
+        }
+    }
+    voxel = tasks.sDataCursor.getVoxel(x, y, z);
+    const id = raw[0];
+    if (id < 0)
+        return false;
+    voxel.setId(id);
+    voxel.setShapeState(raw[2]);
+    const substance = voxel.getSubstance();
+    if (substance > -1 && !voxel.isAir()
+        ? substanceData.setSubstance(voxel.getSubstance()).isLiquid()
+        : false) {
+        voxel.setLevel(7);
+    }
+    voxel.setMod(raw[4]);
+    if (raw[3] > 0 && voxel.canHaveSecondaryVoxel()) {
+        voxel.setSecondary(true);
+        voxel.setId(raw[3]);
+        voxel.setSecondary(false);
+    }
+    if (voxel.isLightSource() && voxel.getLightSourceValue()) {
+        voxel.setLight(voxel.getLightSourceValue());
+    }
+    voxel.updateHeightMap(0);
+    if (ES.doLight()) {
+        updateLightTask(tasks);
+        if (doRGB) {
+            tasks.rgb.update.push(x, y, z);
+            Propagation.instance.rgbUpdate(tasks);
+        }
+        if (doSun) {
+            Propagation.instance.sunUpdate(tasks);
+        }
+    }
+    voxel = tasks.sDataCursor.getVoxel(x, y, z);
+    if (ES.doFlow()) {
+        if (!voxel.isAir() &&
+            substanceData.setSubstance(voxel.getSubstance()).isLiquid()) {
+            Propagation.instance.flowUpdate(tasks);
+        }
+    }
+    return tasks;
+}
+export async function VoxelUpdate(data) {
+    const [dimension, x, y, z] = data[0];
+    tasks.setOrigin(data[0]);
+    const voxel = tasks.sDataCursor.getVoxel(x, y, z);
+    if (!voxel)
+        return false;
+    let doRGB = ES.doRGBPropagation();
+    let doSun = ES.doSunPropagation();
+    if (ES.doLight()) {
+        updateLightTask(tasks);
+        if (doRGB) {
+            tasks.rgb.update.push(x, y, z);
+            Propagation.instance.rgbUpdate(tasks);
+        }
+        if (doSun) {
+            Propagation.instance.sunUpdate(tasks);
+        }
+    }
+    if (ES.doFlow()) {
+        if (substanceData.setSubstance(voxel.getSubstance()).isLiquid()) {
+            Propagation.instance.flowUpdate(tasks);
+        }
+    }
+    return tasks;
+}

package/Tasks/WorldGeneration/InitTasks.d.ts

@@ -0,0 +1 @@
+export default function (): void;

package/Tasks/WorldGeneration/InitTasks.js

@@ -0,0 +1,15 @@
+import { Threads } from "@amodx/threads";
+import { WorldGeneration } from "./WorldGeneration";
+import { TasksIds } from "../../Tasks/TasksIds";
+export default function () {
+    Threads.registerTasks(TasksIds.Generate, (data, onDone) => {
+        if (!onDone)
+            return;
+        WorldGeneration.generate(data, "generate", onDone);
+    }, "deferred");
+    Threads.registerTasks(TasksIds.Decorate, (data, onDone) => {
+        if (!onDone)
+            return;
+        WorldGeneration.generate(data, "decorate", onDone);
+    }, "deferred");
+}

package/{Interfaces/WorldGen → Tasks/WorldGeneration}/WorldGen.types.d.ts

@@ -1,4 +1,4 @@
-import { GenerateTasks } from "../../Types/Tasks.types";
+import { GenerateTasks } from "../Tasks.types";
 export type WorldGenInterface = {
     generate(data: GenerateTasks): Promise<any | void>;
     decorate(data: GenerateTasks): Promise<any | void>;

package/Tasks/WorldGeneration/WorldGenBrush.d.ts

@@ -0,0 +1,16 @@
+import type { Vec3Array } from "@amodx/math";
+import { BrushTool } from "../../Tools/Brush/Brush.js";
+import { UpdateTask } from "../Update/UpdateTask.js";
+export declare class WorldGenBrush extends BrushTool {
+    constructor();
+    requestsId: "";
+    tasks: UpdateTask;
+    start(dimension: string, x: number, y: number, z: number): this;
+    paint(): this;
+    getUpdatedChunks(): Vec3Array[];
+    update(): false | undefined;
+    erase(): this;
+    runUpdates(): void;
+    worldAlloc(start: Vec3Array, end: Vec3Array): Promise<boolean>;
+    worldDealloc(start: Vec3Array, end: Vec3Array): Promise<boolean>;
+}