@divinevoxel/vlox 0.0.73 → 0.0.75

package/Cache/Cache.types.d.ts

@@ -1,6 +1,6 @@
 import { CompactMeshData } from "../Mesher/Types/Mesher.types";
 import { TextureData } from "../Textures/Texture.types";
-import { FinalCompiledVoxelModelData } from "../Voxels/Types/VoxelModelCompiledData.types";
+import { FinalCompiledVoxelModelData } from "../Voxels/Models/CompiledVoxelModel.types";
 export interface CachedVoxelModelData extends FinalCompiledVoxelModelData {
 }
 export interface CachedDisplayIndex {

package/Contexts/Base/Remote/InitDataSync.js

@@ -2,18 +2,20 @@ import { Threads } from "@amodx/threads/";
 import { EngineSettings } from "../../../Settings/EngineSettings";
 //objects
 import { SchemaRegister } from "../../../Voxels/State/SchemaRegister";
-import { VoxelTagStates } from "../../../Voxels/Data/VoxelTagStates";
 import { VoxelPalettesRegister } from "../../../Voxels/Data/VoxelPalettesRegister";
 import { VoxelTagsRegister } from "../../../Voxels/Data/VoxelTagsRegister";
+import { VoxelLogicRegister } from "../../../Voxels/Logic/VoxelLogicRegister";
 export default function InitDataSync(props) {
     Threads.registerTask("sync-data", (data) => {
         EngineSettings.syncSettings(data.settings);
-        VoxelPalettesRegister.voxels.load(data.voxels.data.palette);
+        VoxelPalettesRegister.voxelIds.load(data.voxels.data.idPalette);
         VoxelTagsRegister.VoxelTags = data.voxels.data.tags;
         VoxelPalettesRegister.voxelIdToNameMap = new Map(data.voxels.data.idToNameMap);
         VoxelPalettesRegister.voxelNametoIdMap = new Map(data.voxels.data.nameToIdMap);
         VoxelPalettesRegister.substance.load(data.voxels.substances.palette);
         VoxelTagsRegister.SubstanceStags = data.voxels.substances.tags;
+        VoxelPalettesRegister.voxels = data.voxels.data.palette;
+        VoxelPalettesRegister.voxelRecord = data.voxels.data.record;
         VoxelPalettesRegister.material.load(data.voxels.materials.palette);
         const modelData = data.voxels.models;
         for (const model of modelData.models) {
@@ -22,7 +24,9 @@ export default function InitDataSync(props) {
         for (const voxel of modelData.voxels) {
             SchemaRegister.registerVoxel(voxel.id, voxel.modelId, voxel.modSchema);
         }
-        VoxelTagStates.load(modelData.tagState);
+        for (const id in data.voxels.data.logic) {
+            VoxelLogicRegister.register(id, data.voxels.data.logic[id]);
+        }
         props.onSync(data);
     });
 }

package/Contexts/Base/Remote/InitWorldDataSync.d.ts

@@ -1 +1,2 @@
-export default function (): void;
+import { Thread } from "@amodx/threads/";
+export default function (worldThread: Thread): void;

package/Contexts/Base/Remote/InitWorldDataSync.js

@@ -1,9 +1,9 @@
 import { Threads } from "@amodx/threads/";
 import { WorldDataSyncIds } from "../../../World/Types/WorldDataSyncIds.js";
 import { WorldRegister } from "../../../World/WorldRegister.js";
-export default function () {
+export default function (worldThread) {
     Threads.registerTask(WorldDataSyncIds.SyncDimension, (data) => {
-        WorldRegister.dimensions.add(data.id);
+        WorldRegister.dimensions.add(data.index, data.id);
     });
     Threads.registerTask(WorldDataSyncIds.UnSyncDimension, (data) => {
         //  register.dimensions.re(data.id);
@@ -12,6 +12,17 @@ export default function () {
         WorldRegister.sectors.add(data[0][0], data[0][1], data[0][2], data[0][3], data[1]);
     });
     Threads.registerTask(WorldDataSyncIds.UnSyncSector, (data) => {
-        WorldRegister.sectors.remove(data[0], data[1], data[2], data[3]);
+        WorldRegister.sectors.remove(...data);
+    });
+    Threads.registerTask(WorldDataSyncIds.CheckInSector, (data) => {
+        WorldRegister.sectors.add(data[0][0], data[0][1], data[0][2], data[0][3], data[1]);
+    });
+    Threads.registerTask(WorldDataSyncIds.CheckOutSector, (location) => {
+        const buffer = WorldRegister.sectors.remove(...location);
+        if (!buffer) {
+            console.warn("Not buffer returned when checking out sector", location);
+            return;
+        }
+        worldThread.runTask(WorldDataSyncIds.CheckInSector, [location, buffer], [buffer]);
     });
 }

package/Contexts/Generator/DivineVoxelEngineGenerator.d.ts

@@ -0,0 +1,9 @@
+import { Threads } from "@amodx/threads/";
+import { GeneratorThreadsManager } from "./GeneratorThreads.js";
+export declare class DivineVoxelEngineGenerator {
+    static environment: "node" | "browser";
+    static instance: DivineVoxelEngineGenerator;
+    TC: typeof Threads;
+    threads: GeneratorThreadsManager;
+    constructor();
+}

package/Contexts/Generator/DivineVoxelEngineGenerator.js

@@ -0,0 +1,14 @@
+//threadcomm
+import { Threads } from "@amodx/threads/";
+import { GeneratorThreadsManager } from "./GeneratorThreads.js";
+export class DivineVoxelEngineGenerator {
+    static environment = "browser";
+    static instance;
+    TC = Threads;
+    threads = new GeneratorThreadsManager();
+    constructor() {
+        if (DivineVoxelEngineGenerator.instance)
+            return DivineVoxelEngineGenerator.instance;
+        DivineVoxelEngineGenerator.instance = this;
+    }
+}

package/Contexts/{Constructor/ConstrcutorTheads.d.ts → Generator/GeneratorThreads.d.ts}

@@ -1,6 +1,6 @@
 import { ThreadManager } from "../Base/ThreadManager";
-export declare class ConstructorThreadManager extends ThreadManager {
-    static instnace: ConstructorThreadManager;
+export declare class GeneratorThreadsManager extends ThreadManager {
+    static instnace: GeneratorThreadsManager;
     parent: import("@amodx/threads/").Thread;
     world: import("@amodx/threads/").Thread;
     constructor();

package/Contexts/{Constructor/ConstrcutorTheads.js → Generator/GeneratorThreads.js}

@@ -1,13 +1,13 @@
 import { Threads } from "@amodx/threads/";
 import { ThreadManager } from "../Base/ThreadManager";
 const world = Threads.createThread("world");
-export class ConstructorThreadManager extends ThreadManager {
+export class GeneratorThreadsManager extends ThreadManager {
     static instnace;
     parent = Threads.parent;
     world = world;
     constructor() {
         super();
-        ConstructorThreadManager.instnace = this;
+        GeneratorThreadsManager.instnace = this;
         this.addThread(this.world);
         this.addThread(this.parent);
     }

package/Contexts/Generator/index.d.ts

@@ -0,0 +1 @@
+export * from "./DivineVoxelEngineGenerator.js";

package/Contexts/Generator/index.js

@@ -0,0 +1 @@
+export * from "./DivineVoxelEngineGenerator.js";

package/Contexts/Mesher/DivineVoxelEngineMesher.d.ts

@@ -0,0 +1,9 @@
+import { Threads } from "@amodx/threads/";
+import { MesherThreadsManager } from "./MesherTheads.js";
+export declare class DivineVoxelEngineMesher {
+    static environment: "node" | "browser";
+    static instance: DivineVoxelEngineMesher;
+    TC: typeof Threads;
+    threads: MesherThreadsManager;
+    constructor();
+}

package/Contexts/Mesher/DivineVoxelEngineMesher.js

@@ -0,0 +1,14 @@
+//threadcomm
+import { Threads } from "@amodx/threads/";
+import { MesherThreadsManager } from "./MesherTheads.js";
+export class DivineVoxelEngineMesher {
+    static environment = "browser";
+    static instance;
+    TC = Threads;
+    threads = new MesherThreadsManager();
+    constructor() {
+        if (DivineVoxelEngineMesher.instance)
+            return DivineVoxelEngineMesher.instance;
+        DivineVoxelEngineMesher.instance = this;
+    }
+}

package/Contexts/Mesher/MesherTheads.d.ts

@@ -0,0 +1,7 @@
+import { ThreadManager } from "../Base/ThreadManager";
+export declare class MesherThreadsManager extends ThreadManager {
+    static instnace: MesherThreadsManager;
+    parent: import("@amodx/threads/").Thread;
+    world: import("@amodx/threads/").Thread;
+    constructor();
+}

package/Contexts/Mesher/MesherTheads.js

@@ -0,0 +1,14 @@
+import { Threads } from "@amodx/threads/";
+import { ThreadManager } from "../Base/ThreadManager";
+const world = Threads.createThread("world");
+export class MesherThreadsManager extends ThreadManager {
+    static instnace;
+    parent = Threads.parent;
+    world = world;
+    constructor() {
+        super();
+        MesherThreadsManager.instnace = this;
+        this.addThread(this.world);
+        this.addThread(this.parent);
+    }
+}

package/Contexts/Mesher/index.d.ts

@@ -0,0 +1 @@
+export * from "./DivineVoxelEngineMesher.js";

package/Contexts/Mesher/index.js

@@ -0,0 +1 @@
+export * from "./DivineVoxelEngineMesher.js";

package/Contexts/Nexus/NexusTheads.js

@@ -8,5 +8,5 @@ export class NexusThreads extends ThreadManager {
     world = Threads.createThread("world");
     NexusComm = Threads.createThread("nexus");
     DataComm = Threads.createThread("data-loader");
-    ConstructorComm = Threads.createThreadPool("constructor");
+    ConstructorComm = Threads.createThreadPool("generator");
 }

package/Contexts/Render/DVERenderThreads.d.ts

@@ -1,7 +1,8 @@
 import { ThreadManager } from "../Base/ThreadManager";
 export declare class DVERenderThreads extends ThreadManager {
     nexus: import("@amodx/threads").Thread;
-    constructors: import("@amodx/threads").ThreadPool;
+    meshers: import("@amodx/threads").ThreadPool;
+    generators: import("@amodx/threads").ThreadPool;
     parent: import("@amodx/threads").Thread;
     world: import("@amodx/threads").Thread;
     constructor();

package/Contexts/Render/DVERenderThreads.js

@@ -2,12 +2,14 @@ import { Threads } from "@amodx/threads";
 import { ThreadManager } from "../Base/ThreadManager";
 export class DVERenderThreads extends ThreadManager {
     nexus = Threads.createThread("nexus");
-    constructors = Threads.createThreadPool("constructor");
+    meshers = Threads.createThreadPool("meshers");
+    generators = Threads.createThreadPool("generators");
     parent = Threads.parent;
     world = Threads.createThread("world");
     constructor() {
         super();
-        this.addThread(this.constructors);
+        this.addThread(this.meshers);
+        this.addThread(this.generators);
         this.addThread(this.parent);
         this.addThread(this.world);
     }

package/Contexts/Render/DivineVoxelEngineRender.d.ts

@@ -8,7 +8,8 @@ import { DVERenderThreads } from "./DVERenderThreads.js";
 type PartialEngineSettings = RecursivePartial<EngineSettingsData>;
 export interface DVERInitData extends PartialEngineSettings {
     worldWorker: Worker;
-    constructorWorkers: Worker[];
+    mesherWorkers: Worker[];
+    generatorWorkers: Worker[];
     renderer: DVERenderer;
     nexusWorker?: Worker;
 }
@@ -24,9 +25,19 @@ export declare class DivineVoxelEngineRender {
         readonly doRGBPropagation: boolean;
         readonly doLight: boolean;
         readonly doFlow: boolean;
+        readonly doPower: boolean;
         getSettings(): EngineSettingsData;
         syncSettings(data: EngineSettingsData): void;
         getSettingsCopy(): any;
+        createEventListener<K extends "synced">(type: K, listener: EventListenerObject | ((event: CustomEvent<{
+            synced: {
+                settings: any;
+            };
+        }[K]>) => void) | null): EventListenerObject | ((event: CustomEvent<{
+            synced: {
+                settings: any;
+            };
+        }[K]>) => void) | null;
         addEventListener<K extends "synced">(type: K, listener: EventListenerObject | ((event: CustomEvent<{
             synced: {
                 settings: any;

package/Contexts/Render/DivineVoxelEngineRender.js

@@ -24,9 +24,14 @@ export class DivineVoxelEngineRender {
      */
     async clearAll() {
         this.meshRegister.clearAll();
-        await this.threads.world.runTaskAsync("clear-all", "");
-        await Promise.all(this.threads.constructors
-            .getThreads()
-            .map((_) => _.runTaskAsync("clear-all", "")));
+        await Promise.all([
+            this.threads.world.runTaskAsync("clear-all", ""),
+            ...this.threads.meshers
+                .getThreads()
+                .map((_) => _.runTaskAsync("clear-all", "")),
+            ...this.threads.generators
+                .getThreads()
+                .map((_) => _.runTaskAsync("clear-all", "")),
+        ]);
     }
 }

package/Contexts/World/DivineVoxelEngineWorld.d.ts

@@ -16,9 +16,19 @@ export declare class DivineVoxelEngineWorld {
         readonly doRGBPropagation: boolean;
         readonly doLight: boolean;
         readonly doFlow: boolean;
+        readonly doPower: boolean;
         getSettings(): import("../../Settings/EngineSettings.types.js").EngineSettingsData;
         syncSettings(data: import("../../Settings/EngineSettings.types.js").EngineSettingsData): void;
         getSettingsCopy(): any;
+        createEventListener<K extends "synced">(type: K, listener: EventListenerObject | ((event: CustomEvent<{
+            synced: {
+                settings: any;
+            };
+        }[K]>) => void) | null): EventListenerObject | ((event: CustomEvent<{
+            synced: {
+                settings: any;
+            };
+        }[K]>) => void) | null;
         addEventListener<K extends "synced">(type: K, listener: EventListenerObject | ((event: CustomEvent<{
             synced: {
                 settings: any;

package/Contexts/World/WorldThreads.d.ts

@@ -1,6 +1,7 @@
 import { ThreadManager } from "../Base/ThreadManager.js";
 export declare class WorldThreadManager extends ThreadManager {
-    constructors: import("@amodx/threads/").ThreadPool;
+    meshers: import("@amodx/threads/").ThreadPool;
+    generators: import("@amodx/threads/").ThreadPool;
     parent: import("@amodx/threads/").Thread;
     nexus: import("@amodx/threads/").Thread;
     constructor();

package/Contexts/World/WorldThreads.js

@@ -1,12 +1,14 @@
 import { Threads } from "@amodx/threads/";
 import { ThreadManager } from "../Base/ThreadManager.js";
 export class WorldThreadManager extends ThreadManager {
-    constructors = Threads.createThreadPool("constructor");
+    meshers = Threads.createThreadPool("meshers");
+    generators = Threads.createThreadPool("generators");
     parent = Threads.parent;
     nexus = Threads.createThread("nexus");
     constructor() {
         super();
-        this.addThread(this.constructors);
+        this.addThread(this.meshers);
+        this.addThread(this.generators);
         this.addThread(this.parent);
     }
 }

package/Init/StartGenerator.d.ts

@@ -0,0 +1,2 @@
+import { DivineVoxelEngineGenerator } from "../Contexts/Generator";
+export declare function StartGenerator(data?: {}): Promise<DivineVoxelEngineGenerator>;

package/Init/StartGenerator.js

@@ -0,0 +1,45 @@
+import InitDataSync from "../Contexts/Base/Remote/InitDataSync";
+import { Threads } from "@amodx/threads";
+import { Environment } from "../Util/Environment";
+import { WorldRegister } from "../World/WorldRegister";
+import InitUpdateTasks from "../Tasks/Paint/InitTasks";
+import InitPropagationTasks from "../Tasks/Propagation/InitTasks";
+import InitWorldGenerationTasks from "../Tasks/WorldGeneration/InitTasks";
+import InitWorldDataSync from "../Contexts/Base/Remote/InitWorldDataSync";
+import InitArchiveTasks from "../World/Archive/InitTasks";
+import { DivineVoxelEngineGenerator } from "../Contexts/Generator";
+export async function StartGenerator(data = {}) {
+    WorldRegister.proxy = true;
+    const DVEG = new DivineVoxelEngineGenerator();
+    DivineVoxelEngineGenerator.environment = Environment.isNode()
+        ? "node"
+        : "browser";
+    let parent = "render";
+    if (DivineVoxelEngineGenerator.environment == "node") {
+        parent = "server";
+    }
+    await Threads.init("generator", self, parent);
+    let ready = false;
+    InitDataSync({
+        onSync(data) {
+            ready = true;
+        },
+    });
+    Threads.registerTask("clear-all", () => {
+        WorldRegister.clearAll();
+    });
+    await new Promise((resolve) => {
+        const readyCheck = () => {
+            if (ready)
+                return resolve(true);
+            setTimeout(readyCheck, 10);
+        };
+        readyCheck();
+    });
+    InitArchiveTasks({ worldThread: DVEG.threads.world });
+    InitWorldDataSync(DVEG.threads.world);
+    InitPropagationTasks();
+    InitUpdateTasks();
+    InitWorldGenerationTasks({ worldThread: DVEG.threads.world });
+    return DVEG;
+}

package/Init/StartMesher.d.ts

@@ -0,0 +1,2 @@
+import { DivineVoxelEngineMesher } from "../Contexts/Mesher";
+export declare function StartMesher(data?: {}): Promise<DivineVoxelEngineMesher>;

package/Init/StartMesher.js

@@ -0,0 +1,41 @@
+import InitDataSync from "../Contexts/Base/Remote/InitDataSync";
+import { Threads } from "@amodx/threads";
+import { Environment } from "../Util/Environment";
+import { WorldRegister } from "../World/WorldRegister";
+import InitMesherTasks from "../Mesher/InitTask";
+import InitWorldDataSync from "../Contexts/Base/Remote/InitWorldDataSync";
+import InitMesher from "../Mesher/InitMesher";
+import { DivineVoxelEngineMesher } from "../Contexts/Mesher";
+export async function StartMesher(data = {}) {
+    WorldRegister.proxy = true;
+    const DVEM = new DivineVoxelEngineMesher();
+    DivineVoxelEngineMesher.environment = Environment.isNode()
+        ? "node"
+        : "browser";
+    let parent = "render";
+    if (DivineVoxelEngineMesher.environment == "node") {
+        parent = "server";
+    }
+    await Threads.init("mesher", self, parent);
+    let ready = false;
+    InitDataSync({
+        onSync(data) {
+            InitMesher(data.voxels.materials.palette, data.voxels.models);
+            ready = true;
+        },
+    });
+    Threads.registerTask("clear-all", () => {
+        WorldRegister.clearAll();
+    });
+    await new Promise((resolve) => {
+        const readyCheck = () => {
+            if (ready)
+                return resolve(true);
+            setTimeout(readyCheck, 10);
+        };
+        readyCheck();
+    });
+    InitWorldDataSync(DVEM.threads.world);
+    InitMesherTasks(DVEM.threads.parent);
+    return DVEM;
+}

package/Init/StartNexus.js

@@ -3,7 +3,9 @@ import { DivineVoxelEngineNexus } from "../Contexts/Nexus/DivineVoxelEngineNexus
 import { Environment } from "../Util/Environment";
 import { Threads } from "@amodx/threads";
 import InitWorldDataSync from "../Contexts/Base/Remote/InitWorldDataSync";
+import { WorldRegister } from "../World/WorldRegister";
 export async function StartNexus(data = {}) {
+    WorldRegister.proxy = true;
     const DVEN = new DivineVoxelEngineNexus(data || {});
     DivineVoxelEngineNexus.environment = Environment.isNode()
         ? "node"
@@ -12,14 +14,14 @@ export async function StartNexus(data = {}) {
     if (DivineVoxelEngineNexus.environment == "node") {
         parent = "server";
     }
-    await Threads.init("constructor", self, parent);
+    await Threads.init("generator", self, parent);
     let ready = false;
     InitDataSync({
         onSync(data) {
             ready = true;
         },
     });
-    InitWorldDataSync();
+    InitWorldDataSync(DVEN.threads.world);
     await new Promise((resolve) => {
         const readyCheck = () => {
             if (ready)

package/Init/StartRenderer.d.ts

@@ -1,5 +1,8 @@
 import { DivineVoxelEngineRender, DVERInitData } from "../Contexts/Render";
 import { InitVoxelDataProps } from "../Voxels/InitVoxelData";
-type StartRendererProps = {} & DVERInitData & InitVoxelDataProps;
+import { WorkItemProgress } from "../Util/WorkItemProgress";
+type StartRendererProps = {
+    getProgress?: (progress: WorkItemProgress) => void;
+} & DVERInitData & InitVoxelDataProps;
 export declare function StartRenderer(initData: StartRendererProps): Promise<DivineVoxelEngineRender>;
 export {};

package/Init/StartRenderer.js

@@ -5,9 +5,16 @@ import InitWorldDataSync from "../Contexts/Base/Remote/InitWorldDataSync";
 import InitRendererTasks from "../Renderer/InitTasks";
 import InitMesher from "../Mesher/InitMesher";
 import { MeshManager } from "../Renderer/MeshManager";
+import { WorldRegister } from "../World/WorldRegister";
+import { WorkItemProgress } from "../Util/WorkItemProgress";
 export async function StartRenderer(initData) {
     const DVER = new DivineVoxelEngineRender();
+    const progress = new WorkItemProgress();
+    if (initData.getProgress)
+        initData.getProgress(progress);
+    progress.startTask("load");
     await Threads.init("render", window, "window");
+    WorldRegister.proxy = true;
     DivineVoxelEngineRender.initialized = true;
     DVER.renderer = initData.renderer;
     MeshManager.sectorMeshes = initData.renderer.sectorMeshes;
@@ -20,13 +27,38 @@ export async function StartRenderer(initData) {
         throw Error("Supplied data for World Worker is not correct. Must be path to worker or a worker.");
     }
     DVER.threads.setThreadPort(DVER.threads.world.name, initData.worldWorker);
-    if (Array.isArray(initData.constructorWorkers) &&
-        initData.constructorWorkers[0] instanceof Worker) {
-        DVER.threads.setThreadPort(DVER.threads.constructors.name, initData.constructorWorkers);
+    if (Array.isArray(initData.mesherWorkers) &&
+        initData.mesherWorkers[0] instanceof Worker) {
+        DVER.threads.setThreadPort(DVER.threads.meshers.name, initData.mesherWorkers);
     }
     else {
-        throw Error("Supplied data for the Constructor Workers is not correct. Must be path to worker or an array workers.");
+        throw Error("Supplied data for the Mesher Workers is not correct. Must be path to worker or an array workers.");
     }
+    if (Array.isArray(initData.generatorWorkers) &&
+        initData.generatorWorkers[0] instanceof Worker) {
+        DVER.threads.setThreadPort(DVER.threads.generators.name, initData.generatorWorkers);
+    }
+    else {
+        throw Error("Supplied data for the Generator Workers is not correct. Must be path to worker or an array workers.");
+    }
+    const proms = [];
+    for (const thread of DVER.threads._threads) {
+        if (thread.name == "window" || thread.name == "world")
+            continue;
+        if (thread instanceof ThreadPool) {
+            for (const t of thread.getThreads()) {
+                proms.push(t.waitTillTaskExist("sync-data"));
+                DVER.threads.world.connectToThread(t);
+            }
+        }
+        if (thread instanceof Thread) {
+            proms.push(thread.waitTillTaskExist("sync-data"));
+            DVER.threads.world.connectToThread(thread);
+        }
+    }
+    proms.push(DVER.threads.world.waitTillTaskExist("sync-data"));
+    progress.setStatus("Generate Data");
+    await progress.wait(100);
     const syncData = InitDataGenerator({
         threads: {
             nexus: initData.nexusWorker ? true : false,
@@ -35,27 +67,40 @@ export async function StartRenderer(initData) {
         substances: initData.substances || [],
         materials: initData.materials || [],
     });
-    InitRendererTasks(DVER.threads.constructors);
-    InitWorldDataSync();
+    progress.setWorkLoad(5);
+    progress.setStatus("Init Threads");
+    await progress.wait(100);
+    InitRendererTasks();
+    InitWorldDataSync(DVER.threads.world);
     InitMesher(syncData.voxels.materials.palette, syncData.voxels.models);
+    progress.completeWorkItems(1);
+    progress.setStatus("Waiting For Threads");
+    await Promise.all(proms);
+    progress.completeWorkItems(1);
+    progress.setStatus("Sending Data");
+    await progress.wait(100);
+    proms.length = 0;
     for (const thread of DVER.threads._threads) {
         if (thread.name == "window" || thread.name == "world")
             continue;
         if (thread instanceof ThreadPool) {
             for (const t of thread.getThreads()) {
-                await t.waitTillTaskExist("sync-data");
-                DVER.threads.world.connectToThread(t);
-                await t.runTaskAsync("sync-data", syncData);
+                proms.push(t.runTaskAsync("sync-data", syncData));
             }
         }
         if (thread instanceof Thread) {
-            await thread.waitTillTaskExist("sync-data");
-            DVER.threads.world.connectToThread(thread);
-            await thread.runTaskAsync("sync-data", syncData);
+            proms.push(thread.runTaskAsync("sync-data", syncData));
         }
     }
-    await DVER.threads.world.waitTillTaskExist("sync-data");
-    await DVER.threads.world.runTaskAsync("sync-data", syncData);
+    proms.push(DVER.threads.world.runTaskAsync("sync-data", syncData));
+    await Promise.all(proms);
+    progress.completeWorkItems(1);
+    progress.setStatus("Init Renderer");
+    await progress.wait(100);
     await DVER.renderer.init(DVER);
+    progress.completeWorkItems(1);
+    progress.setStatus("Done");
+    await progress.wait(100);
+    progress.endTask();
     return DVER;
 }

package/Init/StartWorld.js

@@ -33,7 +33,8 @@ export async function StartWorld(props = {}) {
     });
     const threads = [
         DVEW.threads.parent,
-        ...DVEW.threads.constructors.getThreads(),
+        ...DVEW.threads.meshers.getThreads(),
+        ...DVEW.threads.generators.getThreads(),
     ];
     if (DVEW.threads.nexus.isPortSet) {
         threads.push(DVEW.threads.nexus);

package/LICENSE.md

@@ -1,5 +1,6 @@
+@divinevoxel/vlox
 The MIT License (MIT)
-Copyright © 2024 Divine Star LLC
+Copyright © 2025 Divine Star LLC
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: