@divinevoxel/vlox 0.0.5 → 0.0.7

package/Mesher/Models/Nodes/VoxelGeometryConstructor.js

@@ -61,7 +61,7 @@ export class VoxelGeometryConstructor {
         for (const node of this.nodes) {
             node.faceIndex = faceCount;
             node.vertexIndex = vertexCount;
-            faceCount += node.faceCount - 1;
+            faceCount += node.faceCount;
             vertexCount += node.vertexCount;
         }
     }

package/Mesher/Models/VoxelConstructor.d.ts

@@ -21,8 +21,6 @@ export declare class VoxelConstructor {
     shapeStateTree: StateTreeReader;
     condtioanlShapeStateTree: CondtionalTreeReader;
     constructor(id: string, data: CompiledVoxelModelData, voxleData: CompiledVoxelModelInputData);
-    getShapeStateTransaprentByteIndex(shapeState: number, geomtryId: number): number;
-    getCondtionalStateTransaprentByteIndex(shapeState: number, geomtryId: number): number;
     isShapeStateFaceTransparent(modState: number, shapeState: number, geoId: number, faceIndex: number): boolean;
     isCondtionalStateFaceTransparent(modState: number, shapeState: number, geoId: number, faceIndex: number): boolean;
     process(tool: VoxelMesherDataTool): void;

package/Mesher/Models/VoxelConstructor.js

@@ -25,30 +25,24 @@ export class VoxelConstructor {
         this.baseInputMap = voxleData.baseGeometryInputMap;
         this.conditonalInputMap = voxleData.condiotnalGeometryInputMap;
         this.transparentIndex = new VoxelFaceTransparentResultsIndex(voxleData.transparentFaceIndex);
-        this.modSchema = new StateSchema(voxleData.modSchema);
-        this.modTree = new StateTreeReader(this.modSchema, 0, voxleData.modStateTree);
         this.schema = new StateSchema(data.schema);
         this.shapeStateTree = new StateTreeReader(this.schema, 0, data.shapeStateTree);
         this.condtioanlShapeStateTree = new CondtionalTreeReader(this.schema, data.condiotnalStatements, data.condiotnalStateTree);
+        this.modSchema = new StateSchema(voxleData.modSchema);
+        this.modTree = new StateTreeReader(this.modSchema, 0, voxleData.modStateTree);
         this.effects = new VoxelModelEffect(this);
     }
-    getShapeStateTransaprentByteIndex(shapeState, geomtryId) {
-        return this.data.relativeGeometryByteIndexMap[this.data.shapeStateRelativeGeometryMap[shapeState][geomtryId]];
-    }
-    getCondtionalStateTransaprentByteIndex(shapeState, geomtryId) {
-        return this.data.relativeGeometryByteIndexMap[this.data.condiotnalShapeStateRelativeGeometryMap[shapeState][geomtryId]];
-    }
     isShapeStateFaceTransparent(modState, shapeState, geoId, faceIndex) {
-        return (this.transparentIndex.getValue(modState, this.getShapeStateTransaprentByteIndex(shapeState, geoId), faceIndex) == 1);
+        return (this.transparentIndex.getValue(modState, this.data.relativeGeometryByteIndexMap[this.data.shapeStateRelativeGeometryMap[shapeState][geoId]], faceIndex) == 1);
     }
     isCondtionalStateFaceTransparent(modState, shapeState, geoId, faceIndex) {
-        return (this.transparentIndex.getValue(modState, this.getCondtionalStateTransaprentByteIndex(shapeState, geoId), faceIndex) == 1);
+        return (this.transparentIndex.getValue(modState, this.data.relativeGeometryByteIndexMap[this.data.condiotnalShapeStateRelativeGeometryMap[shapeState][geoId]], faceIndex) == 1);
     }
     process(tool) {
         const hashed = VoxelGeometryLookUp.getHash(tool.nVoxel, tool.position.x, tool.position.y, tool.position.z);
-        const treeState = VoxelGeometryLookUp.stateCache[hashed];
-        const modState = VoxelGeometryLookUp.modCache[hashed];
-        if (treeState !== undefined && treeState > -1) {
+        const treeState = VoxelGeometryLookUp.space.stateCache[hashed];
+        const modState = VoxelGeometryLookUp.space.modCache[hashed];
+        if (treeState > -1) {
             const geoLinks = this.data.shapeStateMap[treeState];
             const geometries = this.data.shapeStateGeometryMap[treeState];
             const geometriesLength = geoLinks.length;
@@ -63,8 +57,8 @@ export class VoxelConstructor {
                 }
             }
         }
-        const conditonalTreeState = VoxelGeometryLookUp.conditonalStateCache[hashed];
-        if (conditonalTreeState !== undefined && conditonalTreeState > -1) {
+        const conditonalTreeState = VoxelGeometryLookUp.space.conditonalStateCache[hashed];
+        if (conditonalTreeState > -1) {
             const condiotnalNodes = this.data.condiotnalShapeStateMap[conditonalTreeState];
             const condiotnalNodesLength = condiotnalNodes.length;
             for (let c = 0; c < condiotnalNodesLength; c++) {

package/Mesher/Models/VoxelGeometryLookUp.d.ts

@@ -1,19 +1,28 @@
 import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
-import { VoxelConstructor } from "./VoxelConstructor";
-import { Vec3Array } from "@amodx/math";
+import { Vec3Array, Vector3Like } from "@amodx/math";
 import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
+export declare class VoxelGeometryLookUpSpace {
+    bounds: Vector3Like;
+    foundHash: Uint8Array;
+    voxelHash: Uint16Array;
+    modCache: Int32Array;
+    stateCache: Int32Array;
+    conditonalStateCache: Int32Array;
+    noCastAO: Uint8Array;
+    offset: Vec3Array;
+    constructor(bounds: Vector3Like);
+    start(x: number, y: number, z: number): void;
+    getIndex(x: number, y: number, z: number): number;
+    getConstructor(index: number): import("./VoxelConstructor").VoxelConstructor | null;
+    getGeomtry(index: number): false | number[];
+    getConditionalGeomtry(index: number): false | number[][];
+}
 export declare class VoxelGeometryLookUp {
-    static voxelHash: VoxelConstructor[];
-    static modCache: number[];
-    static stateCache: number[];
-    static conditonalStateCache: number[];
-    static geometryCache: number[][];
-    static conditionalGeometryCache: number[][][];
-    static noCastAO: boolean[];
-    static offset: Vec3Array;
+    static space: VoxelGeometryLookUpSpace | null;
     static voxelCursor: VoxelCursor;
+    static createSpace(x: number, y: number, z: number): VoxelGeometryLookUpSpace;
     static init(): void;
-    static start(dimension: string, x: number, y: number, z: number): void;
+    static start(space: VoxelGeometryLookUpSpace): void;
     static isRulesless(geoId: number): boolean;
     static stop(): void;
     static getHash(dataCursor: DataCursorInterface, x: number, y: number, z: number): number;

package/Mesher/Models/VoxelGeometryLookUp.js

@@ -1,67 +1,106 @@
 import { VoxelModelConstructorRegister } from "./VoxelModelConstructorRegister";
-import { Vector3Like } from "@amodx/math";
 import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
-export class VoxelGeometryLookUp {
-    static voxelHash = [];
-    static modCache = [];
-    static stateCache = [];
-    static conditonalStateCache = [];
-    static geometryCache = [];
-    static conditionalGeometryCache = [];
-    static noCastAO = [];
-    static offset = [0, 0, 0];
-    static voxelCursor = new VoxelCursor();
-    static init() { }
-    static start(dimension, x, y, z) {
+import { GetYXZOrderArrayIndex } from "../../Math/Indexing";
+export class VoxelGeometryLookUpSpace {
+    bounds;
+    foundHash;
+    voxelHash;
+    modCache;
+    stateCache;
+    conditonalStateCache;
+    noCastAO;
+    offset = [0, 0, 0];
+    constructor(bounds) {
+        this.bounds = bounds;
+        const volume = bounds.x * bounds.y * bounds.z;
+        this.foundHash = new Uint8Array(volume);
+        this.voxelHash = new Uint16Array(volume);
+        this.modCache = new Int32Array(volume);
+        this.stateCache = new Int32Array(volume);
+        this.conditonalStateCache = new Int32Array(volume);
+        this.noCastAO = new Uint8Array(volume);
+    }
+    start(x, y, z) {
         this.offset[0] = x;
         this.offset[1] = y;
         this.offset[2] = z;
+        this.foundHash.fill(0);
+        this.voxelHash.fill(0);
+        this.modCache.fill(-1);
+        this.stateCache.fill(-1);
+        this.conditonalStateCache.fill(-1);
+        this.noCastAO.fill(0);
+    }
+    getIndex(x, y, z) {
+        return GetYXZOrderArrayIndex(x - this.offset[0], y - this.offset[1], z - this.offset[2], this.bounds.x, this.bounds.y, this.bounds.z);
+    }
+    getConstructor(index) {
+        if (this.foundHash[index] !== 2)
+            return null;
+        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelHash[index]];
+    }
+    getGeomtry(index) {
+        if (this.foundHash[index] !== 2)
+            return false;
+        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelHash[index]].data.shapeStateGeometryMap[this.stateCache[index]];
+    }
+    getConditionalGeomtry(index) {
+        if (this.foundHash[index] !== 2)
+            return false;
+        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelHash[index]].data.condiotnalShapeStateGeometryMap[this.conditonalStateCache[index]];
+    }
+}
+export class VoxelGeometryLookUp {
+    static space = null;
+    static voxelCursor = new VoxelCursor();
+    static createSpace(x, y, z) {
+        return new VoxelGeometryLookUpSpace({ x, y, z });
+    }
+    static init() { }
+    static start(space) {
+        this.space = space;
     }
     static isRulesless(geoId) {
         return VoxelModelConstructorRegister.rulesless[geoId] == true;
     }
-    static stop() {
-        this.stateCache.length = 0;
-        this.voxelHash.length = 0;
-        this.modCache.length = 0;
-        this.geometryCache.length = 0;
-        this.conditionalGeometryCache.length = 0;
-        this.conditonalStateCache.length = 0;
-        this.noCastAO.length = 0;
-    }
+    static stop() { }
     static getHash(dataCursor, x, y, z) {
-        const hashed = Vector3Like.HashXYZ(x - this.offset[0], y - this.offset[1], z - this.offset[2]);
-        if (!this.stateCache[hashed])
+        if (!this.space)
+            throw new Error(`Voxel geomtry look up must have space set`);
+        const hashed = this.space.getIndex(x, y, z);
+        if (this.space.foundHash[hashed] == 0) {
             this.hashState(dataCursor, hashed, x, y, z);
+        }
         return hashed;
     }
-    static hashState(dataCursor, hashed, x, y, z) {
-        if (this.stateCache[hashed] !== undefined)
-            return this.stateCache[hashed];
-        const voxel = dataCursor.getVoxel(x, y, z);
-        if (!voxel) {
-            this.stateCache[hashed] = -1;
+    static hashState(dataCursor, index, x, y, z) {
+        if (!this.space)
+            throw new Error(`Voxel geomtry look up must have space set`);
+        if (this.space.foundHash[index] == 1)
             return -1;
-        }
-        if (!voxel.isRenderable()) {
-            this.stateCache[hashed] = -1;
+        if (this.space.foundHash[index] == 2)
+            return this.space.stateCache[index];
+        const voxel = dataCursor.getVoxel(x, y, z);
+        if (!voxel || !voxel.isRenderable()) {
+            this.space.foundHash[index] = 1;
             return -1;
         }
-        const voxelConstructor = VoxelModelConstructorRegister.constructorsPaltte[voxel.getId()];
-        if (!voxelConstructor || !voxelConstructor.isModel) {
-            this.stateCache[hashed] = -1;
+        const voxelId = voxel.getId();
+        const voxelConstructor = VoxelModelConstructorRegister.constructorsPaltte[voxelId];
+        if (!voxelConstructor) {
+            this.space.foundHash[index] = 1;
             return -1;
         }
+        this.space.voxelHash[index] = voxelId;
+        this.space.foundHash[index] = 2;
         //no ao
-        this.noCastAO[hashed] = voxel.isLightSource() || voxel.noAO();
+        this.space.noCastAO[index] = voxel.isLightSource() || voxel.noAO() ? 1 : 0;
         //state
-        const shapeState = voxel.getState();
-        const state = voxelConstructor.shapeStateTree.getState(shapeState);
-        this.stateCache[hashed] = state;
+        const state = voxelConstructor.shapeStateTree.getState(voxel.getState());
+        this.space.stateCache[index] = state;
         //mod
-        const mod = voxel.getMod();
-        const modState = voxelConstructor.modTree.getState(mod);
-        this.modCache[hashed] = modState;
+        const mod = voxelConstructor.modTree.getState(voxel.getMod());
+        this.space.modCache[index] = mod;
         this.voxelCursor.copy(voxel).process();
         voxelConstructor.schema.position.x = x;
         voxelConstructor.schema.position.y = y;
@@ -69,12 +108,7 @@ export class VoxelGeometryLookUp {
         voxelConstructor.schema.voxel = this.voxelCursor;
         voxelConstructor.schema.dataCursor = dataCursor;
         const conditonalState = voxelConstructor.condtioanlShapeStateTree.getState();
-        this.voxelHash[hashed] = voxelConstructor;
-        this.conditonalStateCache[hashed] = conditonalState;
-        this.geometryCache[hashed] =
-            voxelConstructor.data.shapeStateGeometryMap[state];
-        this.conditionalGeometryCache[hashed] =
-            voxelConstructor.data.condiotnalShapeStateGeometryMap[conditonalState];
-        return state;
+        this.space.conditonalStateCache[index] = conditonalState;
+        return 1;
     }
 }

package/Mesher/Tools/VoxelMeshBVHBuilder.js

@@ -1,4 +1,5 @@
 import { WorldSpaces } from "../../World/WorldSpaces";
+const MAX_FLOAT32 = new Float32Array([Infinity])[0];
 /**
  * A class to help with indexing a full flat binary tree defined by the number of levels it has.
  */
@@ -160,23 +161,29 @@ export class StructCursor {
         const ix = this.trueIndex;
         const iy = this.trueIndex + 1;
         const iz = this.trueIndex + 2;
-        this.data[ix] =
-            this.data[ix] == -Infinity || x < this.data[ix] ? x : this.data[ix];
-        this.data[iy] =
-            this.data[iy] == -Infinity || y < this.data[iy] ? y : this.data[iy];
-        this.data[iz] =
-            this.data[iz] == -Infinity || z < this.data[iz] ? z : this.data[iz];
+        if (x < this.data[ix] || this.data[ix] == -MAX_FLOAT32) {
+            this.data[ix] = x;
+        }
+        if (y < this.data[iy] || this.data[iy] == -MAX_FLOAT32) {
+            this.data[iy] = y;
+        }
+        if (z < this.data[iz] || this.data[iz] == -MAX_FLOAT32) {
+            this.data[iz] = z;
+        }
     }
     updateMax(x, y, z) {
         const ix = this.trueIndex + 4;
         const iy = this.trueIndex + 5;
         const iz = this.trueIndex + 6;
-        this.data[ix] =
-            this.data[ix] == -Infinity || x > this.data[ix] ? x : this.data[ix];
-        this.data[iy] =
-            this.data[iy] == -Infinity || y > this.data[iy] ? y : this.data[iy];
-        this.data[iz] =
-            this.data[iz] == -Infinity || z > this.data[iz] ? z : this.data[iz];
+        if (x > this.data[ix] || this.data[ix] == -MAX_FLOAT32) {
+            this.data[ix] = x;
+        }
+        if (y > this.data[iy] || this.data[iy] == -MAX_FLOAT32) {
+            this.data[iy] = y;
+        }
+        if (z > this.data[iz] || this.data[iz] == -MAX_FLOAT32) {
+            this.data[iz] = z;
+        }
     }
     toJSON() {
         return {
@@ -194,7 +201,7 @@ export class VoxelMeshBVHBuilder {
     structCursor = new StructCursor(this.tree);
     indices = new Uint32Array(this.treeIndex.getLevelSize(12) * 2);
     reset() {
-        this.tree.fill(-Infinity);
+        this.tree.fill(-MAX_FLOAT32);
         this.indices.fill(0);
     }
     updateVoxel(voxelX, voxelY, voxelZ, meshIndex, indicesStart, indicesEnd, minX, minY, minZ, maxX, maxY, maxZ) {
@@ -219,15 +226,3 @@ export class VoxelMeshBVHBuilder {
         }
     }
 }
-/*
-console.warn(
-  [voxelX, voxelY, voxelZ],
-  "add gometry",
-     [minX, minY, minZ],
-  [maxX, maxY, maxZ],
-  [voxelX, voxelY, voxelZ],
-  [indicesStart, indicesEnd],
-  indicesEnd - indicesStart,
-  (indicesEnd - indicesStart) / 3
-);
-*/

package/Mesher/Tools/VoxelMeshVertexStructCursor.d.ts

@@ -39,7 +39,9 @@ export declare class VoxelMeshVertexStructCursor {
     set colorB(value: number);
     trueIndex: number;
     _index: number;
-    data: Float32Array | number[];
+    data: {
+        [index: number]: number;
+    };
     get index(): number;
     set index(index: number);
     constructor(data?: Float32Array);

package/Mesher/Tools/VoxelMesherDataTool.d.ts

@@ -2,7 +2,7 @@ import { MesherDataTool } from "../Geomtry/Tools/MesherDataTools";
 import { QuadScalarVertexData } from "../Geomtry/Primitives/QuadVertexData";
 import { VoxelFaces } from "../../Math";
 import { QuadVerticies } from "../Geomtry/Geometry.types";
-import { Mesh } from "../Geomtry/Mesh";
+import { VoxelMesh } from "../Geomtry/VoxelMesh";
 import { VoxelMeshBVHBuilder } from "./VoxelMeshBVHBuilder";
 import { Vec3Array, Vector3Like } from "@amodx/math";
 import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface.js";
@@ -26,7 +26,7 @@ export declare class VoxelMesherDataTool extends MesherDataTool {
     position: Vector3Like;
     /**The current local origin  */
     origin: Vector3Like;
-    mesh: Mesh;
+    mesh: VoxelMesh;
     bvhTool: VoxelMeshBVHBuilder | null;
     vars: VoxelVars;
     dataCalculated: Record<VoxelFaces, boolean>;
@@ -44,5 +44,6 @@ export declare class VoxelMesherDataTool extends MesherDataTool {
     calculateFaceData(direction: VoxelFaces): true | undefined;
     clearCalculatedData(): void;
     reset(): void;
+    resetAll(): this;
 }
 export {};

package/Mesher/Tools/VoxelMesherDataTool.js

@@ -5,7 +5,7 @@ import { QuadScalarVertexData } from "../Geomtry/Primitives/QuadVertexData";
 import { VoxelFaces, VoxelFacesArray } from "../../Math";
 import { QuadVerticies } from "../Geomtry/Geometry.types";
 import { FaceDataCalc } from "../Models/Common/Calc/FaceDataCalc.js";
-import { Mesh } from "../Geomtry/Mesh";
+import { VoxelMesh } from "../Geomtry/VoxelMesh";
 import { Vector3Like } from "@amodx/math";
 class VoxelVars {
     faceFlipped = false;
@@ -29,7 +29,7 @@ export class VoxelMesherDataTool extends MesherDataTool {
     position = Vector3Like.Create();
     /**The current local origin  */
     origin = Vector3Like.Create();
-    mesh = new Mesh();
+    mesh = new VoxelMesh();
     bvhTool = null;
     vars = new VoxelVars();
     dataCalculated;
@@ -70,7 +70,7 @@ export class VoxelMesherDataTool extends MesherDataTool {
             this.lightData[face][QuadVerticies.BottomLeft] = 0;
             this.lightData[face][QuadVerticies.BottomRight] = 0;
         }
-        this.startNewMesh(new Mesh(true));
+        this.startNewMesh(new VoxelMesh());
     }
     bounds = {
         min: [0, 0, 0],
@@ -112,4 +112,9 @@ export class VoxelMesherDataTool extends MesherDataTool {
     reset() {
         this.vars.reset();
     }
+    resetAll() {
+        this.vars.reset();
+        this.mesh.clear();
+        return this;
+    }
 }

package/Renderer/Classes/DVESectionMeshes.d.ts

@@ -3,4 +3,5 @@ import { CompactMeshData } from "../../Mesher/Types/Mesher.types";
 import { SectionMesh } from "./SectionMesh";
 export declare abstract class DVESectionMeshes {
     abstract updateVertexData(section: SectionMesh, position: Vec3Array, data: CompactMeshData): SectionMesh;
+    abstract returnMesh(mesh: any): void;
 }

package/Renderer/Classes/SectionMesh.d.ts

@@ -1,11 +1,10 @@
-import { DVESectionMeshInterface } from "./DVESectionMeshInterface";
 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, DVESectionMeshInterface>;
+    meshes: Map<string, any>;
     effects: Map<string, VoxelEffect>;
     constructor(sector: SectorMesh, index: number);
     getPosition(): Vec3Array;

package/Renderer/Classes/SectionMesh.js

@@ -19,8 +19,5 @@ export class SectionMesh {
         for (const [key, effect] of this.effects) {
             effect.dispose();
         }
-        for (const [key, mesh] of this.meshes) {
-            mesh.dispose();
-        }
     }
 }

package/Renderer/InitTasks.js

@@ -2,9 +2,24 @@ 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);
-    Threads.registerTask("set-section", (data) => MeshManager.updateSection(data));
+    Threads.registerTask("set-section", (data, origin) => {
+        MeshManager.updateSection(data);
+        const tranfers = [];
+        for (const comp of data[1]) {
+            if (comp[0] !== 0)
+                continue;
+            for (const mesh of comp[1]) {
+                tranfers.push(mesh[1]);
+                tranfers.push(mesh[2]);
+            }
+        }
+        if (!EngineSettings.settings.rendererSettings.cpuBound) {
+            origin.sendMessage(data, tranfers);
+        }
+    });
     Threads.registerTask("remove-sector", (data) => {
         MeshManager.removeSector(data);
     });

package/Renderer/MeshManager.js

@@ -49,6 +49,10 @@ export class MeshManager {
             if (!section)
                 continue;
             section.dispose();
+            for (const [, mesh] of section.meshes) {
+                this.sectorMeshes.returnMesh(mesh);
+            }
+            section.meshes.clear();
         }
     }
 }

package/Renderer/MeshRegister.d.ts

@@ -1,6 +1,5 @@
 import { type LocationData } from "../Math/index.js";
 import { SectorMesh } from "./Classes/SectorMesh.js";
-import { DVESectionMeshInterface } from "./Classes/DVESectionMeshInterface.js";
 export type MeshRegisterDimensions = Map<string, Map<string, SectorMesh>>;
 declare class Sectors {
     static add(location: LocationData): SectorMesh;
@@ -10,11 +9,7 @@ declare class Sectors {
 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: DVESectionMeshInterface
-    ]>;
+    static getAllMeshes(id: string): Generator<[location: LocationData, substance: string, mesh: any]>;
     static remove(id: string): boolean;
 }
 export declare class MeshRegister {

package/Renderer/index.d.ts

@@ -1,4 +1,3 @@
 export * from "./Classes/DVESectionMeshes";
-export * from "./Classes/DVESectionMeshInterface";
 export * from "./Classes/SectionMesh";
 export * from "./Classes/SectorMesh";

package/Renderer/index.js

@@ -1,4 +1,3 @@
 export * from "./Classes/DVESectionMeshes";
-export * from "./Classes/DVESectionMeshInterface";
 export * from "./Classes/SectionMesh";
 export * from "./Classes/SectorMesh";

package/Settings/EngineSettings.d.ts

@@ -12,14 +12,14 @@ type EngineSettingsEvents = {
 declare class EngineSettingsClass extends TypedEventTarget<EngineSettingsEvents> {
     enviorment: "node" | "browser";
     settings: EngineSettingsData;
+    get doSunPropagation(): boolean;
+    get doRGBPropagation(): boolean;
+    get doLight(): boolean;
+    get doFlow(): boolean;
+    get isClient(): boolean;
     getSettings(): EngineSettingsData;
     syncSettings(data: EngineSettingsData): void;
     getSettingsCopy(): any;
-    doSunPropagation(): boolean;
-    doRGBPropagation(): boolean;
-    doLight(): boolean;
-    doFlow(): boolean;
-    isClient(): boolean;
 }
 export declare const EngineSettings: EngineSettingsClass;
 export {};

package/Settings/EngineSettings.js

@@ -8,6 +8,21 @@ import { TypedEventTarget } from "../Util/TypedEventTarget.js";
 class EngineSettingsClass extends TypedEventTarget {
     enviorment = Environment.isNode() ? "node" : "browser";
     settings = new EngineSettingsData();
+    get doSunPropagation() {
+        return this.settings.lighting.autoSunLight == true;
+    }
+    get doRGBPropagation() {
+        return this.settings.lighting.autoRGBLight == true;
+    }
+    get doLight() {
+        return this.doRGBPropagation || this.doSunPropagation;
+    }
+    get doFlow() {
+        return this.settings.flow.enable;
+    }
+    get isClient() {
+        return this.enviorment != "browser";
+    }
     getSettings() {
         return this.settings;
     }
@@ -34,20 +49,5 @@ class EngineSettingsClass extends TypedEventTarget {
     getSettingsCopy() {
         return JSON.parse(JSON.stringify(this.settings));
     }
-    doSunPropagation() {
-        return this.settings.lighting.autoSunLight == true;
-    }
-    doRGBPropagation() {
-        return this.settings.lighting.autoRGBLight == true;
-    }
-    doLight() {
-        return this.doRGBPropagation() || this.doSunPropagation();
-    }
-    doFlow() {
-        return this.settings.flow.enable;
-    }
-    isClient() {
-        return this.enviorment != "browser";
-    }
 }
 export const EngineSettings = new EngineSettingsClass();