@divinevoxel/vlox 0.0.0

package/IWG/World/Tasks/WorldGen/IWGLoadTasks.js

@@ -0,0 +1,58 @@
+import { SafeInterval } from "@amodx/core/Intervals/SafeInterval";
+import { IWGSingleTask } from "../../Classes/Tasks/IWGSingleTask";
+import { IWGTasksTypes } from "../../Types/IWG.types";
+export class IWGLoadTask extends IWGSingleTask {
+    static Data = {
+        id: "#dve_iwg_load",
+        name: "load",
+        type: IWGTasksTypes.WorldGen,
+        propagationBlocking: true,
+    };
+    getMeta() {
+        return this.getClass().Data;
+    }
+    getClass() {
+        return IWGLoadTask;
+    }
+    async run(dimensionId, x, y, z, onDone) {
+        const gen = this.gen;
+        if (!gen.dataLoader || !gen.data.saveWorldData) {
+            if (gen.columnTool.loadInAt(x, y, z)) {
+                return onDone();
+            }
+            gen.builder.setXYZ(x, y, z).fillColumn();
+            return onDone();
+        }
+        if (gen.columnTool.loadInAt(x, y, z)) {
+            return onDone();
+        }
+        let tries = 0;
+        let ran = false;
+        let cleared = false;
+        const inte = new SafeInterval();
+        inte.setInterval(1_000);
+        inte.setOnRun(() => {
+            if (ran) {
+                inte.stop();
+                return;
+            }
+            tries++;
+            if (!gen.columnTool.loadInAt(x, y, z) && tries >= 120 && !ran) {
+                inte.stop();
+                onDone();
+                console.error("force quit loading column", ran, [gen.dimension, x, y, z]);
+                cleared = true;
+            }
+        });
+        inte.start();
+        const exists = await gen.dataLoader.loadIfExists([gen.dimension, x, y, z]);
+        ran = true;
+        if (cleared)
+            return;
+        onDone();
+        if (!exists) {
+            gen.builder.setXYZ(x, y, z).fillColumn();
+            return;
+        }
+    }
+}

package/IWG/World/Tasks/WorldGen/IWGPropagationTasks.d.ts

@@ -0,0 +1,8 @@
+import { IWGSingleTask } from "../../Classes/Tasks/IWGSingleTask";
+import { IWGTasksData, IWGTaskBaseInterface } from "../../Classes/Tasks/IWGTaskBase";
+export declare class IWGPropagationTasks extends IWGSingleTask {
+    static Data: IWGTasksData;
+    getMeta(): IWGTasksData;
+    getClass(): IWGTaskBaseInterface;
+    run(dimensionId: string, x: number, y: number, z: number, onDone: Function): Promise<any>;
+}

package/IWG/World/Tasks/WorldGen/IWGPropagationTasks.js

@@ -0,0 +1,27 @@
+import { IWGSingleTask } from "../../Classes/Tasks/IWGSingleTask";
+import { IWGTasksTypes } from "../../Types/IWG.types";
+export class IWGPropagationTasks extends IWGSingleTask {
+    static Data = {
+        id: "#dve_iwg_propagation",
+        name: "propagation",
+        type: IWGTasksTypes.WorldGen,
+        propagationBlocking: true,
+    };
+    getMeta() {
+        return this.getClass().Data;
+    }
+    getClass() {
+        return IWGPropagationTasks;
+    }
+    async run(dimensionId, x, y, z, onDone) {
+        const gen = this.gen;
+        if (gen.columnTool.loadInAt(x, y, z) &&
+            gen.columnTool.getStructValue("#dve_is_world_propagation_done"))
+            return onDone();
+        gen.dveTasks.propagation.deferred.run([gen.dimension, x, y, z], () => {
+            onDone();
+            if (gen.columnTool.loadInAt(x, y, z))
+                return gen.columnTool.setTagValue("#dve_is_world_propagation_done", 1);
+        });
+    }
+}

package/IWG/World/Tasks/WorldGen/IWGWorldSunTasks.d.ts

@@ -0,0 +1,8 @@
+import { IWGSingleTask } from "../../Classes/Tasks/IWGSingleTask";
+import { IWGTasksData, IWGTaskBaseInterface } from "../../Classes/Tasks/IWGTaskBase";
+export declare class IWGWorldSunTasks extends IWGSingleTask {
+    static Data: IWGTasksData;
+    getMeta(): IWGTasksData;
+    getClass(): IWGTaskBaseInterface;
+    run(dimensionId: string, x: number, y: number, z: number, onDone: Function): Promise<any>;
+}

