@xeokit/xeokit-sdk 2.4.0-alpha-81 → 2.4.0-alpha-83

package/src/viewer/scene/lod/LOD.js

@@ -0,0 +1,162 @@
+import {Component} from "../Component";
+import {LODCullingManager} from "./LODCullingManager";
+
+/**
+ * Manages LOD culling for {@link SceneModel} implementations.
+ */
+export class LOD extends Component {
+
+    /** @private */
+    constructor(scene, cfg = {}) {
+
+        super(scene, cfg);
+
+        this._scene = scene;
+        this._lodLevels = [2000, 600, 150, 80, 20];
+        this._lodManagers = {};
+        this._lodManagerList = [];
+
+        this.enabled = cfg.enabled;
+        this.targetFPS = cfg.targetFPS;
+
+        this._init();
+    }
+
+    _init() {
+
+        const MAX_NUM_TICKS = 4;
+        const tickTimeArray = new Array(MAX_NUM_TICKS);
+
+        let numTick = 0;
+        let currentFPS = -1;
+        let preRenderTime = Date.now();
+        let deltaTime = 0;
+        let sceneTick = 0;
+        let lastTickCameraMoved = sceneTick;
+
+        this._scene.on("rendering", () => { // Apply LOD-culling before rendering the scene
+            if (currentFPS === -1) {
+                return;
+            }
+            for (let i = 0, len = this._lodManagerList.length; i < len; i++) {
+                this._lodManagerList[i].applyLodCulling(currentFPS);
+            }
+        });
+
+        this._scene.on("rendered", () => {
+            preRenderTime = Date.now();
+            window.requestAnimationFrame(() => {
+                numTick++;
+                const newTime = Date.now();
+                deltaTime = newTime - preRenderTime;
+                preRenderTime = newTime;
+                tickTimeArray[numTick % MAX_NUM_TICKS] = deltaTime;
+                let sumTickTimes = 0;
+                if (numTick > MAX_NUM_TICKS) {
+                    for (let i = 0; i < MAX_NUM_TICKS; i++) {
+                        sumTickTimes += tickTimeArray[i];
+                    }
+                    currentFPS = MAX_NUM_TICKS / sumTickTimes * 1000;
+                }
+            });
+        });
+
+        this._scene.camera.on("matrix", () => {
+            lastTickCameraMoved = sceneTick;
+        });
+
+        this._scene.on("tick", () => {
+            if ((sceneTick - lastTickCameraMoved) > 3) {
+                for (let i = 0, len = this._lodManagerList.length; i < len; i++) {   // Call LOD-culling tasks
+                    this._lodManagerList[i].resetLodCulling();
+                }
+            }
+            sceneTick++;
+        });
+    }
+
+    /**
+     * Sets whether LOD is enabled for the {@link Scene}.
+     *
+     * Default value is ````false````.
+     *
+     * @type {Boolean}
+     */
+    set enabled(value) {
+        value = !!value;
+        if (this._enabled === value) {
+            return;
+        }
+        this._enabled = value;
+        this.glRedraw();
+    }
+
+    /**
+     * Gets whether LOD is enabled for the {@link Scene}.
+     *
+     * Default value is ````false````.
+     *
+     * @type {Boolean}
+     */
+    get enabled() {
+        return this._enabled;
+    }
+
+    /**
+     * Sets the maximum area that LOD takes into account when checking for possible occlusion for each fragment.
+     *
+     * Default value is ````30.0````.
+     *
+     * @type {Number}
+     */
+    set targetFPS(value) {
+        if (value === undefined || value === null) {
+            value = 30.0;
+        }
+        if (this._targetFPS === value) {
+            return;
+        }
+        this._targetFPS = value;
+        this.glRedraw();
+    }
+
+    /**
+     * Gets the maximum area that LOD takes into account when checking for possible occlusion for each fragment.
+     *
+     * Default value is ````30.0````.
+     *
+     * @type {Number}
+     */
+    get targetFPS() {
+        return this._targetFPS;
+    }
+
+    /**
+     * Called within SceneModel constructors
+     * @private
+     */
+    getLODManager(sceneModel) {
+        const lodManager = new LODCullingManager(this.scene, sceneModel, this._lodLevels, this._targetFPS);
+        this._lodManagers[lodManager.id] = lodManager;
+        this._lodManagerList = Object.values(this._lodManagers);
+        return lodManager;
+    }
+
+    /**
+     * Called within SceneModel destructors
+     * @private
+     */
+    putLODManager(lodManager) {
+        delete this._lodManagers[lodManager.id];
+        this._lodManagerList = Object.values(this._lodManagers);
+    }
+
+    /**
+     * Destroys this component.
+     *
+     * @private
+     */
+    destroy() {
+        super.destroy();
+    }
+}

