@divinevoxel/vlox 0.0.74 → 0.0.76

package/Mesher/Models/VoxelGeometryBuilderCacheSpace.js

@@ -48,7 +48,7 @@ export class VoxelGeometryBuilderCacheSpace {
     getConditionalGeomtry(index) {
         if (this.foundHash[index] < 2)
             return null;
-        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelCache[index]].data.condiotnalShapeStateGeometryMap[this.conditonalStateCache[index]];
+        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelCache[index]].data.condiotanlGeometryStatePalette[this.conditonalStateCache[index]];
     }
     getHash(dataCursor, x, y, z) {
         const hashed = this.getIndex(x, y, z);
@@ -67,7 +67,7 @@ export class VoxelGeometryBuilderCacheSpace {
             this.foundHash[index] = 1;
             return;
         }
-        const voxelId = voxel.getId();
+        const voxelId = voxel.getVoxelId();
         const voxelConstructor = VoxelModelConstructorRegister.constructorsPaltte[voxelId];
         if (!voxelConstructor) {
             this.foundHash[index] = 1;

package/Mesher/Models/VoxelModelBuilder.d.ts

@@ -8,7 +8,6 @@ import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface.
 import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface.js";
 import { VoxelGeometryBuilderCacheSpace } from "./VoxelGeometryBuilderCacheSpace";
 declare class VoxelVars {
-    faceFlipped: boolean;
     textureIndex: number;
     overlayTextures: Vector4Like;
     light: QuadScalarVertexData;

package/Mesher/Models/VoxelModelBuilder.js

@@ -7,7 +7,6 @@ import calculateFaceData from "./Common/Calc/FaceDataCalc.js";
 import { VoxelMesh } from "../Geomtry/VoxelMesh";
 import { Vector3Like, Vector4Like } from "@amodx/math";
 class VoxelVars {
-    faceFlipped = false;
     textureIndex = 0;
     overlayTextures = Vector4Like.Create();
     light = new QuadScalarVertexData();
@@ -15,11 +14,11 @@ class VoxelVars {
     animation = new QuadScalarVertexData();
     level = new QuadScalarVertexData();
     reset() {
-        this.faceFlipped = false;
         this.textureIndex = 0;
         this.overlayTextures.x = 0;
         this.overlayTextures.y = 0;
         this.overlayTextures.z = 0;
+        this.overlayTextures.w = 0;
     }
 }
 export class VoxelModelBuilder {

package/Mesher/Models/VoxelModelConstructorRegister.d.ts

@@ -1,12 +1,18 @@
 import { StringPalette } from "../../Util/StringPalette";
-import { CompiledVoxelGeometryRulessData, CompiledVoxelGeometrySyncData, CompiledVoxelModelData } from "../../Voxels/Types/VoxelModelCompiledData.types";
+import { CompiledVoxelGeometrySyncData, CompiledVoxelModelData } from "../../Voxels/Models/CompiledVoxelModel.types";
 import { GeoemtryNodeConstructor } from "./Nodes/GeometryNode";
 import { VoxelConstructor } from "./VoxelConstructor";
 import { VoxelGeometryConstructor } from "./Nodes/VoxelGeometryConstructor";
+import { AOOcclusionFaceIndex } from "../../Voxels/Models/Indexing/AOOcclusionFaceIndex";
+import { CulledOcclusionFaceIndex } from "../../Voxels/Models/Indexing/CulledOcclusionFaceIndex";
 export declare class VoxelModelConstructorRegister {
     static geometryPalette: StringPalette;
     static geometry: VoxelGeometryConstructor[];
     static rulesless: boolean[];
+    static aoIndex: AOOcclusionFaceIndex;
+    static faceCullIndex: CulledOcclusionFaceIndex;
+    static vertexHitMap: number[][][];
+    static faceCullMap: number[][];
     static setGeometryPalette(palette: string[]): void;
     static modelData: Map<string, CompiledVoxelModelData>;
     static customNodes: Map<string, GeoemtryNodeConstructor<any, any>>;
@@ -17,5 +23,5 @@ export declare class VoxelModelConstructorRegister {
     static constructors: Map<string, VoxelConstructor>;
     static getConstructor(id: string): VoxelConstructor;
     static registerVoxel(voxel: VoxelConstructor | VoxelConstructor[]): void;
-    static registerGeometry(geometries: (CompiledVoxelGeometrySyncData | CompiledVoxelGeometryRulessData)[]): void;
+    static registerGeometry(geometries: CompiledVoxelGeometrySyncData[]): void;
 }

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/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,25 +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);
         if (!EngineSettings.settings.rendererSettings.cpuBound) {
             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 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,17 +1,19 @@
 import { MeshRegister } from "./MeshRegister.js";
-import { CompactedSectionVoxelMesh, } from "../Mesher/Geomtry/CompactedSectionVoxelMesh";
+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) {
         compacted.setData(data);
         compacted.getLocation(location);
-        let sector = MeshRegister.sectors.get(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) {
@@ -42,18 +44,13 @@ export class MeshManager {
      */
         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

@@ -2,14 +2,16 @@ import { type LocationData } from "../Math/index.js";
 import { SectorMesh } from "./Classes/SectorMesh.js";
 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: number): Map<any, any>;
     static get(id: number): Map<string, SectorMesh> | undefined;
-    static getAllMeshes(id: number): Generator<[location: LocationData, substance: string, mesh: any]>;
     static remove(id: number): boolean;
 }
 export declare class MeshRegister {

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,38 +58,13 @@ 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;
     }

package/Settings/EngineSettings.js

@@ -52,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 {
@@ -40,7 +40,13 @@ export declare class PropagationSettings {
     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;

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 {
@@ -30,7 +30,11 @@ export class PropagationSettings {
     flowEnabled = true;
     powerEnabled = true;
 }
+export class MemoryAndCPUSettings {
+    useSharedMemory = true;
+}
 export class EngineSettingsData {
+    memoryAndCPU = new MemoryAndCPUSettings();
     mesher = new MesherSettingsData();
     rendererSettings = new RenderSettingsData();
     updating = new UpdatingSettings();

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 {};

package/Stats/EngineStats.js

@@ -0,0 +1,27 @@
+class GeomtryStats {
+    /**The total geomtry faces */
+    faces = 0;
+}
+class PaletteStats {
+    /**The final voxel palette id size. */
+    paletteSize = 0;
+}
+/**
+ * Stores data from the results of the engine building data and other things.
+ */
+export class EngineStats {
+    /** Stats to do with the vlox model system. */
+    static geomtry = new GeomtryStats();
+    /** Stats to do with the vloxel palette system. */
+    static palette = new PaletteStats();
+    static log() {
+        let output = "DVE Stats\n";
+        //geomtry
+        output += "Geomtry\n";
+        output += `Faces: ${this.geomtry.faces}\n`;
+        //palettes
+        output += "Palette\n";
+        output += `Paltte Size: ${this.palette.paletteSize}\n`;
+        return output;
+    }
+}

package/Tasks/Paint/Common.d.ts

@@ -0,0 +1,7 @@
+import { VoxelUpdateTask } from "../VoxelUpdateTask.js";
+import { VoxelUpdateData } from "../../Tasks/Tasks.types.js";
+export declare const updatePowerTask: (tasks: VoxelUpdateTask) => void;
+export declare const canUpdate: (x: number, y: number, z: number, data: VoxelUpdateData) => boolean;
+/**Checks if the given voxel needs a light update and adds it to the needed queues */
+export declare const checkLightUpdate: (x: number, y: number, z: number, tasks: VoxelUpdateTask) => void;
+export declare const updateArea: (tasks: VoxelUpdateTask, sx: number, sy: number, sz: number, ex: number, ey: number, ez: number) => void;