package/IWG/World/Tasks/WorldGen/IWGWorldSunTasks.js

@@ -0,0 +1,27 @@
+import { IWGSingleTask } from "../../Classes/Tasks/IWGSingleTask";
+import { IWGTasksTypes } from "../../Types/IWG.types";
+export class IWGWorldSunTasks extends IWGSingleTask {
+    static Data = {
+        id: "#dve_iwg_world_sun",
+        name: "world sun",
+        type: IWGTasksTypes.WorldGen,
+        propagationBlocking: true,
+    };
+    getMeta() {
+        return this.getClass().Data;
+    }
+    getClass() {
+        return IWGWorldSunTasks;
+    }
+    async run(dimensionId, x, y, z, onDone) {
+        const gen = this.gen;
+        if (gen.columnTool.loadInAt(x, y, z) &&
+            gen.columnTool.getStructValue("#dve_is_world_sun_done"))
+            return onDone();
+        gen.dveTasks.worldSun.deferred.run([gen.dimension, x, y, z], () => {
+            onDone();
+            if (gen.columnTool.loadInAt(x, y, z))
+                return gen.columnTool.setTagValue("#dve_is_world_sun_done", 1);
+        });
+    }
+}

package/IWG/World/Types/IWG.types.d.ts

@@ -0,0 +1,20 @@
+export type IWGGeneratorData = {
+    id: string;
+    positionWatch: number[] | Float32Array | Float64Array | Int32Array | Int16Array;
+    velocityWatch?: number[] | Float32Array | Float64Array | Int32Array | Int16Array;
+    velocityScale?: number;
+} & IWGSettignsData;
+export type IWGSettignsData = {
+    renderDistance: number;
+    generateDistance: number;
+    saveWorldData?: boolean;
+    maxDistance?: number;
+    generateLeadDistance?: number;
+    anaylzerDistance?: number;
+};
+export declare enum IWGTasksTypes {
+    WorldGen = "world-gen",
+    Rendering = "rendering",
+    Saving = "saving",
+    Updating = "updating"
+}

package/IWG/World/Types/IWG.types.js

@@ -0,0 +1,7 @@
+export var IWGTasksTypes;
+(function (IWGTasksTypes) {
+    IWGTasksTypes["WorldGen"] = "world-gen";
+    IWGTasksTypes["Rendering"] = "rendering";
+    IWGTasksTypes["Saving"] = "saving";
+    IWGTasksTypes["Updating"] = "updating";
+})(IWGTasksTypes || (IWGTasksTypes = {}));

package/IWG/World/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./IWG.js";
+export * from "./Classes/Generator.js";

package/IWG/World/index.js

@@ -0,0 +1,2 @@
+export * from "./IWG.js";
+export * from "./Classes/Generator.js";

package/IWG/index.d.ts

@@ -0,0 +1 @@
+export * from "./World/Types/IWG.types.js";

package/IWG/index.js

@@ -0,0 +1 @@
+export * from "./World/Types/IWG.types.js";

package/Init/StartConstructor.d.ts

@@ -0,0 +1,2 @@
+import { DivineVoxelEngineConstructor, DivineVoxelEngineConstructorInitData } from "../Contexts/Constructor/DivineVoxelEngineConstructor";
+export declare function StartContrusctor(data: DivineVoxelEngineConstructorInitData): Promise<DivineVoxelEngineConstructor>;

package/Init/StartConstructor.js

@@ -0,0 +1,8 @@
+import { DivineVoxelEngineConstructor, } from "../Contexts/Constructor/DivineVoxelEngineConstructor";
+import InitVoxelModels from "../VoxelModels/Constructor/InitVoxelModelsConstructor.js";
+export async function StartContrusctor(data) {
+    const DVEC = new DivineVoxelEngineConstructor(data);
+    await DVEC.init();
+    InitVoxelModels(DVEC);
+    return DVEC;
+}

package/Init/StartWorld.d.ts

@@ -0,0 +1,7 @@
+import type { VoxelData } from "../Types/";
+import { DivineVoxelEngineWorld, DVEWorldProps } from "../Contexts/World/DivineVoxelEngineWorld";
+type StartWorldProps = {
+    voxels: VoxelData[];
+} & DVEWorldProps;
+export declare function StartWorld(props: StartWorldProps): Promise<DivineVoxelEngineWorld>;
+export {};

package/Init/StartWorld.js

@@ -0,0 +1,9 @@
+import { DivineVoxelEngineWorld, } from "../Contexts/World/DivineVoxelEngineWorld";
+import InitVoxelModelsWorld from "../VoxelModels/World/InitVoxelModelsWorld";
+export async function StartWorld(props) {
+    const DVEW = new DivineVoxelEngineWorld();
+    InitVoxelModelsWorld(DVEW);
+    DVEW.dataRegiser.voxels.registerData(props.voxels);
+    await DVEW.init();
+    return DVEW;
+}

package/Interfaces/Anaylzer/DVEAnaylzer.d.ts

@@ -0,0 +1,5 @@
+import { AnaylzerTask } from "../../Types/Tasks.types";
+export declare abstract class DVEAnaylzer {
+    abstract runPropagation(data: AnaylzerTask): Promise<void>;
+    abstract runUpdate(data: AnaylzerTask): Promise<void>;
+}

package/Interfaces/Anaylzer/DVEAnaylzer.js

@@ -0,0 +1,2 @@
+export class DVEAnaylzer {
+}

package/Interfaces/Classes/ThreadManager.d.ts

@@ -0,0 +1,16 @@
+import { Thread, ThreadPool, CommPortTypes } from "@amodx/threads";
+import { AsyncPipeline } from "@amodx/core/Pipelines";
+import { ThreadState } from "./ThreadState";
+export declare abstract class ThreadManager {
+    pipelines: {
+        setPorts: AsyncPipeline<ThreadManager>;
+        init: AsyncPipeline<ThreadManager>;
+    };
+    commMap: Map<string, Thread | ThreadPool>;
+    comms: (Thread | ThreadPool)[];
+    abstract state: ThreadState;
+    init(): Promise<void>;
+    setThreadPort(id: string, ports: CommPortTypes | CommPortTypes[]): void;
+    addThread(comm: Thread | ThreadPool): void;
+    getThread(id: string): Thread | ThreadPool;
+}

package/Interfaces/Classes/ThreadManager.js

@@ -0,0 +1,42 @@
+import { Thread, ThreadPool } from "@amodx/threads";
+import { AsyncPipeline } from "@amodx/core/Pipelines";
+export class ThreadManager {
+    pipelines = {
+        setPorts: new AsyncPipeline(),
+        init: new AsyncPipeline(),
+    };
+    commMap = new Map();
+    comms = [];
+    async init() {
+        await this.pipelines.init.pipe(this);
+    }
+    setThreadPort(id, ports) {
+        const comm = this.getThread(id);
+        let error;
+        if (Array.isArray(ports) && comm instanceof ThreadPool) {
+            comm.addPorts(ports);
+            return;
+        }
+        else
+            error =
+                "Comm is an instance of comm manager and the passed in ports was not an array.";
+        if (!Array.isArray(ports) && comm instanceof Thread) {
+            comm.setPort(ports);
+            return;
+        }
+        else
+            error =
+                "Comm is an instance of comm base and the passed in ports was an array.";
+        throw new Error(error);
+    }
+    addThread(comm) {
+        this.commMap.set(comm.name, comm);
+        this.comms.push(comm);
+    }
+    getThread(id) {
+        const comm = this.commMap.get(id);
+        if (!comm)
+            throw new Error(`Comm with id ${id} does not exists`);
+        return comm;
+    }
+}

package/Interfaces/Classes/ThreadState.d.ts

@@ -0,0 +1,7 @@
+import { ThreadManager } from "./ThreadManager";
+export declare abstract class ThreadState<Threads extends ThreadManager = ThreadManager> {
+    threads: Threads;
+    settingsSynced: boolean;
+    constructor(threads: Threads);
+    abstract isReady(): boolean;
+}

package/Interfaces/Classes/ThreadState.js

@@ -0,0 +1,7 @@
+export class ThreadState {
+    threads;
+    settingsSynced = false;
+    constructor(threads) {
+        this.threads = threads;
+    }
+}

package/Interfaces/Common/DataSyncIds.d.ts

