@divinevoxel/vlox 0.0.0

package/Tools/Tasks/TasksTool.d.ts

@@ -0,0 +1,92 @@
+import { BuildTasks, GenerateTasks, Priorities } from "../../Types/Tasks.types.js";
+import { LocationData } from "../../Math";
+import type { RawVoxelData } from "../../Data/Types/VoxelData.types.js";
+export type TaskRunModes = "async" | "sync";
+export declare class TaskTool {
+    _data: {
+        dimension: string;
+        queue: string;
+    };
+    _thread: string;
+    _priority: Priorities;
+    constructor();
+    setPriority(priority: Priorities): this;
+    setFocalPoint(location: LocationData): this;
+    voxelUpdate: {
+        update: {
+            run: (location: LocationData, raw: RawVoxelData, onDone: (data: any) => void, mode?: TaskRunModes) => void;
+        };
+        erase: {
+            run: (location: LocationData, onDone: (data: any) => void, mode?: TaskRunModes) => void;
+        };
+        paint: {
+            run: (location: LocationData, raw: RawVoxelData, onDone: (data: any) => void, mode?: TaskRunModes) => void;
+        };
+    };
+    build: {
+        chunk: {
+            deferred: {
+                run: (buildTasks: BuildTasks, onDone: (data: any) => void) => void;
+            };
+            queued: {
+                add: (location: LocationData) => void;
+                run: (onDone: Function) => void;
+                runAndAwait: () => Promise<void>;
+            };
+        };
+        column: {
+            queued: {};
+            deferred: {
+                run: (location: LocationData, onDone: (data: any) => void) => void;
+            };
+        };
+    };
+    explosion: {
+        run: (location: LocationData, radius: number, onDone: (data: any) => void) => void;
+    };
+    anaylzer: {
+        update: {
+            run: (location: LocationData, onDone: (data: any) => void) => void;
+        };
+    };
+    propagation: {
+        deferred: {
+            run: (location: LocationData, onDone: (data: any) => void) => void;
+        };
+        queued: {
+            add: (location: LocationData) => void;
+            run: (onDone: Function) => void;
+            runAndAwait: () => Promise<void>;
+        };
+    };
+    generate: {
+        deferred: {
+            run(location: LocationData, data: any, onDone: (data: any) => void): void;
+        };
+        queued: {
+            add: (data: GenerateTasks) => void;
+            run: (onDone: Function) => void;
+            runAndAwait: () => Promise<void>;
+        };
+    };
+    decorate: {
+        deferred: {
+            run: (location: LocationData, data: any, onDone: (data: any) => void) => void;
+        };
+        queued: {
+            add: (data: GenerateTasks) => Promise<void>;
+            run: (onDone: Function) => void;
+            runAndAwait: () => Promise<void>;
+        };
+    };
+    worldSun: {
+        deferred: {
+            run: (location: LocationData, onDone: (data: any) => void) => void;
+        };
+        queued: {
+            add: (location: LocationData) => void;
+            run: (onDone: Function) => void;
+            runAndAwait: () => Promise<void>;
+        };
+    };
+}

package/Tools/Tasks/TasksTool.js

