@divinevoxel/vlox 0.0.1 → 0.0.3

package/Contexts/Render/Scene/MeshRegister.js

@@ -1,195 +1,218 @@
 import { Vector3Like } from "@amodx/math";
 import { WorldSpaces } from "../../../Data/World/WorldSpaces.js";
-export const MeshRegister = {
-    _dimensions: new Map(),
-    $INIT() {
-        this._dimensions.set("main", new Map());
-    },
-    clearAll() {
-        for (const [dkey, dim] of this._dimensions) {
-            this.dimensions.remove(dkey);
+import { MushRegisterRegion } from "../../../Renderer/Classes/MushRegisterRegion.js";
+import { MeshRegisterColumn } from "../../../Renderer/Classes/MeshRegisterColumn.js";
+import { ChunkMesh } from "../../../Renderer/Classes/ChunkMesh.js";
+class Chunk {
+    static addMesh(location, mesh, substance) {
+        let column = MeshRegister.column.get(location);
+        if (!column) {
+            column = MeshRegister.column.add(location);
         }
-        this._dimensions.set("main", new Map());
-    },
-    dimensions: {
-        add(id) {
-            const dimesnion = new Map();
-            MeshRegister._dimensions.set(id, dimesnion);
-            return dimesnion;
-        },
-        get(id) {
-            return MeshRegister._dimensions.get(id);
-        },
-        *getAllMeshes(id) {
-            const dimension = MeshRegister._dimensions.get(id);
-            if (!dimension)
-                return false;
-            for (const [key, region] of dimension) {
-                for (const [columnKey, column] of region.columns) {
-                    for (const [chunkKey, chunk] of column.chunks) {
-                        for (const [substance, mesh] of chunk) {
-                            yield [
-                                [
-                                    column.location[0],
-                                    column.location[1],
-                                    column.location[2] + chunkKey * WorldSpaces.chunk._bounds.y,
-                                    column.location[3],
-                                ],
-                                substance,
-                                mesh.mesh,
-                            ];
-                        }
-                    }
-                }
-            }
-        },
-        remove(id) {
-            const dimension = MeshRegister._dimensions.get(id);
-            if (!dimension)
-                return false;
-            dimension.forEach((region) => {
-                region.columns.forEach((column) => {
-                    column.chunks.forEach((chunk) => {
-                        chunk.forEach((chunkMeshes) => {
-                            chunkMeshes.mesh.dispose();
-                        });
-                    });
+        const index = WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]);
+        let chunk = column.chunks.get(index);
+        if (!chunk) {
+            chunk = new ChunkMesh([location[1], location[2], location[3]]);
+            column.chunks.set(index, chunk);
+        }
+        chunk?.meshes.set(substance, mesh);
+        return chunk;
+    }
+    static add(location) {
+        let column = MeshRegister.column.get(location);
+        if (!column) {
+            column = MeshRegister.column.add(location);
+        }
+        const index = WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]);
+        let chunk = column.chunks.get(index);
+        if (!chunk) {
+            chunk = new ChunkMesh([location[1], location[2], location[3]]);
+            column.chunks.set(index, chunk);
+        }
+        return chunk;
+    }
+    static removeMesh(location, substance) {
+        const column = MeshRegister.column.get(location);
+        if (!column)
+            return false;
+        const index = WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]);
+        const chunk = column.chunks.get(index);
+        if (!chunk)
+            return false;
+        const chunkMesh = chunk.meshes.get(substance);
+        if (!chunkMesh)
+            return false;
+        chunk.meshes.delete(substance);
+        if (chunk.meshes.size == 0) {
+            column.chunks.delete(index);
+        }
+        return chunkMesh;
+    }
+    static getMesh(location, substance) {
+        const column = MeshRegister.column.get(location);
+        if (!column)
+            return false;
+        const chunk = column.chunks.get(WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]));
+        if (!chunk)
+            return false;
+        const chunkMesh = chunk.meshes.get(substance);
+        if (!chunkMesh)
+            return false;
+        return chunkMesh;
+    }
+    static remove(location) {
+        const column = MeshRegister.column.get(location);
+        if (!column)
+            return false;
+        const index = WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]);
+        const chunk = column.chunks.get(index);
+        if (!chunk)
+            return false;
+        column.chunks.delete(index);
+        return chunk;
+    }
+    static get(location) {
+        const column = MeshRegister.column.get(location);
+        if (!column)
+            return false;
+        const chunk = column.chunks.get(WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]));
+        if (!chunk)
+            return false;
+        return chunk;
+    }
+}
+class Column {
+    static add(location) {
+        let region = MeshRegister.region.get(location);
+        if (!region) {
+            region = MeshRegister.region.add(location);
+        }
+        const column = new MeshRegisterColumn([
+            location[0],
+            ...Vector3Like.ToArray(WorldSpaces.column.getPositionXYZ(location[1], location[2], location[3])),
+        ]);
+        region.columns.set(WorldSpaces.column.getIndexXYZ(location[1], location[2], location[3]), column);
+        return column;
+    }
+    static remove(location) {
+        const region = MeshRegister.region.get(location);
+        if (!region)
+            return false;
+        const index = WorldSpaces.column.getIndexXYZ(location[1], location[2], location[3]);
+        const column = region.columns.get(index);
+        if (!column)
+            return false;
+        region.columns.delete(index);
+        if (region.columns.size == 0) {
+            MeshRegister.region.remove(location);
+        }
+        return column;
+    }
+    static get(location) {
+        const region = MeshRegister.region.get(location);
+        if (!region)
+            return false;
+        return region.columns.get(WorldSpaces.column.getIndexXYZ(location[1], location[2], location[3]));
+    }
+}
+class Region {
+    static add(location) {
+        let dimension = MeshRegister.dimensions.get(location[0]);
+        if (!dimension) {
+            dimension = MeshRegister.dimensions.add(location[0]);
+        }
+        const region = new MushRegisterRegion();
+        dimension.set(WorldSpaces.region.getKeyXYZ(location[1], location[2], location[3]), region);
+        return region;
+    }
+    static remove(location) {
+        const region = this.get(location);
+        if (!region)
+            return false;
+        const dimension = MeshRegister.dimensions.get(location[0]);
+        if (!dimension)
+            return false;
+        dimension.delete(WorldSpaces.region.getKeyXYZ(location[1], location[2], location[3]));
+        region.columns.forEach((column) => {
+            column.chunks.forEach((chunk) => {
+                chunk.meshes.forEach((chunkMeshes) => {
+                    chunkMeshes.dispose();
                 });
             });
-            MeshRegister._dimensions.delete(id);
-            return true;
-        },
-    },
-    region: {
-        add(location) {
-            let dimension = MeshRegister.dimensions.get(location[0]);
-            if (!dimension) {
-                dimension = MeshRegister.dimensions.add(location[0]);
+        });
+        return true;
+    }
+    static get(location) {
+        const dimension = MeshRegister.dimensions.get(location[0]);
+        if (!dimension)
+            return false;
+        const region = dimension.get(WorldSpaces.region.getKeyXYZ(location[1], location[2], location[3]));
+        if (!region)
+            return false;
+        return region;
+    }
+}
+class Dimensions {
+    static add(id) {
+        const dimension = new Map();
+        MeshRegister._dimensions.set(id, dimension);
+        return dimension;
+    }
+    static get(id) {
+        return MeshRegister._dimensions.get(id);
+    }
+    static *getAllMeshes(id) {
+        const dimension = MeshRegister._dimensions.get(id);
+        if (!dimension)
+            return;
+        for (const [key, region] of dimension) {
+            for (const [columnKey, column] of region.columns) {
+                for (const [chunkKey, chunk] of column.chunks) {
+                    for (const [substance, mesh] of chunk.meshes) {
+                        yield [
+                            [
+                                column.location[0],
+                                column.location[1],
+                                column.location[2] + chunkKey * WorldSpaces.chunk._bounds.y,
+                                column.location[3],
+                            ],
+                            substance,
+                            mesh,
+                        ];
+                    }
+                }
             }
-            const region = this._getRegionData();
-            dimension.set(WorldSpaces.region.getKeyXYZ(location[1], location[2], location[3]), region);
-            return region;
-        },
-        remove(location) {
-            const region = MeshRegister.region.get(location);
-            if (!region)
-                return false;
-            const dimension = MeshRegister.dimensions.get(location[0]);
-            if (!dimension)
-                return false;
-            dimension.delete(WorldSpaces.region.getKeyXYZ(location[1], location[2], location[3]));
+        }
+    }
+    static remove(id) {
+        const dimension = MeshRegister._dimensions.get(id);
+        if (!dimension)
+            return false;
+        dimension.forEach((region) => {
             region.columns.forEach((column) => {
                 column.chunks.forEach((chunk) => {
-                    chunk.forEach((chunkMeshes) => {
-                        chunkMeshes.mesh.dispose();
+                    chunk.meshes.forEach((chunkMeshes) => {
+                        chunkMeshes.dispose();
                     });
                 });
             });
-            return true;
-        },
-        _getRegionData() {
-            return {
-                columns: new Map(),
-            };
-        },
-        get(location) {
-            const dimension = MeshRegister.dimensions.get(location[0]);
-            if (!dimension)
-                return false;
-            const region = dimension.get(WorldSpaces.region.getKeyXYZ(location[1], location[2], location[3]));
-            if (!region)
-                return false;
-            return region;
-        },
-    },
-    column: {
-        add(location) {
-            let region = MeshRegister.region.get(location);
-            if (!region) {
-                region = MeshRegister.region.add(location);
-            }
-            const column = this._getColumnData(location);
-            region.columns.set(WorldSpaces.column.getIndexXYZ(location[1], location[2], location[3]), column);
-            return column;
-        },
-        remove(location) {
-            let region = MeshRegister.region.get(location);
-            if (!region)
-                return false;
-            const index = WorldSpaces.column.getIndexXYZ(location[1], location[2], location[3]);
-            const column = region.columns.get(index);
-            if (!column)
-                return false;
-            region.columns.delete(index);
-            if (region.columns.size == 0) {
-                MeshRegister.region.remove(location);
-            }
-            return column;
-        },
-        _getColumnData(location) {
-            return {
-                location: [
-                    location[0],
-                    ...Vector3Like.ToArray(WorldSpaces.column.getPositionXYZ(location[1], location[2], location[3])),
-                ],
-                chunks: new Map(),
-            };
-        },
-        get(location) {
-            const region = MeshRegister.region.get(location);
-            if (!region)
-                return false;
-            return region.columns.get(WorldSpaces.column.getIndexXYZ(location[1], location[2], location[3]));
-        },
-    },
-    chunk: {
-        add(location, mesh, substance) {
-            let column = MeshRegister.column.get(location);
-            if (!column) {
-                column = MeshRegister.column.add(location);
-            }
-            const index = WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[2]);
-            let chunk = column.chunks.get(index);
-            if (!chunk) {
-                chunk = new Map();
-                column.chunks.set(index, chunk);
-            }
-            chunk.set(substance, this._getChunkData(mesh));
-            return chunk;
-        },
-        _getChunkData(mesh) {
-            return {
-                mesh: mesh,
-            };
-        },
-        remove(location, substance) {
-            const column = MeshRegister.column.get(location);
-            if (!column)
-                return false;
-            const index = WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]);
-            const chunk = column.chunks.get(index);
-            if (!chunk)
-                return false;
-            const chunkMesh = chunk.get(substance);
-            if (!chunkMesh)
-                return false;
-            chunk.delete(substance);
-            if (chunk.size == 0) {
-                column.chunks.delete(index);
-            }
-            return chunkMesh.mesh;
-        },
-        get(location, substance) {
-            const column = MeshRegister.column.get(location);
-            if (!column)
-                return false;
-            const chunk = column.chunks.get(WorldSpaces.chunk.getIndexXYZ(location[1], location[2], location[3]));
-            if (!chunk)
-                return false;
-            const chunkMesh = chunk.get(substance);
-            if (!chunkMesh)
-                return false;
-            return chunkMesh;
-        },
-    },
-};
+        });
+        MeshRegister._dimensions.delete(id);
+        return true;
+    }
+}
+export class MeshRegister {
+    // Main dimensions data store
+    static _dimensions = new Map([["main", new Map()]]);
+    static dimensions = Dimensions;
+    static region = Region;
+    static column = Column;
+    static chunk = Chunk;
+    static clearAll() {
+        for (const [dkey, dim] of this._dimensions) {
+            this.dimensions.remove(dkey);
+        }
+        this._dimensions.clear();
+        this._dimensions.set("main", new Map());
+    }
+}