@@ -0,0 +1,8 @@
+export declare enum DataSyncIds {
+    VoxelPalette = "VoxelPalette",
+    VoxelTags = "VoxelTags",
+    SubstanceTags = "SubstanceTags",
+    SubstancePalette = "SubstancePalette",
+    RegisterStringMap = "RegisterStringMap",
+    RegisterObjectMap = "RegisterObjectMap"
+}

package/Interfaces/Common/DataSyncIds.js

@@ -0,0 +1,9 @@
+export var DataSyncIds;
+(function (DataSyncIds) {
+    DataSyncIds["VoxelPalette"] = "VoxelPalette";
+    DataSyncIds["VoxelTags"] = "VoxelTags";
+    DataSyncIds["SubstanceTags"] = "SubstanceTags";
+    DataSyncIds["SubstancePalette"] = "SubstancePalette";
+    DataSyncIds["RegisterStringMap"] = "RegisterStringMap";
+    DataSyncIds["RegisterObjectMap"] = "RegisterObjectMap";
+})(DataSyncIds || (DataSyncIds = {}));

package/Interfaces/Data/DVEDataCore.d.ts

@@ -0,0 +1,6 @@
+import { DataManager } from "./DataManager";
+import { RemoteDataSyncNode } from "./RemoteDataSyncNode";
+export declare abstract class DVEDataCore {
+    abstract dataManager: DataManager;
+    abstract dataSync: RemoteDataSyncNode;
+}

package/Interfaces/Data/DVEDataCore.js

@@ -0,0 +1,2 @@
+export class DVEDataCore {
+}

package/Interfaces/Data/DataManager.d.ts

@@ -0,0 +1,13 @@
+import { MappedDataRegister } from "../../Data/Register/MappedDataRegister";
+import { WorldBounds } from "../../Data/World/WorldBounds";
+import { VoxelStruct } from "../../Data/Voxel/VoxelStruct";
+import { SubstanceStruct } from "../../Data/Substance/SubstanceStruct";
+export declare abstract class DataManager {
+    worldBounds: typeof WorldBounds;
+    spaces: import("../../Math/Spaces/VoxelSpaces").VoxelSpaces;
+    mapped: typeof MappedDataRegister;
+    tags: {
+        voxels: typeof VoxelStruct;
+        substances: typeof SubstanceStruct;
+    };
+}

package/Interfaces/Data/DataManager.js

@@ -0,0 +1,14 @@
+import { MappedDataRegister } from "../../Data/Register/MappedDataRegister";
+import { WorldBounds } from "../../Data/World/WorldBounds";
+import { WorldSpaces } from "../../Data/World/WorldSpaces";
+import { VoxelStruct } from "../../Data/Voxel/VoxelStruct";
+import { SubstanceStruct } from "../../Data/Substance/SubstanceStruct";
+export class DataManager {
+    worldBounds = WorldBounds;
+    spaces = WorldSpaces;
+    mapped = MappedDataRegister;
+    tags = {
+        voxels: VoxelStruct,
+        substances: SubstanceStruct,
+    };
+}

package/Interfaces/Data/LocationBoundToolBase.d.ts

@@ -0,0 +1,24 @@
+import type { LocationData } from "../../Math/index.js";
+import type { Vec3Array } from "@amodx/math";
+export declare abstract class LocationBoundToolBase {
+    location: LocationData;
+    get dimension(): string;
+    set dimension(dimension: string);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get z(): number;
+    set z(value: number);
+    setDimension(dimensionId: string): this;
+    getLocation(): LocationData;
+    getXYZAsArray(): Vec3Array;
+    getXYZ(): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    setXYZ(x: number, y: number, z: number): this;
+    setXZ(x: number, z: number): this;
+    setLocation(location: LocationData): this;
+}

package/Interfaces/Data/LocationBoundToolBase.js

