@divinevoxel/vlox 0.0.1 → 0.0.3

package/package.json

@@ -1,30 +1,36 @@
 {
-    "name": "@divinevoxel/vlox",
-    "version": "0.0.01",
-    "description": "Vlox a block style voxel engine.",
-    "main": "index.js",
-    "types": "index.d.ts",
-    "type": "module",
-    "devDependencies": {},
-    "scripts": {},
-    "keywords": [],
-    "author": "Divine Star Software",
-    "license": "MIT",
-    "repository": {
-        "url": "git+https://github.com/Divine-Star-Software/DivineVoxelEngine.git"
-    },
-    "bugs": {
-        "url": "https://github.com/Divine-Star-Software/DivineVoxelEngine/issues"
-    },
-    "dependencies": {
-        "@amodx/uri": "^0.0.11",
-        "@amodx/meshing": "^0.0.01",
-        "@amodx/math": "^0.0.01",
-        "@amodx/binary": "^0.0.11",
-        "@amodx/threads": "^0.0.01"
-    },
-    "publishConfig": {
-        "access": "public"
-    },
-    "homepage": "https://github.com/Divine-Star-Software/DivineVoxelEngine#readme"
+  "name": "@divinevoxel/vlox",
+  "version": "0.0.03",
+  "description": "Vlox a block style voxel engine.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "type": "module",
+  "devDependencies": {},
+  "scripts": {
+    "build": "mkdir -p dist && rm -rf dist/* && cp package.json dist/package.json && cp README.md ./dist/README.md && cp ../../LICENSE.md ./dist/LICENSE.md && cd ./src && npx tsc",
+    "compile": "cd src && npx tsc --watch"
+  },
+  "keywords": [],
+  "author": "Divine Star Software",
+  "license": "MIT",
+  "repository": {
+    "url": "git+https://github.com/Divine-Star-Software/DivineVoxelEngine.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Divine-Star-Software/DivineVoxelEngine/issues"
+  },
+  "dependencies": {
+    "@amodx/meshing": "latest",
+    "@dvegames/vlox": "latest",
+    "@dvegames/vlox-tools": "latest",
+    "@amodx/math": "latest",
+    "@amodx/binary": "latest",
+    "@amodx/threads": "latest",
+    "@amodx/indexdb": "latest",
+    "@amodx/controls": "latest",
+    "@amodx/rng": "latest"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
 }

package/Analyzer/Analyzer.d.ts

@@ -1,18 +0,0 @@
-import type { AnaylzerTask } from "../Types/Tasks.types.js";
-import type { LocationData } from "../Math";
-import { DivineVoxelEngineConstructor } from "../Contexts/Constructor/DivineVoxelEngineConstructor.js";
-import { DVEAnaylzer } from "../Interfaces/Anaylzer/DVEAnaylzer.js";
-export declare class Analyzer extends DVEAnaylzer {
-    updater: {
-        _voxels: Map<string, (locaton: LocationData, deltaTime: number, anayzer: Analyzer, DVEC: DivineVoxelEngineConstructor) => void>;
-        registerVoxel(id: string, run: (locaton: LocationData, deltaTime: number, anayzer: Analyzer, DVEC: DivineVoxelEngineConstructor) => void): void;
-        getVoxel(id: string): false | ((locaton: LocationData, deltaTime: number, anayzer: Analyzer, DVEC: DivineVoxelEngineConstructor) => void);
-    };
-    processor: {
-        columnTool: import("../Tools/Data/WorldData/ColumnDataTool.js").ColumnDataTool;
-        goThroughColumn<T>(location: LocationData, run: (x: number, y: number, z: number, column: import("../Tools/Data/WorldData/ColumnDataTool.js").ColumnDataTool) => void): void;
-    };
-    _flowChecks: number[][];
-    runPropagation(data: AnaylzerTask): Promise<void>;
-    runUpdate(data: AnaylzerTask): Promise<void>;
-}

package/Analyzer/Analyzer.js

@@ -1,91 +0,0 @@
-//objects
-import { EngineSettings } from "../Data/Settings/EngineSettings.js";
-import { DivineVoxelEngineConstructor } from "../Contexts/Constructor/DivineVoxelEngineConstructor.js";
-import { AnalyzerProcessor } from "./AnalyzerProcessor.js";
-import { AnalyzerUpdater } from "./AnalyzerUpdater.js";
-import { DVEAnaylzer } from "../Interfaces/Anaylzer/DVEAnaylzer.js";
-import { DataTool } from "../Tools/Data/DataTool.js";
-import { TasksRequest } from "../Contexts/Constructor/Tasks/TasksRequest.js";
-import { Propagation } from "../Propagation/Propagation.js";
-//tools
-const mainDT = new DataTool();
-const secondaryDT = new DataTool();
-export class Analyzer extends DVEAnaylzer {
-    updater = AnalyzerUpdater;
-    processor = AnalyzerProcessor;
-    _flowChecks = [
-        [0, -1, 0],
-        [1, 0, 0],
-        [-1, 0, 0],
-        [0, 0, 1],
-        [0, 0, -1],
-    ];
-    async runPropagation(data) {
-        let t = {};
-        const options = {
-            light: EngineSettings.doLight(),
-            flow: EngineSettings.doFlow(),
-        };
-        mainDT.setDimension(data[0][0]);
-        secondaryDT.setDimension(data[0][0]);
-        const tasks = TasksRequest.getVoxelUpdateRequests(data[0], "none", "self");
-        tasks.start();
-        this.processor.goThroughColumn(data[0], (x, y, z) => {
-            if (!mainDT.loadInAt(x, y, z) || mainDT.isAir())
-                return;
-            if (options.light) {
-                if (mainDT.isLightSource()) {
-                    tasks.queues.rgb.update.push(x, y, z);
-                }
-            }
-            if (options.flow) {
-                t = {
-                    id: mainDT.getStringId(),
-                    sustance: mainDT.getSubstance(),
-                    substanceStringId: mainDT.getSubstanceStringId(),
-                };
-                if (mainDT.getSubstnaceData().isLiquid()) {
-                    let add = false;
-                    for (const check of this._flowChecks) {
-                        if (secondaryDT.loadInAt(x + check[0], y + check[1], z + check[2])) {
-                            if (secondaryDT.isAir()) {
-                                add = true;
-                                break;
-                            }
-                        }
-                    }
-                    if (add) {
-                        tasks.queues.flow.update.queue.push([x, y, z]);
-                    }
-                }
-            }
-        });
-        Propagation.instance.rgbUpdate(tasks);
-        const dimension = data[0][0];
-        for (const flowUpdate of tasks.queues.flow.update.queue) {
-            const [x, y, z] = flowUpdate;
-            if (!mainDT.loadInAt(x, y, z))
-                continue;
-            await Propagation.instance.flowUpdate(TasksRequest.getFlowUpdateRequest([dimension, x, y, z], "none", "self"), false);
-        }
-        tasks.stop();
-    }
-    async runUpdate(data) {
-        if (!this.processor.columnTool.setLocation(data[0]).loadIn())
-            return;
-        const deltaTime = Date.now() - this.processor.columnTool.getLastAnalyzerUpdateTimestamp();
-        const location = [...data[0]];
-        this.processor.goThroughColumn(data[0], (x, y, z) => {
-            if (!mainDT.loadInAt(x, y, z))
-                return;
-            location[1] = x;
-            location[2] = y;
-            location[3] = z;
-            const run = this.updater.getVoxel(mainDT.getStringId());
-            if (!run)
-                return;
-            run(location, deltaTime, this, DivineVoxelEngineConstructor.instance);
-        });
-        this.processor.columnTool.setLastAnalyzerUpdateTimestamp();
-    }
-}

package/Analyzer/AnalyzerProcessor.d.ts

@@ -1,6 +0,0 @@
-import type { LocationData } from "../Math";
-import { ColumnDataTool } from "../Tools/Data/WorldData/ColumnDataTool.js";
-export declare const AnalyzerProcessor: {
-    columnTool: ColumnDataTool;
-    goThroughColumn<T>(location: LocationData, run: (x: number, y: number, z: number, column: ColumnDataTool) => void): void;
-};

package/Analyzer/AnalyzerProcessor.js

@@ -1,39 +0,0 @@
-import { WorldSpaces } from "../Data/World/WorldSpaces.js";
-import { ColumnDataTool } from "../Tools/Data/WorldData/ColumnDataTool.js";
-import { HeightMapTool } from "../Tools/Data/WorldData/HeightMapTool.js";
-import { WorldRegister } from "../Data/World/WorldRegister.js";
-const columnTool = new ColumnDataTool();
-const heightMapTool = new HeightMapTool();
-export const AnalyzerProcessor = {
-    columnTool: columnTool,
-    goThroughColumn(location, run) {
-        if (!columnTool.setLocation(location).loadIn())
-            return;
-        WorldRegister.instance.cache.enable();
-        const column = columnTool.getColumn();
-        let maxX = WorldSpaces.chunk._bounds.x + location[1];
-        let maxZ = WorldSpaces.chunk._bounds.z + location[3];
-        for (let i = 0; i < column.chunks.length; i++) {
-            const chunk = column.chunks[i];
-            if (!chunk)
-                continue;
-            heightMapTool.chunk.setChunk(chunk);
-            const [cx, cy, cz] = [
-                location[1],
-                location[2] + i * WorldSpaces.chunk.getHeight(),
-                location[3],
-            ];
-            let [minY, maxY] = heightMapTool.chunk.getMinMax();
-            minY += cy;
-            maxY += cy + 1;
-            for (let y = minY; y < maxY; y += 1) {
-                for (let z = cz; z < maxZ; z += 1) {
-                    for (let x = cx; x < maxX; x += 1) {
-                        run(x, y, z, columnTool);
-                    }
-                }
-            }
-        }
-        WorldRegister.instance.cache.disable();
-    },
-};

package/Contexts/Constructor/ConstructorTasks.d.ts

@@ -1,2 +0,0 @@
-import { DivineVoxelEngineConstructor } from "./DivineVoxelEngineConstructor.js";
-export default function (DVEC: DivineVoxelEngineConstructor): void;

package/Contexts/Constructor/ConstructorTasks.js

@@ -1,82 +0,0 @@
-import { ConstructorTasksIds } from "./ConstructorTasksIds.js";
-import { Threads } from "@amodx/threads/";
-import { WorldRegister } from "../../Data/World/WorldRegister.js";
-import { WorldSpaces } from "../../Data/World/WorldSpaces.js";
-import { EreaseAndUpdate, PaintAndUpdate, VoxelUpdate, } from "./Tasks/VoxelUpdate.js";
-import { TasksRequest } from "./Tasks/TasksRequest.js";
-import { Propagation } from "../../Propagation";
-import { Analyzer } from "../../Analyzer/Analyzer";
-export default function (DVEC) {
-    Threads.registerTasks("clear-all", () => {
-        WorldRegister.instance.clearAll();
-    });
-    const propagation = new Propagation();
-    const analyzer = new Analyzer();
-    Threads.registerTasks(ConstructorTasksIds.VoxelUpdate, async (data, onDone) => {
-        await VoxelUpdate(data);
-        if (onDone)
-            onDone();
-    }, "deferred");
-    Threads.registerTasks(ConstructorTasksIds.VoxelErease, async (data, onDone) => {
-        await EreaseAndUpdate(data);
-        if (onDone)
-            onDone();
-    }, "deferred");
-    Threads.registerTasks(ConstructorTasksIds.VoxelPaint, async (data, onDone) => {
-        await PaintAndUpdate(data);
-        if (onDone)
-            onDone();
-    }, "deferred");
-    Threads.registerTasks(ConstructorTasksIds.Explosion, async (data) => {
-        await propagation.explosion(TasksRequest.getExplosionRequests(data[0], data[1], data[2], data[3]));
-    });
-    Threads.registerTasks(ConstructorTasksIds.WorldSun, (data, onDone) => {
-        propagation.worldSun(TasksRequest.getWorldSunRequests(data[0], data[1]));
-        if (onDone)
-            onDone();
-    }, "deferred");
-    Threads.registerTasks(ConstructorTasksIds.AnalyzerPropagation, async (data, onDone) => {
-        await analyzer.runPropagation(data);
-        if (onDone)
-            onDone();
-    }, "deferred");
-    Threads.registerTasks(ConstructorTasksIds.AnalyzerUpdate, async (data, onDone) => {
-        await analyzer.runUpdate(data);
-        if (onDone)
-            onDone();
-    }, "deferred");
-    Threads.registerTasks(ConstructorTasksIds.BuildChunk, async (buildData, onDone) => {
-        WorldRegister.instance.cache.enable();
-        const location = buildData.data[0];
-        await DVEC.mesher.meshChunk(location, buildData.data[1], 0);
-        if (onDone)
-            onDone();
-        WorldRegister.instance.cache.disable();
-    });
-    Threads.registerTasks(ConstructorTasksIds.BuildColumn, async (data, onDone) => {
-        WorldRegister.instance.setDimension(data[0][0]);
-        const column = WorldRegister.instance.column.get(data[0][1], data[0][2], data[0][2]);
-        if (!column) {
-            console.warn("Tried building a column that does not exists.", data);
-            return false;
-        }
-        if (column.chunks.length == 0)
-            return false;
-        const location = data[0];
-        WorldRegister.instance.cache.enable();
-        for (let i = 0; i < column.chunks.length; i++) {
-            const chunk = column.chunks[i];
-            if (!chunk)
-                continue;
-            DVEC.mesher.meshChunk([
-                location[0],
-                location[1],
-                location[2] + i * WorldSpaces.chunk.getHeight(),
-                location[3],
-            ], 1, 100);
-        }
-        if (onDone)
-            onDone();
-        WorldRegister.instance.cache.disable();
-    }, "deferred");
-}

package/Contexts/Constructor/ConstructorTasksIds.js

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

package/Contexts/Constructor/ConstructorThreadState.d.ts

@@ -1,5 +0,0 @@
-import { ThreadState } from "../../Interfaces/Classes/ThreadState";
-export declare class ConstructorThreadState extends ThreadState {
-    environment: string;
-    isReady(): boolean;
-}

package/Contexts/Constructor/ConstructorThreadState.js

@@ -1,16 +0,0 @@
-import { Environment } from "@amodx/core/Environment/Environment.js";
-import { ConstructorThreadManager } from "./ConstrcutorTheads";
-import { ThreadState } from "../../Interfaces/Classes/ThreadState";
-export class ConstructorThreadState extends ThreadState {
-    environment = Environment.nodeJS.isNode ? "node" : "brwoser";
-    isReady() {
-        if (this.environment == "node") {
-            return (ConstructorThreadManager.instnace.world.isPortSet() &&
-                this.settingsSynced);
-        }
-        else {
-            return (ConstructorThreadManager.instnace.world.isPortSet() &&
-                this.settingsSynced);
-        }
-    }
-}

package/Contexts/Constructor/InitWorker.d.ts

@@ -1,2 +0,0 @@
-import { DivineVoxelEngineConstructor } from "./DivineVoxelEngineConstructor.js";
-export default function (DVEC: DivineVoxelEngineConstructor): Promise<void>;

package/Contexts/Constructor/InitWorker.js

@@ -1,20 +0,0 @@
-import { DivineVoxelEngineConstructor } from "./DivineVoxelEngineConstructor.js";
-import { Threads } from "@amodx/threads/";
-import { CreatePromiseCheck } from "@amodx/core/Intervals/CreatePromiseCheck.js";
-export default async function (DVEC) {
-    let parent = "render";
-    if (DivineVoxelEngineConstructor.environment == "node") {
-        parent = "server";
-    }
-    await Threads.init("constructor", parent);
-    DVEC.TC.registerTasks("thread-ready", () => { });
-    DVEC.mesher.init();
-    await CreatePromiseCheck({
-        check: () => {
-            return DVEC.threads.state.isReady();
-        },
-        onReady() { },
-        checkInterval: 1,
-    });
-    DVEC.TC.registerTasks("ready", () => { });
-}

package/Contexts/Constructor/Tasks/TasksRequest.d.ts

@@ -1,141 +0,0 @@
-import type { LocationData } from "../../../Math";
-import type { AddToRebuildQueue, BuildTasks, Priorities, PriorityTask } from "../../../Types/Tasks.types";
-import { Thread } from "@amodx/threads/";
-import { VisitedMap } from "../../../Util/VisistedMap";
-import { Vec3Array } from "@amodx/math";
-type RebuildModes = "sync" | "async";
-declare class Request<T, Q> {
-    tasksType: string;
-    origin: LocationData;
-    data: T;
-    buildQueue: string;
-    originThread: string;
-    queues: Q;
-    rebuildQueMap: Map<string, boolean>;
-    comm: Thread;
-    priority: Priorities;
-    LOD: number;
-    syncQueue: LocationData[];
-    aSyncQueue: LocationData[];
-    buildMode: RebuildModes;
-    buildTasks: PriorityTask<BuildTasks>;
-    trackedChunks: Map<string, Vec3Array>;
-    keepTrackOfChunks: boolean;
-    rebuildTasks: AddToRebuildQueue;
-    constructor(tasksType: string, origin: LocationData, data: T, buildQueue: string, originThread: string, queues: Q);
-    start(): this;
-    stop(): this;
-    setPriority(priority: Priorities): this;
-    getData(): T;
-    getOriginThread(): LocationData;
-    getBuildQueue(): string;
-    getOrigin(): LocationData;
-    needsRebuild(): boolean;
-    needsToUpdateOriginThread(): boolean;
-    clearBuildQueue(): void;
-    setBuldMode(mode: RebuildModes): this;
-    addToRebuildQueue(x: number, y: number, z: number): boolean;
-    addNeighborsToRebuildQueue(x: number, y: number, z: number): false | this | undefined;
-    runRebuildQueue(): this;
-    clear(): void;
-}
-type ArrayOfVec3Arrays = [x: number, y: number, z: number][];
-type FlowVec3Array = number[][];
-export declare const TasksRequest: {
-    getLightUpdateRequest(origin: LocationData, buildQueue?: string, originThread?: string): Request<any, {
-        rgb: {
-            update: number[];
-            remove: number[];
-            map: VisitedMap;
-        };
-        sun: {
-            update: number[];
-            remove: number[];
-            updateMap: VisitedMap;
-            remvoeMap: VisitedMap;
-        };
-    }>;
-    getFlowUpdateRequest(origin: LocationData, buildQueue?: string, originThread?: string): Request<null, {
-        flow: {
-            update: {
-                queue: FlowVec3Array;
-                map: VisitedMap;
-            };
-            remove: {
-                queue: FlowVec3Array;
-                map: VisitedMap;
-                noRemoveMap: VisitedMap;
-            };
-        };
-        rgb: {
-            update: number[];
-            remove: number[];
-            map: VisitedMap;
-        };
-        sun: {
-            update: number[];
-            remove: number[];
-            updateMap: VisitedMap;
-            remvoeMap: VisitedMap;
-        };
-    }>;
-    getVoxelUpdateRequests(origin: LocationData, buildQueue?: string, originThread?: string): Request<null, {
-        flow: {
-            update: {
-                queue: FlowVec3Array;
-                map: VisitedMap;
-            };
-            remove: {
-                queue: FlowVec3Array;
-                map: VisitedMap;
-                noRemoveMap: VisitedMap;
-            };
-        };
-        rgb: {
-            update: number[];
-            remove: number[];
-            map: VisitedMap;
-        };
-        sun: {
-            update: number[];
-            remove: number[];
-            updateMap: VisitedMap;
-            remvoeMap: VisitedMap;
-        };
-    }>;
-    getWorldSunRequests(origin: LocationData, buildQueue?: string, originThread?: string): Request<null, {
-        sun: number[];
-    }>;
-    getExplosionRequests(origin: LocationData, radius: number, buildQueue?: string, originThread?: string): Request<number, {
-        flow: {
-            update: {
-                queue: FlowVec3Array;
-                map: VisitedMap;
-            };
-            remove: {
-                queue: FlowVec3Array;
-                map: VisitedMap;
-                noRemoveMap: VisitedMap;
-            };
-        };
-        rgb: {
-            update: number[];
-            remove: number[];
-            map: VisitedMap;
-        };
-        sun: {
-            update: number[];
-            remove: number[];
-            updateMap: VisitedMap;
-            remvoeMap: VisitedMap;
-        };
-        queue: ArrayOfVec3Arrays;
-        map: VisitedMap;
-    }>;
-};
-export type ExplosionTaskRequests = ReturnType<typeof TasksRequest.getExplosionRequests>;
-export type VoxelUpdateTaskRequest = ReturnType<typeof TasksRequest.getVoxelUpdateRequests>;
-export type FlowTaskRequests = ReturnType<typeof TasksRequest.getFlowUpdateRequest>;
-export type LightTaskRequest = ReturnType<typeof TasksRequest.getLightUpdateRequest>;
-export type WorldSunTaskRequest = ReturnType<typeof TasksRequest.getWorldSunRequests>;
-export {};