@@ -0,0 +1,217 @@
+import { Threads } from "@amodx/threads/";
+import { WorldSpaces } from "../../Data/World/WorldSpaces.js";
+import { ConstructorRemoteThreadTasks } from "../../Contexts/Constructor/ConstructorRemoteThreadTasks.js";
+import { ConstructorTasksIds } from "../../Contexts/Constructor/ConstructorTasksIds.js";
+import { DVEConstructorTasksQueues } from "../../Contexts/Constructor/DVEConstructorTasksQueues.js";
+export class TaskTool {
+    _data = {
+        dimension: "main",
+        queue: "main",
+    };
+    _thread = "";
+    _priority = 0;
+    constructor() {
+        this._thread = Threads.threadName;
+    }
+    setPriority(priority) {
+        this._priority = priority;
+        return this;
+    }
+    setFocalPoint(location) {
+        const [dimesnion, x, y, z] = location;
+        const queueKey = `${dimesnion}-${WorldSpaces.region.getKeyXYZ(x, y, z)}`;
+        DVEConstructorTasksQueues.instance.addQueue(queueKey);
+        this._data.queue = queueKey;
+        this._thread = Threads.threadName;
+        return this;
+    }
+    voxelUpdate = {
+        update: {
+            run: (location, raw, onDone, mode = "sync") => {
+                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(ConstructorTasksIds.VoxelUpdate, [location, raw, this._data.queue, this._thread], [], onDone, mode == "sync" ? 0 : undefined);
+            },
+        },
+        erase: {
+            run: (location, onDone, mode = "sync") => {
+                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(ConstructorTasksIds.VoxelErease, [location, this._data.queue, this._thread], [], onDone, mode == "sync" ? 0 : undefined);
+            },
+        },
+        paint: {
+            run: (location, raw, onDone, mode = "sync") => {
+                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(ConstructorTasksIds.VoxelPaint, [location, raw, this._data.queue, this._thread], [], onDone, mode == "sync" ? 0 : undefined);
+            },
+        },
+    };
+    build = {
+        chunk: {
+            deferred: {
+                run: (buildTasks, onDone) => {
+                    DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(ConstructorTasksIds.BuildChunk, {
+                        data: buildTasks,
+                        priority: this._priority,
+                    }, [], onDone, undefined, 0);
+                },
+            },
+            queued: {
+                add: (location) => {
+                    DVEConstructorTasksQueues.instance.getTasks("build-chunk").add({
+                        data: [location, 1],
+                        priority: this._priority,
+                    }, this._data.queue);
+                },
+                run: (onDone) => {
+                    DVEConstructorTasksQueues.instance
+                        .getTasks("build-chunk")
+                        .run(this._data.queue);
+                    DVEConstructorTasksQueues.instance
+                        .getTasks("build-chunk")
+                        .onDone(this._data.queue, onDone);
+                },
+                runAndAwait: async () => {
+                    await DVEConstructorTasksQueues.instance
+                        .getTasks("build-chunk")
+                        .runAndAwait(this._data.queue);
+                },
+            },
+        },
+        column: {
+            queued: {},
+            deferred: {
+                run: (location, onDone) => {
+                    DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(ConstructorTasksIds.BuildColumn, [location, 1], [], onDone, undefined, 0);
+                },
+            },
+        },
+    };
+    explosion = {
+        run: (location, radius, onDone) => {
+            DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(ConstructorTasksIds.Explosion, [location, radius, "", ""], [], onDone, undefined, 0);
+        },
+    };
+    anaylzer = {
+        update: {
+            run: (location, onDone) => {
+                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(ConstructorTasksIds.AnalyzerUpdate, [location, this._data.queue, this._thread], [], onDone, undefined, 0);
+            },
+        },
+    };
+    propagation = {
+        deferred: {
+            run: (location, onDone) => {
+                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(ConstructorTasksIds.AnalyzerPropagation, [location, this._data.queue, this._thread], [], onDone, undefined, 0);
+            },
+        },
+        queued: {
+            add: (location) => {
+                DVEConstructorTasksQueues.instance
+                    .getTasks("propagation")
+                    .add([location, this._data.queue, this._thread], this._data.queue);
+            },
+            run: (onDone) => {
+                DVEConstructorTasksQueues.instance
+                    .getTasks("propagation")
+                    .run(this._data.queue);
+                DVEConstructorTasksQueues.instance
+                    .getTasks("propagation")
+                    .onDone(this._data.queue, onDone);
+            },
+            runAndAwait: async () => {
+                await DVEConstructorTasksQueues.instance
+                    .getTasks("propagation")
+                    .runAndAwait(this._data.queue);
+            },
+        },
+    };
+    generate = {
+        deferred: {
+            run(location, data, onDone) {
+                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(ConstructorTasksIds.Generate, [location, data], [], onDone, undefined, 0);
+            },
+        },
+        queued: {
+            add: (data) => {
+                DVEConstructorTasksQueues.instance
+                    .getTasks("generate")
+                    .add(data, this._data.queue);
+            },
+            run: (onDone) => {
+                DVEConstructorTasksQueues.instance
+                    .getTasks("generate")
+                    .run(this._data.queue);
+                DVEConstructorTasksQueues.instance
+                    .getTasks("generate")
+                    .onDone(this._data.queue, onDone);
+            },
+            runAndAwait: async () => {
+                await DVEConstructorTasksQueues.instance
+                    .getTasks("generate")
+                    .runAndAwait(this._data.queue);
+            },
+        },
+    };
+    decorate = {
+        deferred: {
+            run: (location, data, onDone) => {
+                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(ConstructorTasksIds.Decorate, [location, data], [], onDone, undefined, 0);
+            },
+        },
+        queued: {
+            add: async (data) => {
+                DVEConstructorTasksQueues.instance
+                    .getTasks("decorate")
+                    .add(data, this._data.queue);
+            },
+            run: (onDone) => {
+                DVEConstructorTasksQueues.instance
+                    .getTasks("decorate")
+                    .run(this._data.queue);
+                DVEConstructorTasksQueues.instance
+                    .getTasks("decorate")
+                    .onDone(this._data.queue, onDone);
+            },
+            runAndAwait: async () => {
+                await DVEConstructorTasksQueues.instance
+                    .getTasks("decorate")
+                    .runAndAwait(this._data.queue);
+            },
+        },
+    };
+    worldSun = {
+        deferred: {
+            run: (location, onDone) => {
+                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(ConstructorTasksIds.WorldSun, [location, this._thread], [], onDone, undefined, 0);
+            },
+        },
+        queued: {
+            add: (location) => {
+                DVEConstructorTasksQueues.instance
+                    .getTasks("world-sun")
+                    .add([[...location], this._data.queue, this._thread], this._data.queue);
+            },
+            run: (onDone) => {
+                DVEConstructorTasksQueues.instance
+                    .getTasks("world-sun")
+                    .run(this._data.queue);
+                DVEConstructorTasksQueues.instance
+                    .getTasks("world-sun")
+                    .onDone(this._data.queue, onDone);
+            },
+            runAndAwait: async () => {
+                await DVEConstructorTasksQueues.instance
+                    .getTasks("world-sun")
+                    .runAndAwait(this._data.queue);
+            },
+        },
+    };
+}
+DVEConstructorTasksQueues.onCreated.subscribe(TaskTool, () => {
+    DVEConstructorTasksQueues.instance.registerTasks("world-sun", ConstructorTasksIds.WorldSun);
+    DVEConstructorTasksQueues.instance.registerTasks("decorate", ConstructorTasksIds.Decorate);
+    DVEConstructorTasksQueues.instance.registerTasks("generate", ConstructorTasksIds.Generate);
+    DVEConstructorTasksQueues.instance.registerTasks("propagation", ConstructorTasksIds.AnalyzerPropagation);
+    const tasks = new TaskTool();
+    Threads.registerTasks(ConstructorRemoteThreadTasks.BuildChunk, (data) => {
+        tasks.setPriority(data.priority);
+        tasks.build.chunk.deferred.run(data.data, () => { });
+    });
+});