@@ -0,0 +1,61 @@
+export class LocationBoundToolBase {
+    location = ["main", 0, 0, 0];
+    get dimension() {
+        return this.location[0];
+    }
+    set dimension(dimension) {
+        this.location[0] = dimension;
+    }
+    get x() {
+        return this.location[1];
+    }
+    set x(value) {
+        this.location[1] = value;
+    }
+    get y() {
+        return this.location[2];
+    }
+    set y(value) {
+        this.location[2] = value;
+    }
+    get z() {
+        return this.location[3];
+    }
+    set z(value) {
+        this.location[3] = value;
+    }
+    setDimension(dimensionId) {
+        this.location[0] = dimensionId;
+        return this;
+    }
+    getLocation() {
+        return this.location;
+    }
+    getXYZAsArray() {
+        return [this.x, this.y, this.z];
+    }
+    getXYZ() {
+        return {
+            x: this.x,
+            y: this.y,
+            z: this.z,
+        };
+    }
+    setXYZ(x, y, z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        return this;
+    }
+    setXZ(x, z) {
+        this.setXYZ(x, this.location[2], z);
+        return this;
+    }
+    setLocation(location) {
+        this.dimension = location[0];
+        this.x = location[1];
+        this.y = location[2];
+        this.z = location[3];
+        return this;
+    }
+}

package/Interfaces/Data/NumberPalette.d.ts

@@ -0,0 +1,13 @@
+export declare class NumberPalette {
+    private _count;
+    _palette: number[];
+    _map: Record<number, number>;
+    get size(): number;
+    constructor(inital?: ArrayLike<number>);
+    register(value: number): number;
+    get(): number[];
+    getMap(): Record<number, number>;
+    isRegistered(id: number): boolean;
+    getId(value: number): number;
+    getValue(id: number): number;
+}

package/Interfaces/Data/NumberPalette.js

@@ -0,0 +1,40 @@
+export class NumberPalette {
+    _count = 0;
+    //map id to value
+    _palette = [];
+    //map value to id
+    _map = {};
+    get size() {
+        return this._count;
+    }
+    constructor(inital) {
+        if (inital) {
+            let length = inital.length;
+            for (let i = 0; i < length; i++) {
+                this.register(inital[i]);
+            }
+        }
+    }
+    register(value) {
+        const id = this._count;
+        this._palette[id] = value;
+        this._map[value] = id;
+        this._count++;
+        return id;
+    }
+    get() {
+        return this._palette;
+    }
+    getMap() {
+        return this._map;
+    }
+    isRegistered(id) {
+        return this._map[id] !== undefined;
+    }
+    getId(value) {
+        return this._map[value];
+    }
+    getValue(id) {
+        return this._palette[id];
+    }
+}

package/Interfaces/Data/RemoteDataSyncNode.d.ts

@@ -0,0 +1,16 @@
+import type { VoxelDataSync, PaletteSyncData, RegisterStringMapSync } from "Types/DataSync.types.js";
+import { BinaryStructData } from "@amodx/binary/";
+export declare abstract class RemoteDataSyncNode {
+    maps: {
+        strings: import("@amodx/threads/").DataSync<RegisterStringMapSync, void>;
+        objects: import("@amodx/threads/").DataSync<RegisterStringMapSync, void>;
+    };
+    palettes: {
+        voxel: import("@amodx/threads/").DataSync<PaletteSyncData, any>;
+        substance: import("@amodx/threads/").DataSync<PaletteSyncData, any>;
+    };
+    tags: {
+        voxel: import("@amodx/threads/").DataSync<VoxelDataSync, any>;
+        substance: import("@amodx/threads/").DataSync<BinaryStructData, any>;
+    };
+}

package/Interfaces/Data/RemoteDataSyncNode.js

@@ -0,0 +1,36 @@
+//objects
+import { Threads } from "@amodx/threads/";
+import { SubstanceStruct } from "../../Data/Substance/SubstanceStruct.js";
+import { DataSyncIds } from "../Common/DataSyncIds.js";
+import { MappedDataRegister } from "../../Data/Register/MappedDataRegister.js";
+import { VoxelPalette } from "../../Data/Voxel/VoxelPalette.js";
+import { SubstancePaletteReader } from "../../Data/Substance/SubstancePalette.js";
+import { VoxelStruct } from "../../Data/Voxel/VoxelStruct.js";
+export class RemoteDataSyncNode {
+    maps = {
+        strings: Threads.onDataSync(DataSyncIds.RegisterStringMap, (data) => {
+            MappedDataRegister.stringMaps.sync(data[0], data[1], data[2]);
+        }),
+        objects: Threads.onDataSync(DataSyncIds.RegisterObjectMap, (data) => {
+            MappedDataRegister.objectMaps.sync(data[0], data[1], data[2]);
+        }),
+    };
+    palettes = {
+        voxel: Threads.onDataSync(DataSyncIds.VoxelPalette, ([palette, map, nameToId, idToName]) => {
+            VoxelPalette.setVoxelIdPalette(palette, map);
+            VoxelPalette.setVoxelNamePalette(nameToId, idToName);
+        }),
+        substance: Threads.onDataSync(DataSyncIds.SubstancePalette, ([palette, map]) => {
+            SubstancePaletteReader.setPalette(palette, map);
+        }),
+    };
+    tags = {
+        voxel: Threads.onDataSync(DataSyncIds.VoxelTags, (data) => {
+            VoxelStruct.init(data[0]);
+            VoxelStruct.sync(new Uint16Array(data[1]));
+        }),
+        substance: Threads.onDataSync(DataSyncIds.SubstanceTags, (data) => {
+            SubstanceStruct.init(data);
+        }),
+    };
+}