package/Contexts/Render/Tasks/RenderTasks.js

@@ -1,19 +1,15 @@
 import { Threads } from "@amodx/threads/";
-import { MeshManager } from "../Scene/MeshManager.js";
-import { MeshRegister } from "../Scene/MeshRegister.js";
+import { MeshManager } from "../../../Renderer/MeshManager.js";
+import { MeshRegister } from "../../../Renderer/MeshRegister.js";
 export const RenderTasks = {
     setChunk: Threads.registerTasks("set-chunk", (data) => {
-        MeshManager.chunks.update(data);
-        /*   if (data[2] == 0) return MeshManager.chunks.update(data);
-          setTimeout(() => {
-            MeshManager.chunks.update(data);
-          }, 10); */
+        MeshManager.update(data);
     }),
     removeChunk: Threads.registerTasks("remove-chunk", (data) => {
-        MeshManager.chunks.remove(data);
+        MeshManager.remove(data);
     }),
     removeColumn: Threads.registerTasks("remove-column", (data) => {
-        MeshManager.chunks.removeColumn(data);
+        MeshManager.removeColumn(data);
     }),
     clearAll: Threads.registerTasks("clear-all", (data) => {
         MeshRegister.clearAll();

package/Contexts/Render/Tasks/RenderTasks.types.d.ts

@@ -1,20 +1,15 @@
-import { DVENodeMeshAttributes } from "../../../Interfaces/Render/Nodes/DVERenderNode.types";
+import { CompactMeshData } from "../../../Mesher/Types/Mesher.types";
 import type { LocationData } from "../../../Math/index.js";
 export type SetChunkMeshTask = [
     location: LocationData,
-    meshes: (ChunkMeshData | RemoveChunkTasks)[],
+    meshes: CompactMeshData,
+    effects: ChunkEffectData[],
     priority: number
 ];
+export type ChunkEffectData = [id: string, data: any];
 export type ChunkMeshData = [
     substanceType: string,
-    meshData: [
-        location: LocationData,
-        attributes: DVENodeMeshAttributes
-    ]
-];
-type RemoveChunkTasks = [
-    substanceType: string,
-    removeFlag: false
+    meshData: [location: LocationData, mesh: CompactMeshData]
 ];
 export type RemoveChunkMeshTasks = [
     location: LocationData,
@@ -24,4 +19,3 @@ export type RemoveChunksOutsideDistance = [
     location: LocationData,
     distance: number
 ];
-export {};

package/Contexts/World/Data/DataSync.d.ts

@@ -1,34 +1,24 @@
 import type { Thread, ThreadPool } from "@amodx/threads/";
-import type { PaletteSyncData, RegisterObjectMapSync, RegisterStringMapSync } from "Types/DataSync.types.js";
-import type { BinaryStructData } from "@amodx/binary/";
 import { CommSyncOptions } from "./DataSyncNode.js";
 import { DataSyncNode } from "./DataSyncNode.js";
-import { Pipeline, AsyncPipeline } from "@amodx/core/Pipelines/";
+import { Pipeline } from "@amodx/core/Pipelines/";
 import type { LocationData } from "../../../Math/index.js";
-import type { WorldDataSync } from "../../../Data/Types/DataSync.types.js";
 import type { DimensionData } from "../../../Data/Types/DimensionData.types.js";
 import { Chunk, Column, Region } from "../../../Data/World/Classes/index.js";
 import { DivineVoxelEngineWorld } from "../index.js";
+import { WorldDataSync } from "../../Base/Remote/Sync/DataSync.types.js";
 export declare class DataSync {
-    static instance: DataSync;
-    static constructorPipeLine: Pipeline<DataSync>;
     commMap: Map<string, Thread | ThreadPool>;
     comms: (Thread | ThreadPool)[];
     commOptions: WeakMap<any, CommSyncOptions>;
     _ready: boolean;
     pipelines: {
-        init: AsyncPipeline<DataSync>;
+        init: Pipeline<DataSync>;
     };
-    constructor();
     init(world: DivineVoxelEngineWorld): Promise<void>;
     isReady(): boolean;
     registerComm(comm: Thread | ThreadPool, data?: Partial<CommSyncOptions>): void;
     loopThroughComms(func: (comm: Thread | ThreadPool, options: CommSyncOptions) => void): void;
-    worldDataTags: {
-        chunk: DataSyncNode<void, BinaryStructData, void, false>;
-        column: DataSyncNode<void, BinaryStructData, void, false>;
-        region: DataSyncNode<void, [BinaryStructData, BinaryStructData], void, false>;
-    };
     worldData: {
         dimesnion: DataSyncNode<string | number, DimensionData, string | number, boolean>;
         chunk: DataSyncNode<LocationData, [LocationData, Chunk], LocationData, LocationData>;
@@ -36,16 +26,4 @@ export declare class DataSync {
         region: DataSyncNode<LocationData, [LocationData, Region], LocationData, LocationData>;
         regionHeader: DataSyncNode<LocationData, WorldDataSync, LocationData, boolean>;
     };
-    tags: {
-        voxel: DataSyncNode<void, [BinaryStructData, SharedArrayBuffer], void, false>;
-        substance: DataSyncNode<void, BinaryStructData, void, false>;
-    };
-    palettes: {
-        voxel: DataSyncNode<void, PaletteSyncData, void, false>;
-        substance: DataSyncNode<void, PaletteSyncData, void, false>;
-    };
-    maps: {
-        strings: DataSyncNode<RegisterStringMapSync, RegisterStringMapSync, void, false>;
-        objects: DataSyncNode<RegisterObjectMapSync, RegisterObjectMapSync, void, false>;
-    };
 }

package/Contexts/World/Data/DataSync.js

@@ -1,37 +1,18 @@
-//objects
-import { VoxelStruct } from "../../../Data/Voxel/VoxelStruct.js";
-import { VoxelTagBuilder } from "./StructBuilders/VoxelStructBuilder.js";
-import { SubstanceDataGenerator } from "./Generators/SubstanceDataGenerator.js";
-import { SubstanceStruct } from "../../../Data/Substance/SubstanceStruct.js";
-import { SubstanceTagBuilder } from "./StructBuilders/SubstanceStructBuilder.js";
 import { DataSyncNode } from "./DataSyncNode.js";
-import { VoxelDataGenerator } from "./Generators/VoxelDataGenerator.js";
-import { Pipeline, AsyncPipeline } from "@amodx/core/Pipelines/";
-import { DataSyncIds } from "../../../Interfaces/Common/DataSyncIds.js";
+import { Pipeline } from "@amodx/core/Pipelines/";
 //objects
 import { WorldRegister } from "../../../Data/World/WorldRegister.js";
-import { ChunkStatStruct } from "./Structs/ChunkStruct.js";
-import { ColumnStateStruct, } from "./Structs/ColumnStruct.js";
-import { RegionStateStruct, RegionHeaderTagManager, } from "./Structs/RegionStruct.js";
-import { RegionHeaderRegister } from "../../../Data/RegionHeaderRegister.js";
+import { RegionHeaderRegister } from "../../../Data/World/RegionHeaderRegister.js";
 import { DimensionsRegister } from "../../../Data/World/DimensionsRegister.js";
 import { DVEFDataSyncIds } from "../../../Data/Constants/DVEFDataSyncIds.js";
 export class DataSync {
-    static instance;
-    static constructorPipeLine = new Pipeline();
     commMap = new Map();
     comms = [];
     commOptions = new WeakMap();
     _ready = false;
     pipelines = {
-        init: new AsyncPipeline(),
+        init: new Pipeline(),
     };
-    constructor() {
-        if (DataSync.instance)
-            return DataSync.instance;
-        DataSync.instance = DataSync.constructorPipeLine.pipe(this);
-        return DataSync.instance;
-    }
     async init(world) {
         for (const comm of world.threads.comms) {
             if (!comm.isReady())
@@ -41,15 +22,7 @@ export class DataSync {
         this.loopThroughComms((comm) => {
             this.commMap.set(comm.name, comm);
         });
-        SubstanceDataGenerator.$generate();
-        SubstanceTagBuilder.sync();
-        VoxelDataGenerator.generate();
-        VoxelTagBuilder.sync();
-        this.palettes.voxel.sync();
-        this.palettes.substance.sync();
-        this.tags.voxel.sync();
-        this.tags.substance.sync();
-        await this.pipelines.init.pipe(this);
+        await this.pipelines.init.pipeAsync(this);
         this._ready = true;
     }
     isReady() {
@@ -74,29 +47,6 @@ export class DataSync {
             func(comm, options);
         }
     }
-    worldDataTags = {
-        chunk: new DataSyncNode({
-            dataSyncType: DVEFDataSyncIds.ChunkTags,
-            commCheck: (options) => options.worldDataTags,
-            getSyncData: () => ChunkStatStruct.structData,
-            getUnSyncData: () => false,
-        }, this),
-        column: new DataSyncNode({
-            dataSyncType: DVEFDataSyncIds.ColumnTags,
-            commCheck: (options) => options.worldDataTags,
-            getSyncData: () => ColumnStateStruct.structData,
-            getUnSyncData: () => false,
-        }, this),
-        region: new DataSyncNode({
-            dataSyncType: DVEFDataSyncIds.RegionTags,
-            commCheck: (options) => options.worldDataTags,
-            getSyncData: () => [
-                RegionStateStruct.structData,
-                RegionHeaderTagManager.structData,
-            ],
-            getUnSyncData: () => false,
-        }, this),
-    };
     worldData = {
         dimesnion: new DataSyncNode({
             dataSyncType: DVEFDataSyncIds.Dimesnion,
@@ -157,59 +107,4 @@ export class DataSync {
             getUnSyncData: () => true,
         }, this),
     };
-    tags = {
-        voxel: new DataSyncNode({
-            dataSyncType: DataSyncIds.VoxelTags,
-            commCheck: (options) => options.voxelTags,
-            getSyncData: () => [
-                VoxelStruct.initData,
-                VoxelStruct.voxelIndex.buffer,
-            ],
-            getUnSyncData: () => false,
-        }, this),
-        substance: new DataSyncNode({
-            dataSyncType: DataSyncIds.SubstanceTags,
-            commCheck: (options) => options.voxelTags,
-            getSyncData: () => SubstanceStruct.initData,
-            getUnSyncData: () => false,
-        }, this),
-    };
-    palettes = {
-        voxel: new DataSyncNode({
-            dataSyncType: DataSyncIds.VoxelPalette,
-            commCheck: (options) => options.worldDataTags,
-            getSyncData: () => [
-                VoxelDataGenerator.palette._palette,
-                VoxelDataGenerator.palette._map,
-                VoxelDataGenerator.nameToIdMap,
-                VoxelDataGenerator.idToNameMap,
-            ],
-            getUnSyncData: () => false,
-        }, this),
-        substance: new DataSyncNode({
-            dataSyncType: DataSyncIds.SubstancePalette,
-            commCheck: (options) => options.worldDataTags,
-            getSyncData: () => [
-                SubstanceDataGenerator.palette._palette,
-                SubstanceDataGenerator.palette._map,
-                {},
-                {},
-            ],
-            getUnSyncData: () => false,
-        }, this),
-    };
-    maps = {
-        strings: new DataSyncNode({
-            dataSyncType: DataSyncIds.RegisterStringMap,
-            commCheck: () => true,
-            getSyncData: (data) => data,
-            getUnSyncData: () => false,
-        }, this),
-        objects: new DataSyncNode({
-            dataSyncType: DataSyncIds.RegisterObjectMap,
-            commCheck: () => true,
-            getSyncData: (data) => data,
-            getUnSyncData: () => false,
-        }, this),
-    };
 }