package/Tools/index.js

@@ -0,0 +1 @@
+"use strict";

package/Types/DataSync.types.d.ts

@@ -0,0 +1,25 @@
+import type { BinaryStructData } from "@amodx/binary/";
+import { LocationData } from "Math/index.js";
+export type DataSyncTypes = "chunk" | "voxel-data" | "iten-data" | "shape-map";
+export type WorldDataSync = [location: LocationData, buffer: SharedArrayBuffer];
+export type PaletteSyncData = [
+    voxelPalette: string[],
+    voxelPaletteMap: Record<string, number>,
+    nameToIdMap: Record<string, string>,
+    idToNameMap: Record<string, string>
+];
+export type VoxelDataSync = [
+    initData: BinaryStructData,
+    voxelMapData: SharedArrayBuffer
+];
+export type RegisterStringMapSync = [
+    segment: string,
+    id: string,
+    map: string[]
+];
+export type RegisterObjectMapSync = [
+    segment: string,
+    id: string,
+    map: any[]
+];
+export type VoxelMapSyncData = string[];

package/Types/DataSync.types.js

@@ -0,0 +1 @@
+export {};

package/Types/EngineSettings.types.d.ts

@@ -0,0 +1,73 @@
+export declare class EngineSettingsData {
+    floatingOrigi: {
+        enable: boolean;
+    };
+    nexus: {
+        enabled: boolean;
+        autoSyncChunks: boolean;
+        autoSyncVoxelPalette: boolean;
+    };
+    data: {
+        enabled: boolean;
+        autoSyncChunks: boolean;
+        mode: string;
+    };
+    server: {
+        enabled: boolean;
+    };
+    richWorld: {
+        enabled: boolean;
+        autoSyncChunks: boolean;
+        autoSyncVoxelPalette: boolean;
+    };
+    textures: {
+        animationTime: number;
+        textureSize: number;
+        mipMapSizes: number[];
+    };
+    updating: {
+        autoRebuild: boolean;
+    };
+    world: {
+        maxX: number;
+        minX: number;
+        maxZ: number;
+        minZ: number;
+        maxY: number;
+        minY: number;
+    };
+    regions: {
+        regionXPow2: number;
+        regionYPow2: number;
+        regionZPow2: number;
+    };
+    chunks: {
+        autoHeightMap: boolean;
+        chunkXPow2: number;
+        chunkYPow2: number;
+        chunkZPow2: number;
+    };
+    voxels: {
+        doColors: boolean;
+    };
+    flow: {
+        enable: boolean;
+        baseFlowLimit: number;
+    };
+    lighting: {
+        doAO: boolean;
+        doSunLight: boolean;
+        doRGBLight: boolean;
+        autoRGBLight: boolean;
+        autoSunLight: boolean;
+    };
+    meshes: {
+        clearChachedGeometry: boolean;
+        checkMagmaCollisions: boolean;
+        checkLiquidCollisions: boolean;
+        checkFloraCollisions: boolean;
+        checkSolidCollisions: boolean;
+        serialize: boolean;
+        pickable: boolean;
+    };
+}

package/Types/EngineSettings.types.js

@@ -0,0 +1,73 @@
+export class EngineSettingsData {
+    floatingOrigi = {
+        enable: false,
+    };
+    nexus = {
+        enabled: false,
+        autoSyncChunks: true,
+        autoSyncVoxelPalette: true,
+    };
+    data = {
+        enabled: false,
+        autoSyncChunks: true,
+        mode: "indexdb",
+    };
+    server = {
+        enabled: false,
+    };
+    richWorld = {
+        enabled: false,
+        autoSyncChunks: true,
+        autoSyncVoxelPalette: true,
+    };
+    textures = {
+        animationTime: 20,
+        textureSize: 16,
+        mipMapSizes: [16, 12, 8, 4],
+    };
+    updating = {
+        autoRebuild: true,
+    };
+    world = {
+        maxX: Number.MAX_SAFE_INTEGER,
+        minX: -Number.MAX_SAFE_INTEGER,
+        maxZ: Number.MAX_SAFE_INTEGER,
+        minZ: -Number.MAX_SAFE_INTEGER,
+        maxY: 256,
+        minY: 0,
+    };
+    regions = {
+        regionXPow2: 9,
+        regionYPow2: 8,
+        regionZPow2: 9,
+    };
+    chunks = {
+        autoHeightMap: true,
+        chunkXPow2: 4,
+        chunkYPow2: 4,
+        chunkZPow2: 4,
+    };
+    voxels = {
+        doColors: true,
+    };
+    flow = {
+        enable: true,
+        baseFlowLimit: 200,
+    };
+    lighting = {
+        doAO: true,
+        doSunLight: true,
+        doRGBLight: true,
+        autoRGBLight: true,
+        autoSunLight: true,
+    };
+    meshes = {
+        clearChachedGeometry: true,
+        checkMagmaCollisions: false,
+        checkLiquidCollisions: false,
+        checkFloraCollisions: false,
+        checkSolidCollisions: false,
+        serialize: false,
+        pickable: false,
+    };
+}