package/src/viewer/scene/lod/LODCullingManager.js

@@ -0,0 +1,83 @@
+import {LODState} from "./LODState";
+
+/**
+ * @private
+ */
+export class LODCullingManager {
+
+    constructor(scene, sceneModel, lodLevels, targetFps) {
+        this.id = sceneModel.id;
+        this.scene = scene;
+        this.sceneModel = sceneModel;
+        this.lodState = new LODState(lodLevels, targetFps);
+        this.lodState.initializeLodState(sceneModel);
+    }
+
+    /**
+     * Cull any objects belonging to the current `LOD` level, and increase the `LOD` level.
+     */
+    _increaseLODLevelIndex() {
+        const lodState = this.lodState;
+        if (lodState.lodLevelIndex === lodState.primLODLevels.length) {
+            return false;
+        }
+        const entitiesInLOD = lodState.entitiesInLOD [lodState.primLODLevels[lodState.lodLevelIndex]] || [];
+        for (let i = 0, len = entitiesInLOD.length; i < len; i++) {
+
+            entitiesInLOD[i].culledLOD = true;
+        }
+        lodState.lodLevelIndex++;
+        return true;
+    }
+
+    /**
+     * Un-cull any objects belonging to the current `LOD` level, and decrease the `LOD` level.
+     */
+    _decreaseLODLevelIndex() {
+        const lodState = this.lodState;
+        if (lodState.lodLevelIndex === 0) {
+            return false;
+        }
+        const entitiesInLOD = lodState.entitiesInLOD [lodState.primLODLevels[lodState.lodLevelIndex - 1]] || [];
+        for (let i = 0, len = entitiesInLOD.length; i < len; i++) {
+            entitiesInLOD[i].culledLOD = false;
+        }
+        lodState.lodLevelIndex--;
+        return true;
+    }
+
+    /**
+     * Apply LOD culling.
+     *
+     * Will update LOD level, if needed, based on current FPS and target FPS,
+     * and then will cull/uncull the needed objects according to the LOD level.
+     *
+     * @param {number} currentFPS The current FPS (frames per second)
+     * @returns {boolean} Whether the LOD level was changed. This is, if some object was culled/unculled.
+     */
+    applyLodCulling(currentFPS) {
+        let lodState = this.lodState;
+        let retVal = false;
+        if (currentFPS < lodState.targetFps) {
+            if (++lodState.consecutiveFramesWithoutTargetFps > 0) {
+                lodState.consecutiveFramesWithoutTargetFps = 0;
+                retVal = this._increaseLODLevelIndex();
+            }
+        } else if (currentFPS > (lodState.targetFps + 4)) {
+            if (++lodState.consecutiveFramesWithTargetFps > 1) {
+                lodState.consecutiveFramesWithTargetFps = 0;
+                retVal = this._decreaseLODLevelIndex();
+            }
+        }
+        return retVal;
+    }
+
+    resetLodCulling() {
+        let retVal = false;
+        let decreasedLevel = false;
+        do {
+            retVal |= (decreasedLevel = this._decreaseLODLevelIndex());
+        } while (decreasedLevel);
+        return retVal;
+    }
+}

package/src/viewer/scene/lod/LODState.js

