@divinevoxel/vlox 0.0.4 → 0.0.6

package/Init/StartNexus.js

@@ -1,19 +1,18 @@
-import InitDataSync from "../Contexts/Base/Remote/Sync/InitDataSync";
+import InitDataSync from "../Contexts/Base/Remote/InitDataSync";
 import { DivineVoxelEngineNexus } from "../Contexts/Nexus/DivineVoxelEngineNexus";
-import { Environment } from "@amodx/core/Environment/Environment";
+import { Environment } from "../Util/Environment";
 import { Threads } from "@amodx/threads";
-import { CreatePromiseCheck } from "@amodx/core/Intervals/CreatePromiseCheck";
-import InitWorldDataSync from "../Contexts/Base/Remote/Sync/InitWorldDataSync";
+import InitWorldDataSync from "../Contexts/Base/Remote/InitWorldDataSync";
 export async function StartNexus(data = {}) {
     const DVEN = new DivineVoxelEngineNexus(data || {});
-    DivineVoxelEngineNexus.environment = Environment.nodeJS.isNode
+    DivineVoxelEngineNexus.environment = Environment.isNode()
         ? "node"
         : "browser";
     let parent = "render";
     if (DivineVoxelEngineNexus.environment == "node") {
         parent = "server";
     }
-    await Threads.init("constructor", parent);
+    await Threads.init("constructor", self, parent);
     let ready = false;
     InitDataSync({
         onSync(data) {
@@ -21,9 +20,13 @@ export async function StartNexus(data = {}) {
         },
     });
     InitWorldDataSync();
-    await CreatePromiseCheck({
-        check: () => ready,
-        checkInterval: 1,
+    await new Promise((resolve) => {
+        const readyCheck = () => {
+            if (ready)
+                return resolve(true);
+            setTimeout(readyCheck, 10);
+        };
+        readyCheck();
     });
     return DVEN;
 }

package/Init/StartRenderer.d.ts

@@ -1,15 +1,5 @@
 import { DivineVoxelEngineRender, DVERInitData } from "../Contexts/Render";
-import { VoxelData } from "../Voxels/Voxel.types";
-import { VoxelGeometryData, VoxelModelData } from "../Models/VoxelModel.types";
-import { VoxelSubstanceData } from "Voxels/VoxelSubstances.types";
-type StartRendererProps = {
-    voxels: VoxelData[];
-    geometry?: VoxelGeometryData[];
-    models?: VoxelModelData[];
-    substances?: VoxelSubstanceData[];
-    materials?: {
-        id: string;
-    }[];
-} & DVERInitData;
+import { InitVoxelDataProps } from "../Voxels/InitVoxelData";
+type StartRendererProps = {} & DVERInitData & InitVoxelDataProps;
 export declare function StartRenderer(initData: StartRendererProps): Promise<DivineVoxelEngineRender>;
 export {};

package/Init/StartRenderer.js

@@ -1,33 +1,32 @@
-import { InitVoxelData } from "../Voxels/InitVoxelData";
 import { DivineVoxelEngineRender } from "../Contexts/Render";
-import InitDataGenerator from "../Contexts/Base/Main/Generator/InitDataGenerator";
-import { Thread, ThreadPool } from "@amodx/threads";
-import InitWorldDataSync from "../Contexts/Base/Remote/Sync/InitWorldDataSync";
+import InitDataGenerator from "../Contexts/Base/Main/InitDataGenerator";
+import { Threads, Thread, ThreadPool } from "@amodx/threads";
+import InitWorldDataSync from "../Contexts/Base/Remote/InitWorldDataSync";
+import InitRendererTasks from "../Renderer/InitTasks";
+import InitMesher from "../Mesher/InitMesher";
+import { MeshManager } from "../Renderer/MeshManager";
 export async function StartRenderer(initData) {
     const DVER = new DivineVoxelEngineRender();
+    await Threads.init("render", window, "window");
     DivineVoxelEngineRender.initialized = true;
     DVER.renderer = initData.renderer;
+    MeshManager.sectorMeshes = initData.renderer.sectorMeshes;
     if (initData.nexusWorker) {
         DVER.threads.nexus.setPort(initData.nexusWorker);
         DVER.threads.addThread(DVER.threads.nexus);
     }
-    await DVER.renderer.init(DVER);
-    const t = performance.now();
     DVER.settings.syncSettings(initData);
-    await DVER.TC.init("render", "global");
     if (!(initData.worldWorker instanceof Worker)) {
         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.construcotrs.name, initData.constructorWorkers);
+        DVER.threads.setThreadPort(DVER.threads.constructors.name, initData.constructorWorkers);
     }
     else {
         throw Error("Supplied data for the Constructor Workers is not correct. Must be path to worker or an array workers.");
     }
-    const t2 = performance.now();
-    console.log("DONE INIT VOXEL DATA", performance.now() - t2);
     const syncData = InitDataGenerator({
         threads: {
             nexus: initData.nexusWorker ? true : false,
@@ -35,50 +34,28 @@ export async function StartRenderer(initData) {
         voxels: initData.voxels,
         substances: initData.substances || [],
         materials: initData.materials || [],
-        // voxelModels: modelSyncData,
     });
+    InitRendererTasks(DVER.threads.constructors);
     InitWorldDataSync();
-    const modelSyncData = await InitVoxelData({
-        geometry: initData.geometry,
-        models: initData.models,
-        voxels: initData.voxels,
-    });
-    syncData.modelData = modelSyncData;
-    //make sure threads are ready
-    await DVER.threads.world.waitTillTasksExist("sync-data");
-    for (const thread of DVER.threads.construcotrs.getThreads()) {
-        await thread.waitTillTasksExist("sync-data");
-    }
-    //sync threads
-    for (const thread of DVER.threads.construcotrs.getThreads()) {
-        DVER.threads.world.connectToThread(thread);
-    }
-    if (initData.nexusWorker) {
-        DVER.threads.world.connectToThread(DVER.threads.nexus);
-    }
-    //send data to threads
-    for (const thread of DVER.threads.comms) {
+    InitMesher(syncData.voxels.materials.palette, syncData.voxels.models);
+    for (const thread of DVER.threads._threads) {
+        if (thread.name == "window" || thread.name == "world")
+            continue;
         if (thread instanceof ThreadPool) {
-            for (const com of thread.getThreads()) {
-                com.runTasks("sync-data", syncData);
+            for (const t of thread.getThreads()) {
+                await t.waitTillTaskExist("sync-data");
+                DVER.threads.world.connectToThread(t);
+                await t.runTaskAsync("sync-data", syncData);
             }
         }
         if (thread instanceof Thread) {
-            if (thread == DVER.threads.parent)
-                continue;
-            thread.runTasks("sync-data", syncData);
+            await thread.waitTillTaskExist("sync-data");
+            DVER.threads.world.connectToThread(thread);
+            await thread.runTaskAsync("sync-data", syncData);
         }
     }
-    console.log("DONE INIT DVE", performance.now() - t);
-    window.addEventListener("beforeunload", () => {
-        for (const thread of DVER.threads.comms) {
-            if (thread instanceof ThreadPool) {
-                thread.destroyAll();
-            }
-            if (thread instanceof Thread) {
-                thread.destroy();
-            }
-        }
-    });
+    await DVER.threads.world.waitTillTaskExist("sync-data");
+    await DVER.threads.world.runTaskAsync("sync-data", syncData);
+    await DVER.renderer.init(DVER);
     return DVER;
 }

package/Init/StartWorld.d.ts

@@ -1,4 +1,7 @@
 import { DivineVoxelEngineWorld } from "../Contexts/World/DivineVoxelEngineWorld";
-type StartWorldProps = {};
+import { WorldStorageInterface } from "World/Storage/WorldStorage.interface";
+type StartWorldProps = {
+    worldStorage?: WorldStorageInterface;
+};
 export declare function StartWorld(props?: StartWorldProps): Promise<DivineVoxelEngineWorld>;
 export {};

package/Init/StartWorld.js

@@ -1,21 +1,13 @@
-import InitDataSync from "../Contexts/Base/Remote/Sync/InitDataSync";
+import InitDataSync from "../Contexts/Base/Remote/InitDataSync";
 import { DivineVoxelEngineWorld } from "../Contexts/World/DivineVoxelEngineWorld";
 import { Threads } from "@amodx/threads/";
-import { CreatePromiseCheck } from "@amodx/core/Intervals/CreatePromiseCheck.js";
-import { WorldLock } from "../Contexts/World/Lock/WorldLock";
-import InitWorldTasks from "../Contexts/World/Tasks/WorldTasks";
-import { DataLoaderTool } from "../Tasks/DataLoader/World/Tools/DataLoaderTool";
-import { DataHooks } from "../Contexts/Base/DataHooks";
-import { Chunk, Column, Region } from "../Data/World/Classes";
-import { Environment } from "@amodx/core/Environment/Environment";
+import InitWorldTasks from "../World/InitTasks";
+import { Environment } from "../Util/Environment";
 import { VoxelTagStates } from "../Voxels/State/VoxelTagStates";
 import { SchemaRegister } from "../Voxels/State/SchemaRegister";
-import { WorldRegister } from "../Data/World/WorldRegister";
 export async function StartWorld(props = {}) {
-    const register = new WorldRegister();
     const DVEW = new DivineVoxelEngineWorld();
-    InitWorldTasks(DVEW);
-    DivineVoxelEngineWorld.environment = Environment.nodeJS.isNode
+    DivineVoxelEngineWorld.environment = Environment.isNode()
         ? "node"
         : "browser";
     Threads.threadName = "world";
@@ -23,7 +15,7 @@ export async function StartWorld(props = {}) {
     if (DivineVoxelEngineWorld.environment == "node") {
         parent = "server";
     }
-    await Threads.init("world", parent);
+    await Threads.init("world", self, parent);
     let ready = false;
     InitDataSync({
         onSync(data) {
@@ -43,91 +35,24 @@ export async function StartWorld(props = {}) {
             ready = true;
         },
     });
-    DataHooks.chunk.onGetAsync.regiser("world", async (data) => {
-        data.chunk = Chunk.CreateNew();
-        return data;
-    });
-    DataHooks.chunk.onGetSync.regiser("world", (data) => {
-        data.chunk = Chunk.CreateNew();
-        return data;
-    });
-    DataHooks.chunk.onNew.subscribe("world", (data) => {
-        DVEW.dataSync.worldData.chunk.sync(data);
-    });
-    DataHooks.chunk.onRemove.subscribe("world", (data) => {
-        /*     if (!dataLoaderTool) {
-          DVEW.dataSync.worldData.chunk.unSync(data);
-          return;
-        }
-        dataLoaderTool.setLocation(data).saveColumn(() => {
-          DVEW.dataSync.worldData.chunk.unSync(data);
-        }); */
-    });
-    /*
-  [columns]
-  */
-    DataHooks.column.onGetAsync.regiser("world", async (data) => {
-        data.column = Column.CreateNew({});
-        return data;
-    });
-    DataHooks.column.onGetSync.regiser("world", (data) => {
-        data.column = Column.CreateNew({});
-        return data;
-    });
-    DataHooks.column.onNew.subscribe("world", (data) => {
-        DVEW.dataSync.worldData.column.sync(data);
-    });
-    DataHooks.column.onRemove.subscribe("world", (data) => {
-        /*     if (!dataLoaderTool) {
-        DVEW.dataSync.worldData.column.unSync(data);
-        return;
-      }
-      dataLoaderTool.setLocation(data).saveColumn(() => {
-        DVEW.dataSync.worldData.column.unSync(data);
-      }); */
-    });
-    /*
-  [region]
-  */
-    DataHooks.region.onGetAsync.regiser("world", async (data) => {
-        data.region = Region.CreateNew();
-        return data;
-    });
-    DataHooks.region.onGetSync.regiser("world", (data) => {
-        data.region = Region.CreateNew();
-        return data;
-    });
-    DataHooks.region.onNew.subscribe("world", (data) => {
-        DVEW.dataSync.worldData.region.sync(data);
-    });
-    DataHooks.region.onRemove.subscribe("world", (data) => {
-        /*     if (!dataLoaderTool) {
-      DVEW.dataSync.worldData.column.unSync(data);
-      return;
+    await new Promise((resolve) => {
+        const readyCheck = () => {
+            if (ready)
+                return resolve(true);
+            setTimeout(readyCheck, 10);
+        };
+        readyCheck();
+    });
+    const threads = [
+        DVEW.threads.parent,
+        ...DVEW.threads.constructors.getThreads(),
+    ];
+    if (DVEW.threads.nexus.isPortSet) {
+        threads.push(DVEW.threads.nexus);
     }
-    dataLoaderTool.setLocation(data).saveColumn(() => {
-      DVEW.dataSync.worldData.column.unSync(data);
-    }); */
-    });
-    /*
-  [paint]
-  */
-    DataHooks.paint.onRichVoxelPaint.subscribe("world", (data) => {
-        // DVEW.richworld.setInitalData(data);
-    });
-    /*
-  [dimensions]
-  */
-    DataHooks.dimension.onRegisterDimension.regiser("world", (data) => {
-        DVEW.queues.addQueue(data.id);
-        DVEW.dataSync.worldData.dimesnion.sync(data.id);
-        return data;
-    });
-    WorldLock.init(new DataLoaderTool());
-    await CreatePromiseCheck({
-        check: () => ready,
-        checkInterval: 1,
+    InitWorldTasks({
+        threads,
+        worldStorage: props.worldStorage,
     });
-    await DVEW.dataSync.init(DVEW);
     return DVEW;
 }

package/Math/Indexing.d.ts

@@ -0,0 +1,12 @@
+import { Vec3Array, Vector3Like } from "@amodx/math";
+export declare function CubeHashVec3Array(positionX: number, positionY: number, positionZ: number, xPower2: number, yPower2: number, zPower2: number, positionRef?: Vec3Array): Vec3Array;
+export declare function CubeHashVec3(positionX: number, positionY: number, positionZ: number, xPower2: number, yPower2: number, zPower2: number, positionRef?: Vector3Like): Vector3Like;
+export declare function GetXYZOrderArrayPositionVec3Array(index: number, boundsX: number, boundsY: number, boundsZ: number, positionRef?: Vec3Array): Vec3Array;
+export declare function GetXYZOrderArrayPositionVec3(index: number, boundsX: number, boundsY: number, boundsZ: number, positionRef?: Vector3Like): Vector3Like;
+export declare function GetXYZOrderArrayIndex(positionX: number, positionY: number, positionZ: number, boundsX: number, boundsY: number, boundsZ: number): number;
+export declare function GetXZYOrderArrayPositionVec3Array(index: number, boundsX: number, boundsY: number, boundsZ: number, positionRef?: Vec3Array): Vec3Array;
+export declare function GetXZYOrderArrayPositionVec3(index: number, boundsX: number, boundsY: number, boundsZ: number, positionRef?: Vector3Like): Vector3Like;
+export declare function GetXZYOrderArrayIndex(positionX: number, positionY: number, positionZ: number, boundsX: number, boundsY: number, boundsZ: number): number;
+export declare function GetYXZOrderArrayPositionVec3Array(index: number, boundsX: number, boundsY: number, boundsZ: number, positionRef?: Vec3Array): Vec3Array;
+export declare function GetYXZOrderArrayPositionVec3(index: number, boundsX: number, boundsY: number, boundsZ: number, positionRef?: Vector3Like): Vector3Like;
+export declare function GetYXZOrderArrayIndex(positionX: number, positionY: number, positionZ: number, boundsX: number, boundsY: number, boundsZ: number): number;

package/Math/Indexing.js

@@ -0,0 +1,58 @@
+import { Vector3Like } from "@amodx/math";
+export function CubeHashVec3Array(positionX, positionY, positionZ, xPower2, yPower2, zPower2, positionRef = [0, 0, 0]) {
+    positionRef[0] = (positionX >> xPower2) << xPower2;
+    positionRef[1] = (positionY >> yPower2) << yPower2;
+    positionRef[2] = (positionZ >> zPower2) << zPower2;
+    return positionRef;
+}
+export function CubeHashVec3(positionX, positionY, positionZ, xPower2, yPower2, zPower2, positionRef = Vector3Like.Create()) {
+    positionRef.x = (positionX >> xPower2) << xPower2;
+    positionRef.y = (positionY >> yPower2) << yPower2;
+    positionRef.z = (positionZ >> zPower2) << zPower2;
+    return positionRef;
+}
+export function GetXYZOrderArrayPositionVec3Array(index, boundsX, boundsY, boundsZ, positionRef = [0, 0, 0]) {
+    positionRef[2] = index / (boundsX * boundsY);
+    positionRef[1] = (index % (boundsX * boundsY)) / boundsX;
+    positionRef[0] = index % boundsX;
+    return positionRef;
+}
+export function GetXYZOrderArrayPositionVec3(index, boundsX, boundsY, boundsZ, positionRef = Vector3Like.Create()) {
+    positionRef.z = index / (boundsX * boundsY);
+    positionRef.y = (index % (boundsX * boundsY)) / boundsX;
+    positionRef.x = index % boundsX;
+    return positionRef;
+}
+export function GetXYZOrderArrayIndex(positionX, positionY, positionZ, boundsX, boundsY, boundsZ) {
+    return positionX + positionY * boundsX + positionZ * boundsX * boundsY;
+}
+export function GetXZYOrderArrayPositionVec3Array(index, boundsX, boundsY, boundsZ, positionRef = [0, 0, 0]) {
+    positionRef[1] = index / (boundsX * boundsY);
+    positionRef[2] = (index % (boundsX * boundsY)) / boundsX;
+    positionRef[0] = index % boundsX;
+    return positionRef;
+}
+export function GetXZYOrderArrayPositionVec3(index, boundsX, boundsY, boundsZ, positionRef = Vector3Like.Create()) {
+    positionRef.y = index / (boundsX * boundsY);
+    positionRef.z = (index % (boundsX * boundsY)) / boundsX;
+    positionRef.x = index % boundsX;
+    return positionRef;
+}
+export function GetXZYOrderArrayIndex(positionX, positionY, positionZ, boundsX, boundsY, boundsZ) {
+    return positionX + positionY * boundsX + positionZ * boundsX * boundsZ;
+}
+export function GetYXZOrderArrayPositionVec3Array(index, boundsX, boundsY, boundsZ, positionRef = [0, 0, 0]) {
+    positionRef[1] = index / (boundsX * boundsZ);
+    positionRef[0] = (index % (boundsX * boundsZ)) / boundsZ;
+    positionRef[2] = index % boundsZ;
+    return positionRef;
+}
+export function GetYXZOrderArrayPositionVec3(index, boundsX, boundsY, boundsZ, positionRef = Vector3Like.Create()) {
+    positionRef.y = index / (boundsX * boundsZ);
+    positionRef.x = (index % (boundsX * boundsZ)) / boundsZ;
+    positionRef.z = index % boundsZ;
+    return positionRef;
+}
+export function GetYXZOrderArrayIndex(positionX, positionY, positionZ, boundsX, boundsY, boundsZ) {
+    return positionZ + boundsZ * (positionX + boundsX * positionY);
+}

package/Math/index.d.ts

@@ -1,11 +1,8 @@
-export * from "./VoxelMath.js";
-export * from "./Classes/BoundingBox.js";
-export * from "./Classes/Plane.js";
-export * from "./Classes/SimpleBoundingBox.js";
-export * from "./Classes/Vector3.js";
-export * from "./Classes/Vector3.js";
-export * from "./VisitAll.js";
-export * from "./Math.types.js";
-export * from "./Constants/VoxelFaces.js";
-export * from "./Spaces/VoxelSpaces.types.js";
-export * from "./Constants/VoxelFaces.js";
+export * from "./VoxelFaces.js";
+export * from "./VoxelFaces.js";
+export type LocationData = [
+    dimensionId: string,
+    x: number,
+    y: number,
+    z: number
+];

package/Math/index.js

@@ -1,11 +1,2 @@
-export * from "./VoxelMath.js";
-export * from "./Classes/BoundingBox.js";
-export * from "./Classes/Plane.js";
-export * from "./Classes/SimpleBoundingBox.js";
-export * from "./Classes/Vector3.js";
-export * from "./Classes/Vector3.js";
-export * from "./VisitAll.js";
-export * from "./Math.types.js";
-export * from "./Constants/VoxelFaces.js";
-export * from "./Spaces/VoxelSpaces.types.js";
-export * from "./Constants/VoxelFaces.js";
+export * from "./VoxelFaces.js";
+export * from "./VoxelFaces.js";

package/Mesher/Functions/CompactMesh.d.ts

@@ -1,3 +1,2 @@
-import { MesherDataTool } from "@amodx/meshing";
-import { CompactMeshData } from "../Types/Mesher.types";
-export declare function CompactMesh(materialId: string, tool: MesherDataTool): CompactMeshData;
+import { MesherDataTool } from "../Geomtry/Tools/MesherDataTools";
+export declare function CompactMesh(materialId: string, tool: MesherDataTool): void;

package/Mesher/Functions/CompactMesh.js

@@ -1,37 +1,42 @@
-import { MeshDefaultAttributes, } from "@amodx/meshing/MeshData.types";
-import { EngineSettings } from "../../Settings/EngineSettings";
-import { BinaryNumberTypes, TypedArrayClassMap, MappedByteCounts, } from "@amodx/binary";
 export function CompactMesh(materialId, tool) {
-    let webGPU = EngineSettings.settings.rendererSettings.mode == "webgpu";
-    const mesh = tool.mesh;
-    const dataMap = [materialId, []];
-    let totalSize = 0;
-    for (let [key, [array, stride, type]] of mesh.attributes) {
+    /*   let webGPU = EngineSettings.settings.rendererSettings.mode == "webgpu";
+    
+      const mesh = tool.mesh!;
+      const byteRanges: [
+        byteStart: number,
+        length: number,
+        type: BinaryNumberTypes,
+      ][] = [];
+      const dataMap: CompactSubMesh = [materialId, []];
+      let totalSize = 0;
+      for (let [key, [array, stride, type]] of mesh.attributes) {
         if (key == MeshDefaultAttributes.Indices) {
-            if (array.length > 60_000) {
-                type = BinaryNumberTypes.Uint32;
-            }
+          if (array.length > 60_000) {
+            type = BinaryNumberTypes.Uint32;
+          }
         }
         let current = totalSize;
+    
         totalSize += MappedByteCounts[type] * array.length;
-        dataMap[1].push([
-            key,
-            {},
-            array.length,
-            current,
-            totalSize,
-            stride,
-            type,
-        ]);
-    }
-    const finalBuffer = new ArrayBuffer(totalSize);
-    for (let data of dataMap[1]) {
-        const [id, n, length, startByte, endByte, stride, type] = data;
-        const newArray = new TypedArrayClassMap[type](finalBuffer, 
-        //@ts-ignore
-        startByte, length);
-        newArray.set(mesh.attributes.get(id)[0]);
-        data[1] = newArray;
-    }
-    return [0, finalBuffer, [dataMap]];
+        byteRanges.push([current, array.length, type]);
+        dataMap[1].push([key, array as any, stride]);
+      }
+    
+      const finalBuffer = new ArrayBuffer(totalSize);
+    
+      for (let i = 0; i < dataMap[1].length; i++) {
+        const startByte = byteRanges[i][0];
+        const length = byteRanges[i][1];
+        const type = byteRanges[i][2];
+        const newArray = new TypedArrayClassMap[type](
+          finalBuffer,
+          //@ts-ignore
+          startByte,
+          length
+        ) as Float32Array;
+        newArray.set(dataMap[1][i][0] as any as number[]);
+        dataMap[1][i][1] = newArray;
+      }
+    
+      return [0, finalBuffer, [dataMap]]; */
 }

package/Mesher/Functions/CompactVoxelMesh.d.ts

@@ -1,3 +1,3 @@
 import { CompactMeshData } from "../Types/Mesher.types";
 import { VoxelMesherDataTool } from "Mesher/Tools/VoxelMesherDataTool";
-export declare function CompactVoxelMesh(...tools: VoxelMesherDataTool[]): CompactMeshData;
+export declare function CompactVoxelMesh(tools: VoxelMesherDataTool[]): [data: CompactMeshData, tranfers: ArrayBuffer[]];