package/Types/StructBuilder.types.d.ts

@@ -0,0 +1,30 @@
+import type { BinaryNumberTypes } from "@amodx/binary/";
+type TagBuilderNodeBase = {
+    id: string;
+};
+type TagBuilderNumberNode = {
+    type: "number";
+    numberType: BinaryNumberTypes;
+    default: number;
+} & TagBuilderNodeBase;
+type TagBuilderNumberArrayNode = {
+    type: "number-array";
+    numberType: BinaryNumberTypes;
+    length: number;
+} & TagBuilderNodeBase;
+type TagBuilderStringMapNode = {
+    type: "string-map";
+    allowedComms: string[];
+    default?: string;
+} & TagBuilderNodeBase;
+type TagBuilderObjectMapNode = {
+    type: "object-map";
+    allowedComms: string[];
+    default?: any;
+} & TagBuilderNodeBase;
+type TagBuilderBooleanNode = {
+    type: "boolean";
+    default: boolean;
+} & TagBuilderNodeBase;
+export type TagBuilderNodes = TagBuilderNumberNode | TagBuilderNumberArrayNode | TagBuilderStringMapNode | TagBuilderBooleanNode | TagBuilderObjectMapNode;
+export {};

package/Types/StructBuilder.types.js

@@ -0,0 +1 @@
+export {};

package/Types/Substances.types.d.ts

@@ -0,0 +1,4 @@
+export type SubstanceData = {
+    id: string;
+    tags: ([id: string, value: string | number | boolean | number[]] | [id: "#dve_parent_substance", value: string] | [id: "#dve_is_transparent", value: string] | [id: "#dve_rendered_substance", value: string] | [id: "#dve_culled_substances", value: string[]] | [id: "#dve_is_solid", value: boolean] | [id: "#dve_is_liquid", value: boolean] | [id: "#dve_flow_rate", value: number])[];
+};

package/Types/Substances.types.js

@@ -0,0 +1 @@
+export {};

package/Types/Tasks.types.d.ts

@@ -0,0 +1,85 @@
+import type { LocationData } from "../Math/index.js";
+import type { Vec3Array } from "@amodx/math";
+import type { RawVoxelData } from "../Data/Types/VoxelData.types";
+import { ChunkData, ColumnData, RegionData } from "Data/World/Classes";
+export type Priorities = 0 | 1 | 2 | 3;
+export type PriorityTask<T> = {
+    data: T;
+    priority: Priorities;
+};
+export type WorldLockTasks = [
+    dimension: string,
+    start: Vec3Array,
+    end: Vec3Array
+];
+export type LightUpdateTask = [number, number, number];
+export type WorldSunTask = [location: LocationData, originThread: string];
+export type UpdateTasks = [
+    location: LocationData,
+    buildQueue: string,
+    originThread: string
+];
+export type VoxelUpdateTasks = [
+    location: LocationData,
+    raw: RawVoxelData,
+    buildQueue: string,
+    originThread: string
+];
+export type AnaylzerTask = [
+    location: LocationData,
+    buildQueue: string,
+    originThread: string
+];
+export type AddToRebuildQueue = [
+    location: LocationData,
+    buildQueue: string,
+    priority: Priorities
+];
+export type RunRebuildTasks = [buildQueue: string];
+export type BuildTasks = [location: LocationData, LOD: number];
+export type GenerateTasks = [location: LocationData, data: any];
+export type ExplosionTasks = [
+    location: LocationData,
+    radius: number,
+    buildQueue: string,
+    originThread: string
+];
+export type LoadChunkDataTasks = [location: LocationData, chunk: ChunkData];
+export type LoadColumnDataTasks = [location: LocationData, column: ColumnData];
+export type LoadRegionDataTasks = [location: LocationData, region: RegionData];
+export type LoadRegionHeadertasks = [
+    location: LocationData,
+    data: SharedArrayBuffer
+];
+export type GetRichDataTasks = [location: LocationData, segment: string];
+export type SetRichDataTasks = [
+    location: LocationData,
+    segment: string,
+    objectBuffer: ArrayBuffer
+];
+export type SetRichColumnTasks = [
+    location: LocationData,
+    objectBuffer: ArrayBuffer
+];
+export type RequestLightUpdateQueueData = {
+    rgb: {
+        update: number[][];
+        rmeove: number[][];
+    };
+    sun: {
+        update: number[][];
+        rmeove: number[][];
+    };
+};
+export type RequestFlowUpdateQueueData = {
+    flow: {
+        update: number[][];
+        rmeove: number[][];
+    };
+} & RequestLightUpdateQueueData;
+export type RequestsVoxelUpdateQueuesData = {
+    flow: {
+        update: number[][];
+        rmeove: number[][];
+    };
+} & RequestLightUpdateQueueData;

package/Types/Tasks.types.js

@@ -0,0 +1 @@
+export {};

package/Types/Util.types.d.ts

@@ -0,0 +1,5 @@
+import { CompassDirectionNames } from "../Math/Math.types";
+export type DirectionNames = "up" | "down" | Exclude<CompassDirectionNames, "north-west" | "north-east" | "south-west" | "south-east">;
+export type RecursivePartial<T> = {
+    [P in keyof T]?: RecursivePartial<T[P]>;
+};

package/Types/Util.types.js

@@ -0,0 +1 @@
+export {};

package/Types/Voxel.types.d.ts

@@ -0,0 +1,12 @@
+export type VoxelPalette = string[];
+export type VoxelPaletteMap = Record<string, number>;
+/**# Voxel Data
+ * ---
+ * This the needed information for each voxel.
+ */
+export interface VoxelData {
+    id: string;
+    name?: string;
+    title?: string;
+    tags: ([id: string, value: any] | [id: "#dve_substance", value: string] | [id: "#dve_shape_id", value: string] | [id: "#dve_is_light_source", value: boolean] | [id: "#dve_no_ao", value: boolean] | [id: "#dve_light_value", value: [r: number, g: number, z: number]] | [id: "#dve_collider_id", value: string] | [id: "#dve_check_collisions", value: boolean] | [id: "#dve_can_have_secondary", value: boolean] | [id: "#dve_material", value: string] | [id: "#dve_hardness", value: number] | [id: "#dve_is_rich", value: boolean])[];
+}

package/Types/Voxel.types.js

@@ -0,0 +1 @@
+export {};

package/Types/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Voxel.types.js";
+export * from "./Util.types.js";

package/Types/index.js

@@ -0,0 +1,2 @@
+export * from "./Voxel.types.js";
+export * from "./Util.types.js";

package/Util/DataMatrix.d.ts

@@ -0,0 +1,23 @@
+import type { Vec3Array } from "@amodx/math";
+export declare class DataMatrix<T> {
+    size: Vec3Array;
+    defaultValue: T;
+    private _matrix;
+    constructor(size: Vec3Array, defaultValue: T);
+    get sizeX(): number;
+    get sizeY(): number;
+    get sizeZ(): number;
+    setMatrix(matrix: T[][][]): void;
+    cloneMatrix(): T[][][];
+    setVec3([x, y, z]: Vec3Array, value: T): void;
+    setXYZ(x: number, y: number, z: number, value: T): void;
+    getVec3([x, y, z]: Vec3Array): T | undefined;
+    getXYZ(x: number, y: number, z: number): T | undefined;
+    deleteVec3([x, y, z]: Vec3Array): void;
+    deleteXYZ(x: number, y: number, z: number): void;
+    setAll(value: T): void;
+    getAll(): Generator<[Vec3Array, T]>;
+    swap(startPosition: Vec3Array, endPosition: Vec3Array): void;
+    isCube(): boolean;
+    private isWithinBounds;
+}