package/Interfaces/Data/StringPalette.d.ts

@@ -0,0 +1,13 @@
+export declare class StringPalette {
+    private _count;
+    _palette: string[];
+    _map: Record<string, number>;
+    constructor(inital?: ArrayLike<string>);
+    get size(): number;
+    register(string: string): number;
+    get(): string[];
+    getMap(): Record<string, number>;
+    isRegistered(id: string): boolean;
+    getNumberId(id: string): number;
+    getStringId(id: number): string;
+}

package/Interfaces/Data/StringPalette.js

@@ -0,0 +1,38 @@
+export class StringPalette {
+    _count = 0;
+    _palette = [];
+    _map = {};
+    constructor(inital) {
+        if (inital) {
+            const length = inital.length;
+            for (let i = 0; i < length; i++) {
+                this.register(inital[i]);
+            }
+        }
+    }
+    get size() {
+        return this._count;
+    }
+    register(string) {
+        const id = this._count;
+        this._count++;
+        this._palette[id] = string;
+        this._map[string] = id;
+        return id;
+    }
+    get() {
+        return this._palette;
+    }
+    getMap() {
+        return this._map;
+    }
+    isRegistered(id) {
+        return this._map[id] !== undefined;
+    }
+    getNumberId(id) {
+        return this._map[id];
+    }
+    getStringId(id) {
+        return this._palette[id];
+    }
+}

package/Interfaces/DataLoader/DVEDataHandler.d.ts

@@ -0,0 +1,17 @@
+import { LocationData } from "../../Math";
+export type DataLoaderModes = "server" | "indexdb" | "both";
+export type DataLoaderSegments = "world-data" | "rich-data" | "dbo" | "entities";
+export declare abstract class DVEDataHandler {
+    mode: "server" | "indexdb" | "both";
+    constructor();
+    setMode(mode: "server" | "indexdb" | "both"): void;
+    dataType: DataLoaderSegments;
+    setDataType(type: DataLoaderSegments): void;
+    abstract getRegionHeader(location: LocationData): Promise<ArrayBuffer>;
+    abstract setPath(id: string): Promise<boolean>;
+    abstract getColumn(location: LocationData): Promise<ArrayBuffer | SharedArrayBuffer>;
+    abstract saveColumn(location: LocationData, columnBuffer: ArrayBuffer | SharedArrayBuffer): Promise<boolean>;
+    abstract columnExists(location: LocationData): Promise<boolean>;
+    abstract columnExistsBatch(location: LocationData[]): Promise<Record<string, boolean>>;
+    abstract columnTimestamp(location: LocationData): Promise<number>;
+}

package/Interfaces/DataLoader/DVEDataHandler.js

@@ -0,0 +1,14 @@
+import { DataHanlderWrapper } from "../../DataLoader/World/DataHandlerWrapper";
+export class DVEDataHandler {
+    mode = "indexdb";
+    constructor() {
+        this.mode = DataHanlderWrapper.mode;
+    }
+    setMode(mode) {
+        this.mode = mode;
+    }
+    dataType = "world-data";
+    setDataType(type) {
+        this.dataType = type;
+    }
+}

package/Interfaces/Render/DVEFOManager.d.ts

@@ -0,0 +1,7 @@
+import { URIScene } from "@amodx/uri/Scenes/URIScene";
+import { URINode } from "@amodx/uri/Meshes/URINode";
+export declare abstract class DVEFOManager {
+    scene: URIScene;
+    constructor(scene: URIScene);
+    abstract getActiveNode(): URINode | null;
+}