@xeokit/xeokit-sdk 2.5.2-beta-10 → 2.5.2-beta-13

package/src/src/viewer/scene/core.js

@@ -0,0 +1,268 @@
+import {Queue} from './utils/Queue.js';
+import {Map} from './utils/Map.js';
+import {stats} from './stats.js';
+import {utils} from './utils.js';
+
+const scenesRenderInfo = {}; // Used for throttling FPS for each Scene
+const sceneIDMap = new Map(); // Ensures unique scene IDs
+const taskQueue = new Queue(); // Task queue, which is pumped on each frame; tasks are pushed to it with calls to xeokit.schedule
+const tickEvent = {sceneId: null, time: null, startTime: null, prevTime: null, deltaTime: null};
+const taskBudget = 10; // Millisecs we're allowed to spend on tasks in each frame
+const fpsSamples = [];
+const numFPSSamples = 30;
+
+let lastTime = 0;
+let elapsedTime;
+let totalFPS = 0;
+
+
+/**
+ * @private
+ */
+function Core() {
+
+    /**
+     Semantic version number. The value for this is set by an expression that's concatenated to
+     the end of the built binary by the xeokit build script.
+     @property version
+     @namespace xeokit
+     @type {String}
+     */
+    this.version = "1.0.0";
+
+    /**
+     Existing {@link Scene}s , mapped to their IDs
+     @property scenes
+     @namespace xeokit
+     @type {Scene}
+     */
+    this.scenes = {};
+
+    this._superTypes = {}; // For each component type, a list of its supertypes, ordered upwards in the hierarchy.
+
+    /**
+     * Registers a scene on xeokit.
+     * This is called within the xeokit.Scene constructor.
+     * @private
+     */
+    this._addScene = function (scene) {
+        if (scene.id) { // User-supplied ID
+            if (core.scenes[scene.id]) {
+                console.error(`[ERROR] Scene ${utils.inQuotes(scene.id)} already exists`);
+                return;
+            }
+        } else { // Auto-generated ID
+            scene.id = sceneIDMap.addItem({});
+        }
+        core.scenes[scene.id] = scene;
+        const ticksPerOcclusionTest = scene.ticksPerOcclusionTest;
+        const ticksPerRender = scene.ticksPerRender;
+        scenesRenderInfo[scene.id] = {
+            ticksPerOcclusionTest: ticksPerOcclusionTest,
+            ticksPerRender: ticksPerRender,
+            renderCountdown: ticksPerRender
+        };
+        stats.components.scenes++;
+        scene.once("destroyed", () => { // Unregister destroyed scenes
+            sceneIDMap.removeItem(scene.id);
+            delete core.scenes[scene.id];
+            delete scenesRenderInfo[scene.id];
+            stats.components.scenes--;
+        });
+    };
+
+    /**
+     * @private
+     */
+    this.clear = function () {
+        let scene;
+        for (const id in core.scenes) {
+            if (core.scenes.hasOwnProperty(id)) {
+                scene = core.scenes[id];
+                // Only clear the default Scene
+                // but destroy all the others
+                if (id === "default.scene") {
+                    scene.clear();
+                } else {
+                    scene.destroy();
+                    delete core.scenes[scene.id];
+                }
+            }
+        }
+    };
+
+    /**
+     * Schedule a task to run at the next frame.
+     *
+     * Internally, this pushes the task to a FIFO queue. Within each frame interval, xeokit processes the queue
+     * for a certain period of time, popping tasks and running them. After each frame interval, tasks that did not
+     * get a chance to run during the task are left in the queue to be run next time.
+     *
+     * @param {Function} callback Callback that runs the task.
+     * @param {Object} [scope] Scope for the callback.
+     */
+    this.scheduleTask = function (callback, scope = null) {
+        taskQueue.push(callback);
+        taskQueue.push(scope);
+    };
+
+    this.runTasks = function (until = -1) { // Pops and processes tasks in the queue, until the given number of milliseconds has elapsed.
+        let time = (new Date()).getTime();
+        let callback;
+        let scope;
+        let tasksRun = 0;
+        while (taskQueue.length > 0 && (until < 0 || time < until)) {
+            callback = taskQueue.shift();
+            scope = taskQueue.shift();
+            if (scope) {
+                callback.call(scope);
+            } else {
+                callback();
+            }
+            time = (new Date()).getTime();
+            tasksRun++;
+        }
+        return tasksRun;
+    };
+
+    this.getNumTasks = function () {
+        return taskQueue.length;
+    };
+}
+
+/**
+ * @private
+ * @type {Core}
+ */
+const core = new Core();
+
+const frame = function () {
+    let time = Date.now();
+    elapsedTime = time - lastTime;
+    if (lastTime > 0 && elapsedTime > 0) { // Log FPS stats
+        var newFPS = 1000 / elapsedTime; // Moving average of FPS
+        totalFPS += newFPS;
+        fpsSamples.push(newFPS);
+        if (fpsSamples.length >= numFPSSamples) {
+            totalFPS -= fpsSamples.shift();
+        }
+        stats.frame.fps = Math.round(totalFPS / fpsSamples.length);
+    }
+    for (let id in core.scenes) {
+        core.scenes[id].compile();
+    }
+    runTasks(time);
+    lastTime = time;
+};
+
+class WorkerInterval {
+    worker = null;
+
+    constructor(callback, interval) {
+        const blob = new Blob([`setInterval(() => postMessage(0), ${interval});`]);
+        const workerScript = URL.createObjectURL(blob);
+        this.worker = new Worker(workerScript);
+        this.worker.onmessage = callback;
+    }
+
+    stop() {
+        this.worker.terminate();
+    }
+}
+
+const interval = new WorkerInterval(frame, 100);
+
+const renderFrame = function () {
+    let time = Date.now();
+    elapsedTime = time - lastTime;
+    if (lastTime > 0 && elapsedTime > 0) { // Log FPS stats
+        var newFPS = 1000 / elapsedTime; // Moving average of FPS
+        totalFPS += newFPS;
+        fpsSamples.push(newFPS);
+        if (fpsSamples.length >= numFPSSamples) {
+            totalFPS -= fpsSamples.shift();
+        }
+        stats.frame.fps = Math.round(totalFPS / fpsSamples.length);
+    }
+    runTasks(time);
+    fireTickEvents(time);
+    renderScenes();
+    (window.requestPostAnimationFrame !== undefined) ? window.requestPostAnimationFrame(frame) : requestAnimationFrame(renderFrame);
+};
+
+renderFrame();
+
+function runTasks(time) { // Process as many enqueued tasks as we can within the per-frame task budget
+    const tasksRun = core.runTasks(time + taskBudget);
+    const tasksScheduled = core.getNumTasks();
+    stats.frame.tasksRun = tasksRun;
+    stats.frame.tasksScheduled = tasksScheduled;
+    stats.frame.tasksBudget = taskBudget;
+}
+
+function fireTickEvents(time) { // Fire tick event on each Scene
+    tickEvent.time = time;
+    for (var id in core.scenes) {
+        if (core.scenes.hasOwnProperty(id)) {
+            var scene = core.scenes[id];
+            tickEvent.sceneId = id;
+            tickEvent.startTime = scene.startTime;
+            tickEvent.deltaTime = tickEvent.prevTime != null ? tickEvent.time - tickEvent.prevTime : 0;
+            /**
+             * Fired on each game loop iteration.
+             *
+             * @event tick
+             * @param {String} sceneID The ID of this Scene.
+             * @param {Number} startTime The time in seconds since 1970 that this Scene was instantiated.
+             * @param {Number} time The time in seconds since 1970 of this "tick" event.
+             * @param {Number} prevTime The time of the previous "tick" event from this Scene.
+             * @param {Number} deltaTime The time in seconds since the previous "tick" event from this Scene.
+             */
+            scene.fire("tick", tickEvent, true);
+        }
+    }
+    tickEvent.prevTime = time;
+}
+
+function renderScenes() {
+    const scenes = core.scenes;
+    const forceRender = false;
+    let scene;
+    let renderInfo;
+    let ticksPerOcclusionTest;
+    let ticksPerRender;
+    let id;
+    for (id in scenes) {
+        if (scenes.hasOwnProperty(id)) {
+
+            scene = scenes[id];
+            renderInfo = scenesRenderInfo[id];
+
+            if (!renderInfo) {
+                renderInfo = scenesRenderInfo[id] = {}; // FIXME
+            }
+
+            ticksPerOcclusionTest = scene.ticksPerOcclusionTest;
+            if (renderInfo.ticksPerOcclusionTest !== ticksPerOcclusionTest) {
+                renderInfo.ticksPerOcclusionTest = ticksPerOcclusionTest;
+                renderInfo.renderCountdown = ticksPerOcclusionTest;
+            }
+            if (--scene.occlusionTestCountdown <= 0) {
+                scene.doOcclusionTest();
+                scene.occlusionTestCountdown = ticksPerOcclusionTest;
+            }
+
+            ticksPerRender = scene.ticksPerRender;
+            if (renderInfo.ticksPerRender !== ticksPerRender) {
+                renderInfo.ticksPerRender = ticksPerRender;
+                renderInfo.renderCountdown = ticksPerRender;
+            }
+            if (--renderInfo.renderCountdown === 0) {
+                scene.render(forceRender);
+                renderInfo.renderCountdown = ticksPerRender;
+            }
+        }
+    }
+}
+
+export {core};

package/src/src/viewer/scene/geometry/Geometry.js

@@ -0,0 +1,33 @@
+import {Component} from '../Component.js';
+import {stats} from '../stats.js';
+
+/**
+ * @desc Defines a shape for one or more {@link Mesh}es.
+ *
+ * * {@link ReadableGeometry} is a subclass that stores its data in both browser and GPU memory. Use ReadableGeometry when you need to keep the geometry arrays in browser memory.
+ * * {@link VBOGeometry} is a subclass that stores its data solely in GPU memory. Use VBOGeometry when you need a lower memory footprint and don't need to keep the geometry data in browser memory.
+ */
+class Geometry extends Component {
+
+    /** @private */
+    get type() {
+        return "Geometry";
+    }
+
+    /** @private */
+    get isGeometry() {
+        return true;
+    }
+
+    constructor(owner, cfg = {}) {
+        super(owner, cfg);
+        stats.memory.meshes++;
+    }
+
+    destroy() {
+        super.destroy();
+        stats.memory.meshes--;
+    }
+}
+
+export {Geometry};