@divinevoxel/vlox 0.0.73 → 0.0.75

package/Mesher/Models/VoxelModelConstructorRegister.js

@@ -5,6 +5,10 @@ export class VoxelModelConstructorRegister {
     static geometryPalette;
     static geometry = [];
     static rulesless = [];
+    static aoIndex;
+    static faceCullIndex;
+    static vertexHitMap;
+    static faceCullMap;
     static setGeometryPalette(palette) {
         this.geometryPalette = new StringPalette(palette);
     }
@@ -31,23 +35,17 @@ export class VoxelModelConstructorRegister {
         if (Array.isArray(voxel)) {
             for (const vox of voxel) {
                 this.constructors.set(vox.id, vox);
-                this.constructorsPaltte[VoxelPalettesRegister.voxels.getNumberId(vox.id)] = vox;
+                this.constructorsPaltte[VoxelPalettesRegister.voxelIds.getNumberId(vox.id)] = vox;
             }
             return;
         }
-        this.constructorsPaltte[VoxelPalettesRegister.voxels.getNumberId(voxel.id)] = voxel;
+        this.constructorsPaltte[VoxelPalettesRegister.voxelIds.getNumberId(voxel.id)] = voxel;
         this.constructors.set(voxel.id, voxel);
     }
     static registerGeometry(geometries) {
         for (const geometry of geometries) {
             const paletteId = this.geometryPalette.getNumberId(geometry.id);
             this.geometry[paletteId] = new VoxelGeometryConstructor(paletteId, geometry);
-            if (geometry.ruleless == true) {
-                this.rulesless[paletteId] = true;
-            }
-            else {
-                this.rulesless[paletteId] = false;
-            }
         }
     }
 }

package/Mesher/Types/Mesher.types.d.ts

@@ -1,4 +1,5 @@
 import { Vec3Array } from "@amodx/math";
+export type SetSectionMeshTask = ArrayBuffer;
 export type CompactSubMesh = [
     materialId: string,
     vertexBuffer: Float32Array,

package/Renderer/Classes/DVESectionMeshes.d.ts

@@ -1,7 +1,6 @@
-import { Vec3Array } from "@amodx/math";
-import { CompactMeshData } from "../../Mesher/Types/Mesher.types";
 import { SectionMesh } from "./SectionMesh";
+import { CompactedSectionVoxelMesh } from "../../Mesher/Geomtry/CompactedSectionVoxelMesh";
 export declare abstract class DVESectionMeshes {
-    abstract updateVertexData(section: SectionMesh, position: Vec3Array, data: CompactMeshData): SectionMesh;
+    abstract updateVertexData(section: SectionMesh, data: CompactedSectionVoxelMesh): SectionMesh;
     abstract returnMesh(mesh: any): void;
 }

package/Renderer/Classes/SectionMesh.d.ts

@@ -2,11 +2,10 @@ import { VoxelEffect } from "../../Voxels/Effects/VoxelEffect";
 import { SectorMesh } from "./SectorMesh";
 import { Vec3Array } from "@amodx/math";
 export declare class SectionMesh {
-    sector: SectorMesh;
-    index: number;
     meshes: Map<string, any>;
     effects: Map<string, VoxelEffect>;
-    constructor(sector: SectorMesh, index: number);
+    sector: SectorMesh;
+    index: number;
     getPosition(): Vec3Array;
     dispose(): void;
 }

package/Renderer/Classes/SectionMesh.js

@@ -1,23 +1,26 @@
 import { WorldSpaces } from "../../World/WorldSpaces";
+import { MeshManager } from "../MeshManager";
 export class SectionMesh {
-    sector;
-    index;
     meshes = new Map();
     effects = new Map();
-    constructor(sector, index) {
-        this.sector = sector;
-        this.index = index;
-    }
+    sector;
+    index = 0;
     getPosition() {
         return [
-            this.sector.location[1],
-            this.sector.location[1] + WorldSpaces.section.bounds.y * this.index,
-            this.sector.location[2],
+            this.sector.position[0],
+            this.sector.position[1] + WorldSpaces.section.bounds.y * this.index,
+            this.sector.position[2],
         ];
     }
     dispose() {
-        for (const [key, effect] of this.effects) {
+        MeshManager._sectionPool.push(this);
+        for (const [, mesh] of this.meshes) {
+            MeshManager.sectorMeshes.returnMesh(mesh);
+        }
+        this.meshes.clear();
+        for (const [, effect] of this.effects) {
             effect.dispose();
         }
+        this.effects.clear();
     }
 }

package/Renderer/Classes/SectorMesh.d.ts

@@ -1,10 +1,10 @@
-import { LocationData } from "../../Math";
 import { SectionMesh } from "./SectionMesh";
+import { Vec3Array } from "@amodx/math";
 export declare class SectorMesh {
-    location: LocationData;
-    sections: SectionMesh[];
-    constructor(location: LocationData);
-    getSection(x: number, y: number, z: number): SectionMesh;
+    sections: (SectionMesh | null)[];
+    position: Vec3Array;
+    dipose(): void;
+    getSection(x: number, y: number, z: number): SectionMesh | null;
     addSection(x: number, y: number, z: number): SectionMesh;
     removeSection(x: number, y: number, z: number): false | SectionMesh;
 }

package/Renderer/Classes/SectorMesh.js

@@ -1,10 +1,17 @@
 import { WorldSpaces } from "../../World/WorldSpaces";
 import { SectionMesh } from "./SectionMesh";
+import { MeshManager } from "../MeshManager";
 export class SectorMesh {
-    location;
-    sections = [];
-    constructor(location) {
-        this.location = location;
+    sections = new Array(WorldSpaces.sector.sectionVolumne).fill(null);
+    position = [0, 0, 0];
+    dipose() {
+        MeshManager._sectorPool.push(this);
+        for (const section of this.sections) {
+            if (!section)
+                continue;
+            section.dispose();
+        }
+        this.sections.fill(null);
     }
     getSection(x, y, z) {
         return this.sections[WorldSpaces.section.getIndex(x, y, z)];
@@ -13,7 +20,11 @@ export class SectorMesh {
         const index = WorldSpaces.section.getIndex(x, y, z);
         if (this.sections[index])
             return this.sections[index];
-        const section = new SectionMesh(this, index);
+        const section = MeshManager._sectionPool.length
+            ? MeshManager._sectionPool.shift()
+            : new SectionMesh();
+        section.sector = this;
+        section.index = index;
         this.sections[index] = section;
         return section;
     }
@@ -22,7 +33,7 @@ export class SectorMesh {
         if (!this.sections[index])
             return false;
         const section = this.sections[index];
-        delete this.sections[index];
+        this.sections[index] = null;
         return section;
     }
 }

package/Renderer/InitTasks.d.ts

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

package/Renderer/InitTasks.js

@@ -1,33 +1,19 @@
 import { Threads } from "@amodx/threads/";
 import { MeshManager } from "./MeshManager";
 import { MeshRegister } from "./MeshRegister";
-import { TaskTool } from "../Tools/Tasks/TasksTool";
 import { EngineSettings } from "../Settings/EngineSettings";
-export default function RendererTasks(threads) {
-    const tasks = new TaskTool(threads);
+import { getLocationData } from "../Util/LocationData";
+export default function RendererTasks() {
     Threads.registerTask("set-section", (data, origin) => {
         MeshManager.updateSection(data);
-        const tranfers = [];
-        if (data[1][0] == 0) {
-            const comp = data[1][1];
-            for (const mesh of comp) {
-                tranfers.push(mesh[1].buffer);
-                tranfers.push(mesh[2].buffer);
-            }
-        }
         if (!EngineSettings.settings.rendererSettings.cpuBound) {
-            origin.sendMessage([], tranfers);
+            origin.sendMessage([], [data]);
         }
     });
-    Threads.registerTask("remove-sector", (data) => {
-        MeshManager.removeSector(data);
+    Threads.registerBinaryTask("remove-sector", (data) => {
+        MeshManager.removeSector(...getLocationData(data));
     });
     Threads.registerTask("clear-all", (data) => {
         MeshRegister.clearAll();
     });
-    Threads.registerTask("build-queue", ([dim, sections]) => {
-        for (const position of sections) {
-            tasks.build.section.run([dim, ...position]);
-        }
-    });
 }

package/Renderer/MeshManager.d.ts

@@ -1,9 +1,14 @@
-import { SetSectionMeshTask } from "../Renderer/Renderer.types";
+import type { SetSectionMeshTask } from "../Mesher/Types/Mesher.types";
 import { LocationData } from "../Math/index.js";
 import { DVESectionMeshes } from "./Classes/DVESectionMeshes";
+import { SectorMesh } from "./Classes/SectorMesh";
+import { SectionMesh } from "./Classes/SectionMesh";
 export declare class MeshManager {
+    static _sectorPool: SectorMesh[];
+    static _sectionPool: SectionMesh[];
     static sectorMeshes: DVESectionMeshes;
     static runningUpdate: boolean;
     static updateSection(data: SetSectionMeshTask): void;
-    static removeSector(data: LocationData): false | undefined;
+    static removeSector(dimensionId: number, x: number, y: number, z: number): false | undefined;
+    static removeSectorAt(data: LocationData): false | undefined;
 }

package/Renderer/MeshManager.js

@@ -1,58 +1,56 @@
 import { MeshRegister } from "./MeshRegister.js";
-import { VoxelEffectRegister } from "../Voxels/Effects/VoxelEffectRegister.js";
+import { CompactedSectionVoxelMesh } from "../Mesher/Geomtry/CompactedSectionVoxelMesh";
 const added = new Set();
+const compacted = new CompactedSectionVoxelMesh();
+const location = [0, 0, 0, 0];
 export class MeshManager {
+    static _sectorPool = [];
+    static _sectionPool = [];
     static sectorMeshes;
     static runningUpdate = false;
     static updateSection(data) {
-        const location = data[0];
-        const sections = data[1];
-        const effects = data[2];
-        let sector = MeshRegister.sectors.get(location);
+        compacted.setData(data);
+        compacted.getLocation(location);
+        let sector = MeshRegister.sectors.getAt(location);
         if (!sector) {
-            sector = MeshRegister.sectors.add(location);
+            sector = MeshRegister.sectors.addAt(location);
         }
         let section = sector.getSection(location[1], location[2], location[3]);
         if (!section) {
             section = sector.addSection(location[1], location[2], location[3]);
         }
+        /*
         added.clear();
         for (const [id, points] of effects) {
-            added.add(id);
-            if (!section.effects.has(id)) {
-                const EffectClass = VoxelEffectRegister.get(id);
-                const newEffect = new EffectClass(section);
-                newEffect.init();
-                newEffect.setPoints(points);
-                section.effects.set(id, newEffect);
-            }
-            else {
-                const effect = section.effects.get(id);
-                effect.setPoints(points);
-            }
+          added.add(id);
+          if (!section.effects.has(id)) {
+            const EffectClass = VoxelEffectRegister.get(id);
+            const newEffect = new EffectClass(section);
+            newEffect.init();
+            newEffect.setPoints(points);
+            section.effects.set(id, newEffect);
+          } else {
+            const effect = section.effects.get(id)!;
+            effect.setPoints(points);
+          }
         }
         for (const [key, effect] of section.effects) {
-            if (!added.has(key)) {
-                effect.dispose();
-                section.effects.delete(key);
-            }
-        }
-        if (sections[0] == 0) {
-            this.sectorMeshes.updateVertexData(section, [location[1], location[2], location[3]], sections);
+          if (!added.has(key)) {
+            effect.dispose();
+            section.effects.delete(key);
+          }
         }
+    
+     */
+        this.sectorMeshes.updateVertexData(section, compacted);
     }
-    static removeSector(data) {
-        const sector = MeshRegister.sectors.remove(data);
+    static removeSector(dimensionId, x, y, z) {
+        const sector = MeshRegister.sectors.remove(dimensionId, x, y, z);
         if (!sector)
             return false;
-        for (const section of sector.sections) {
-            if (!section)
-                continue;
-            section.dispose();
-            for (const [, mesh] of section.meshes) {
-                this.sectorMeshes.returnMesh(mesh);
-            }
-            section.meshes.clear();
-        }
+        sector.dipose();
+    }
+    static removeSectorAt(data) {
+        return this.removeSector(...data);
     }
 }

package/Renderer/MeshRegister.d.ts

@@ -1,16 +1,18 @@
 import { type LocationData } from "../Math/index.js";
 import { SectorMesh } from "./Classes/SectorMesh.js";
-export type MeshRegisterDimensions = Map<string, Map<string, SectorMesh>>;
+export type MeshRegisterDimensions = Map<number, Map<string, SectorMesh>>;
 declare class Sectors {
-    static add(location: LocationData): SectorMesh;
-    static remove(location: LocationData): false | SectorMesh;
-    static get(location: LocationData): false | SectorMesh | undefined;
+    static add(dimensionId: number, x: number, y: number, z: number): SectorMesh;
+    static addAt(location: LocationData): SectorMesh;
+    static remove(dimensionId: number, x: number, y: number, z: number): false | SectorMesh;
+    static removeAt(location: LocationData): false | SectorMesh;
+    static get(dimensionId: number, x: number, y: number, z: number): false | SectorMesh | undefined;
+    static getAt(location: LocationData): false | SectorMesh | undefined;
 }
 declare class Dimensions {
-    static add(id: string): Map<any, any>;
-    static get(id: string): Map<string, SectorMesh> | undefined;
-    static getAllMeshes(id: string): Generator<[location: LocationData, substance: string, mesh: any]>;
-    static remove(id: string): boolean;
+    static add(id: number): Map<any, any>;
+    static get(id: number): Map<string, SectorMesh> | undefined;
+    static remove(id: number): boolean;
 }
 export declare class MeshRegister {
     static _dimensions: MeshRegisterDimensions;

package/Renderer/MeshRegister.js

@@ -1,36 +1,52 @@
+import { Vector3Like } from "@amodx/math";
 import { WorldSpaces } from "../World/WorldSpaces.js";
 import { SectorMesh } from "./Classes/SectorMesh.js";
+import { MeshManager } from "./MeshManager.js";
+const tempVec3 = Vector3Like.Create();
+const tempVec3Array = [0, 0, 0];
 class Sectors {
-    static add(location) {
-        let dimension = MeshRegister.dimensions.get(location[0]);
+    static add(dimensionId, x, y, z) {
+        let dimension = MeshRegister.dimensions.get(dimensionId);
         if (!dimension)
-            dimension = MeshRegister.dimensions.add(location[0]);
-        const sector = new SectorMesh([
-            location[0],
-            ...WorldSpaces.sector.getPositionVec3Array(location[1], location[2], location[3]),
-        ]);
-        dimension.set(WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(location[1], location[2], location[3])), sector);
+            dimension = MeshRegister.dimensions.add(dimensionId);
+        const sector = MeshManager._sectorPool.length
+            ? MeshManager._sectorPool.shift()
+            : new SectorMesh();
+        const posoiton = WorldSpaces.sector.getPositionVec3Array(x, y, z, tempVec3Array);
+        sector.position[0] = posoiton[0];
+        sector.position[1] = posoiton[1];
+        sector.position[2] = posoiton[2];
+        dimension.set(WorldSpaces.hash.hashVec3Array(sector.position), sector);
         return sector;
     }
-    static remove(location) {
-        let dimension = MeshRegister.dimensions.get(location[0]);
+    static addAt(location) {
+        return this.add(...location);
+    }
+    static remove(dimensionId, x, y, z) {
+        let dimension = MeshRegister.dimensions.get(dimensionId);
         if (!dimension)
             return false;
-        const key = WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(location[1], location[2], location[3]));
+        const key = WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(x, y, z, tempVec3));
         const sector = dimension.get(key);
         if (!sector)
             return false;
         dimension.delete(key);
         if (dimension.size == 0) {
-            MeshRegister.dimensions.remove(location[0]);
+            MeshRegister.dimensions.remove(dimensionId);
         }
         return sector;
     }
-    static get(location) {
-        let dimension = MeshRegister.dimensions.get(location[0]);
+    static removeAt(location) {
+        return this.remove(...location);
+    }
+    static get(dimensionId, x, y, z) {
+        let dimension = MeshRegister.dimensions.get(dimensionId);
         if (!dimension)
             return false;
-        return dimension.get(WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(location[1], location[2], location[3])));
+        return dimension.get(WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(x, y, z, tempVec3)));
+    }
+    static getAt(location) {
+        return this.get(...location);
     }
 }
 class Dimensions {
@@ -42,44 +58,19 @@ class Dimensions {
     static get(id) {
         return MeshRegister._dimensions.get(id);
     }
-    static *getAllMeshes(id) {
-        const dimension = MeshRegister._dimensions.get(id);
-        if (!dimension)
-            return;
-        for (const [key, sector] of dimension) {
-            for (let i = 0; i < sector.sections.length; i++) {
-                for (const [substance, mesh] of sector.sections[i].meshes) {
-                    yield [
-                        [
-                            sector.location[0],
-                            sector.location[1],
-                            sector.location[2] + i * WorldSpaces.section.bounds.y,
-                            sector.location[3],
-                        ],
-                        substance,
-                        mesh,
-                    ];
-                }
-            }
-        }
-    }
     static remove(id) {
         const dimension = MeshRegister._dimensions.get(id);
         if (!dimension)
             return false;
-        dimension.forEach((sector) => {
-            sector.sections.forEach((section) => {
-                section.meshes.forEach((sectionMeshes) => {
-                    sectionMeshes.dispose();
-                });
-            });
-        });
+        for (const [, sector] of dimension) {
+            sector.dipose();
+        }
         MeshRegister._dimensions.delete(id);
         return true;
     }
 }
 export class MeshRegister {
-    static _dimensions = new Map([["main", new Map()]]);
+    static _dimensions = new Map([[0, new Map()]]);
     static dimensions = Dimensions;
     static sectors = Sectors;
     static clearAll() {
@@ -87,7 +78,7 @@ export class MeshRegister {
             this.dimensions.remove(dkey);
         }
         this._dimensions.clear();
-        this._dimensions.set("main", new Map());
+        this._dimensions.set(0, new Map());
     }
 }
 window.MeshRegister = MeshRegister;

package/Settings/EngineSettings.d.ts

@@ -17,6 +17,7 @@ declare class EngineSettingsClass extends TypedEventTarget<EngineSettingsEvents>
     get doRGBPropagation(): boolean;
     get doLight(): boolean;
     get doFlow(): boolean;
+    get doPower(): boolean;
     getSettings(): EngineSettingsData;
     syncSettings(data: EngineSettingsData): void;
     getSettingsCopy(): any;

package/Settings/EngineSettings.js

@@ -10,16 +10,19 @@ class EngineSettingsClass extends TypedEventTarget {
     settings = new EngineSettingsData();
     version = "0.0.72";
     get doSunPropagation() {
-        return this.settings.lighting.sunLightEnabled == true;
+        return this.settings.propagation.sunLightEnabled == true;
     }
     get doRGBPropagation() {
-        return this.settings.lighting.rgbLightEnabled == true;
+        return this.settings.propagation.rgbLightEnabled == true;
     }
     get doLight() {
         return this.doRGBPropagation || this.doSunPropagation;
     }
     get doFlow() {
-        return this.settings.flow.enable;
+        return this.settings.propagation.flowEnabled;
+    }
+    get doPower() {
+        return this.settings.propagation.powerEnabled;
     }
     getSettings() {
         return this.settings;
@@ -49,3 +52,6 @@ class EngineSettingsClass extends TypedEventTarget {
     }
 }
 export const EngineSettings = new EngineSettingsClass();
+if (typeof SharedArrayBuffer === "undefined") {
+    EngineSettings.settings.memoryAndCPU.useSharedMemory = false;
+}

package/Settings/EngineSettings.types.d.ts

@@ -13,7 +13,7 @@ export interface RenderSettingsData {
 export declare class RenderSettingsData {
     /**Set the mode to change how mesh data is generated based on the underlying rendering API. */
     mode: "webgl" | "webgpu";
-    /**If set to try the engine will not try to send vertex buffers to woerks for GC. */
+    /**If set to try the engine will not try to send vertex buffers to workers for GC. */
     cpuBound: boolean;
 }
 export interface UpdatingSettings {
@@ -29,35 +29,27 @@ export interface WorldSettings {
 export declare class WorldSettings {
     min: Vector3Like;
     max: Vector3Like;
+    sectorPower2Size: Vector3Like;
+    sectionPower2Size: Vector3Like;
 }
-export interface SectorSettings {
+export interface PropagationSettings {
 }
-export declare class SectorSettings {
-    power2Size: Vector3Like;
-}
-export interface SectionSettings {
-}
-export declare class SectionSettings {
-    power2Size: Vector3Like;
-}
-export interface FlowSettings {
-}
-export declare class FlowSettings {
-    enable: boolean;
-}
-export interface LightingSettings {
-}
-export declare class LightingSettings {
+export declare class PropagationSettings {
     rgbLightEnabled: boolean;
     sunLightEnabled: boolean;
+    flowEnabled: boolean;
+    powerEnabled: boolean;
+}
+export interface MemoryAndCPUSettings {
+}
+export declare class MemoryAndCPUSettings {
+    useSharedMemory: boolean;
 }
 export declare class EngineSettingsData {
+    memoryAndCPU: MemoryAndCPUSettings;
     mesher: MesherSettingsData;
     rendererSettings: RenderSettingsData;
     updating: UpdatingSettings;
     world: WorldSettings;
-    sectors: SectorSettings;
-    sections: SectionSettings;
-    flow: FlowSettings;
-    lighting: LightingSettings;
+    propagation: PropagationSettings;
 }

package/Settings/EngineSettings.types.js

@@ -9,7 +9,7 @@ export class MesherSettingsData {
 export class RenderSettingsData {
     /**Set the mode to change how mesh data is generated based on the underlying rendering API. */
     mode = "webgl";
-    /**If set to try the engine will not try to send vertex buffers to woerks for GC. */
+    /**If set to try the engine will not try to send vertex buffers to workers for GC. */
     cpuBound = false;
 }
 export class UpdatingSettings {
@@ -21,27 +21,23 @@ export class UpdatingSettings {
 export class WorldSettings {
     min = Vector3Like.Create(-Number.MAX_SAFE_INTEGER, 0, -Number.MAX_SAFE_INTEGER);
     max = Vector3Like.Create(Number.MAX_SAFE_INTEGER, 256, Number.MAX_SAFE_INTEGER);
+    sectorPower2Size = Vector3Like.Create(4, 8, 4);
+    sectionPower2Size = Vector3Like.Create(4, 4, 4);
 }
-export class SectorSettings {
-    power2Size = Vector3Like.Create(4, 8, 4);
-}
-export class SectionSettings {
-    power2Size = Vector3Like.Create(4, 4, 4);
-}
-export class FlowSettings {
-    enable = true;
-}
-export class LightingSettings {
+export class PropagationSettings {
     rgbLightEnabled = true;
     sunLightEnabled = true;
+    flowEnabled = true;
+    powerEnabled = true;
+}
+export class MemoryAndCPUSettings {
+    useSharedMemory = true;
 }
 export class EngineSettingsData {
+    memoryAndCPU = new MemoryAndCPUSettings();
     mesher = new MesherSettingsData();
     rendererSettings = new RenderSettingsData();
     updating = new UpdatingSettings();
     world = new WorldSettings();
-    sectors = new SectorSettings();
-    sections = new SectionSettings();
-    flow = new FlowSettings();
-    lighting = new LightingSettings();
+    propagation = new PropagationSettings();
 }

package/Stats/EngineStats.d.ts

@@ -0,0 +1,19 @@
+declare class GeomtryStats {
+    /**The total geomtry faces */
+    faces: number;
+}
+declare class PaletteStats {
+    /**The final voxel palette id size. */
+    paletteSize: number;
+}
+/**
+ * Stores data from the results of the engine building data and other things.
+ */
+export declare class EngineStats {
+    /** Stats to do with the vlox model system. */
+    static geomtry: GeomtryStats;
+    /** Stats to do with the vloxel palette system. */
+    static palette: PaletteStats;
+    static log(): string;
+}
+export {};