@@ -0,0 +1,125 @@
+/**
+ * Data structure containing pre-initialized `LOD` data.
+ *
+ * Will be used by the rest of `LOD` related code.
+ *
+ * @private
+ */
+import {math} from "../math";
+
+export class LODState {
+
+    /**
+     * @param {Array<number>} primLODLevels The primtive counts for the LOD levels, for example ```[ 2000, 600, 150, 80, 20 ]```
+     * @param {number} targetFps The target FPS (_Frames Per Second_) for the dynamic culling of objects in the different LOD levels.
+     */
+    constructor(primLODLevels, targetFps) {
+
+        /**
+         * An array ordered DESC with the number of primtives allowed in each LOD bucket.
+         *
+         * @type {Array<number>}
+         */
+        this.primLODLevels = primLODLevels;
+
+        /**
+         * A computed dictionary for `primtive-number-buckets` where:
+         * - key: the number of primtives allowed for the objects in the bucket.
+         * - value: all PerformanceNodes that have the number of primtives or more.
+         *
+         * @type {Map<number, Array<DataTextureSceneModelNode>>}
+         */
+        this.entitiesInLOD = {};
+
+        /**
+         * A computed dictionary for `primtive-number-buckets` where:
+         * - key: the number of primtives allowed for the objects in the bucket.
+         * - value: the sum of primtives counts for all PeformanceNodes in the bucket.
+         *
+         * @type {Map<number, number>}
+         */
+        this.primCountInLOD = {};
+
+        /**
+         * The target FPS for the `LOD` mechanism:
+         * - if real FPS are below this number, the next `LOD` level will be applied.
+         *
+         * - if real FPS are...
+         *   - above this number plus a margin
+         *   - and for some consecutive frames
+         *  ... then the previous `LOD` level will be applied.
+         *
+         * @type {number}
+         */
+        this.targetFps = targetFps;
+
+        // /**
+        //  * Not used at the moment.
+        //  */
+        // this.restoreTime = LOD_RESTORE_TIME;
+
+        /**
+         * Current `LOD` level. Starts at 0.
+         *
+         * @type {number}
+         */
+        this.lodLevelIndex = 0;
+
+        /**
+         * Number of consecutive frames in current `LOD` level where FPS was above `targetFps`
+         *
+         * @type {number}
+         */
+        this.consecutiveFramesWithTargetFps = 0;
+
+        /**
+         * Number of consecutive frames in current `LOD` level where FPS was below `targetFps`
+         *
+         * @type {number}
+         */
+        this.consecutiveFramesWithoutTargetFps = 0;
+    }
+
+    /**
+     * @param {SceneModel} sceneModel
+     */
+    initializeLodState(sceneModel) {
+        const entityList = Object.values(sceneModel.objects);
+        if (entityList.length === 0) {
+            return;
+        }
+        const entitiesInLOD = {};
+        const primCountInLOD = {};
+        const maxSize = 15;
+        const minComplexity = 10;
+
+        for (let i = 0, len = entityList.length; i < len; i++) {
+            const entity = entityList[i];
+            const entityComplexity = entity.numPrimitives;
+            const entitySize = math.getAABB3Diag(entity.aabb);
+// //            const isCullable = ((minComplexity <= entityComplexity) && (entitySize <= maxSize));
+//             const isCullable = ( (entitySize <= maxSize));
+//
+//             if (!isCullable) {
+//                 continue;
+//             }
+            let lodLevel = 0, len;
+            for (lodLevel = 0, len = this.primLODLevels.length; lodLevel < len; lodLevel++) {
+                if (entity.numPrimitives >= this.primLODLevels [lodLevel]) {
+                    break;
+                }
+            }
+            const lodPrims = this.primLODLevels [lodLevel] || 0;
+            if (!(lodPrims in entitiesInLOD)) {
+                entitiesInLOD [lodPrims] = [];
+            }
+            entitiesInLOD [lodPrims].push(entity);
+            if (!(lodPrims in primCountInLOD)) {
+                primCountInLOD [lodPrims] = 0;
+            }
+            primCountInLOD [lodPrims] += entity.numPrimitives;
+        }
+        this.entitiesInLOD = entitiesInLOD;
+        this.primCountInLOD = primCountInLOD;
+    }
+}

package/src/viewer/scene/lod/index.js

@@ -0,0 +1 @@
+export * from "./LOD.js";