@urso/core 0.6.3 → 0.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@urso/core",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "description": "HTML5 game engine",
   "main": "build/js/index.js",
   "author": "Megbrimef",

package/src/js/components/debug/fps.js

@@ -21,12 +21,14 @@ class ComponentsDebugFps {
         this.frames++;
 
         if (currentTime - this.lastUpdateTime < 1000)
-            return
+            return;
 
         const fps = Math.round(1000 * this.frames / (currentTime - this.lastUpdateTime));
         this.lastUpdateTime = currentTime;
         this.frames = 0;
-        this._coordsText.text = 'fps:' + fps;
+
+        const fpsData = Urso.scenes.getFpsData();
+        this._coordsText.text = `fps: ${fps}, sceneFps: ${fpsData.fps}, limit: ${fpsData.limit}`;
     };
 
 }

package/src/js/config/main.js

@@ -6,7 +6,11 @@ let ConfigMain = {
     extendingChain: ['Urso.Core'], //chain that will be set as Urso.Game
     defaultScene: 'play', //default scene to display
     useBinPath: false, // use assets from bin directory
-    useTransport: false // use transport module for connetcting with server
+    useTransport: false, // use transport module for connetcting with server
+    fps: {
+        limit: 60, //max fps limit
+        optimizeLowPerformance: true //down to 30 fps if lower 60
+    }
 };
 
 module.exports = ConfigMain;

package/src/js/modules/scenes/controller.js

@@ -21,6 +21,22 @@ class ModulesScenesController {
         this._service.display(name);
     }
 
+    /**
+     * get fps
+     * @returns {Number}
+     */
+    getFps() {
+        return this.getInstance('PixiWrapper').getFps();
+    }
+
+    /**
+     * get fps data
+     * @returns {Object}
+     */
+    getFpsData() {
+        return this.getInstance('PixiWrapper').getFpsData();
+    }
+
     /**
      * pause scene
      */

package/src/js/modules/scenes/pixiWrapper.js

@@ -1,3 +1,6 @@
+const NORMAL_FPS_COUNT = 60;
+const LOW_PERFORMANCE_FPS_COUNT = 30;
+
 class ModulesScenesPixiWrapper {
     constructor() {
         this.singleton = true;
@@ -13,10 +16,17 @@ class ModulesScenesPixiWrapper {
         this._loopPaused = false;
         this._loopLastCall = 0;
 
-        this.loop = this.loop.bind(this);
+        this._loop = this._loop.bind(this);
         this.passiveCallIntervalId = null;
 
         this._mouseCoords = { x: 0, y: 0 };
+
+
+        this._maxFPSLimit = Urso.config.fps.limit;
+        this._lastUpdateTime = 0;
+        this._frames = 0;
+        this._currentFPS = Urso.config.fps.limit;
+        this._lastTimeCheckFPS = 0;
     }
 
     init() {
@@ -35,7 +45,7 @@ class ModulesScenesPixiWrapper {
         this.interaction = new PIXI.InteractionManager(this.renderer);
 
         this._loaderScene = this.getInstance('Model');
-        this._requestAnimFrame(this.loop);
+        this._requestAnimFrame(this._loop);
 
         this.getInstance('Resolutions');
     }
@@ -62,10 +72,112 @@ class ModulesScenesPixiWrapper {
     resume() {
         this._loopLastCall = Date.now();
         this._loopPaused = false;
-        this.update();
+        this._update();
         PIXI.spine.settings.GLOBAL_AUTO_UPDATE = true;
     }
 
+    /**
+     * resize renderer
+     * @param {Number} width
+     * @param {Number} height
+     */
+    resize(width, height) {
+        this.renderer.resize(width, height);
+    };
+
+    /**
+     * hide canvas
+     */
+    hideCanvas() {
+        this.renderer.view.style.display = 'none';
+    }
+
+    /**
+     * show canvas
+     */
+    showCanvas() {
+        this.renderer.view.style.display = '';
+    }
+
+    /**
+     * set world scale
+     * @param {Number} x
+     * @param {Number} y
+     */
+    setWorldScale(x, y) {
+        this.world.scale.x = x;
+        this.world.scale.y = y;
+    }
+
+    /**
+     * set canvas width
+     * @param {Number} val
+     */
+    setCanvasWidth(val) {
+        this.renderer.view.style.width = val + 'px';
+    };
+
+    /**
+     * set canvas height
+     * @param {Number} val
+     */
+    setCanvasHeight(val) {
+        this.renderer.view.style.height = val + 'px';
+    };
+
+    /**
+     * get pixi world (main Container)
+     * @returns {Object}
+     */
+    getPixiWorld() {
+        return this.world;
+    }
+
+    /**
+     * set new scene
+     * @param {Object} model
+     */
+    setNewScene(model) {
+        this._createWorld();
+        this.currentScene = model;
+    }
+
+    /**
+     * get fps
+     * @returns {Number}
+     */
+    getFps() {
+        return this._currentFPS;
+    }
+
+    /**
+     * get fps data
+     * @returns {Object}
+     */
+    getFpsData() {
+        return {
+            fps: this._currentFPS,
+            limit: this._maxFPSLimit
+        }
+    }
+
+    /**
+     * get cached mouse coords
+     * @returns {Object}
+     */
+    getCachedMouseCoords() {
+        return this._mouseCoords;
+    }
+
+    /**
+     * generateTexture from object
+     * @param {Object} obj
+     * @returns {Object} - pixi.Texture
+     */
+    generateTexture(obj) {
+        return this.renderer.generateTexture(obj);
+    }
+
     _setPixiSettings() {
         PIXI.settings.SCALE_MODE = PIXI.SCALE_MODES.LINEAR;
         PIXI.settings.TEXT_RESOLUTION = 1;
@@ -107,19 +219,53 @@ class ModulesScenesPixiWrapper {
         return deltaTime * 60 / 1000;
     };
 
-    loop() {
+    _loop() {
         if (this._loopStopped)
             return false;
 
-        this._requestAnimFrame(this.loop);
+        this._requestAnimFrame(this._loop);
 
-        if (!this._loopPaused)
-            this.update();
+        if (!this._loopPaused) {
+            if (!this._fpsCheckAllowUpdate())
+                return;
+
+            this._update();
+        }
 
         return true;
     };
 
-    update() {
+    _fpsCheckAllowUpdate() {
+        const currentTime = Urso.time.get();
+        this._updateCurrentFPS(currentTime);
+
+        //setup maxFPSLimit
+        if (Urso.config.fps.optimizeLowPerformance)
+            if (this._currentFPS < NORMAL_FPS_COUNT)
+                this._maxFPSLimit = LOW_PERFORMANCE_FPS_COUNT;
+            else
+                this._maxFPSLimit = Urso.config.fps.limit;
+
+        //check need update
+        if (currentTime - this._lastUpdateTime < ~~(1000 / this._maxFPSLimit))
+            return false;
+
+        this._lastUpdateTime = currentTime;
+        return true;
+    }
+
+    _updateCurrentFPS(currentTime) {
+        this._frames++;
+
+        if (currentTime - this._lastTimeCheckFPS < 1000)
+            return;
+
+        this._currentFPS = Math.round(1000 * this._frames / (currentTime - this._lastTimeCheckFPS));
+        this._lastTimeCheckFPS = currentTime;
+        this._frames = 0;
+    }
+
+    _update() {
         if (!this.currentScene)
             return;
 
@@ -135,41 +281,6 @@ class ModulesScenesPixiWrapper {
         this.renderer.render(this._root);
     };
 
-    //size
-    resize(width, height) {
-        this.renderer.resize(width, height);
-    };
-
-    hideCanvas() {
-        this.renderer.view.style.display = 'none';
-    }
-
-    showCanvas() {
-        this.renderer.view.style.display = '';
-    }
-
-    setWorldScale(x, y) {
-        this.world.scale.x = x;
-        this.world.scale.y = y;
-    }
-
-    setCanvasWidth(val) {
-        this.renderer.view.style.width = val + 'px';
-    };
-
-    setCanvasHeight(val) {
-        this.renderer.view.style.height = val + 'px';
-    };
-
-    getPixiWorld() {
-        return this.world;
-    }
-
-    setNewScene(model) {
-        this._createWorld();
-        this.currentScene = model;
-    }
-
     _checkMouse() {
         let newCoords = this._getMouseCoords();
 
@@ -180,10 +291,6 @@ class ModulesScenesPixiWrapper {
         this.emit(Urso.events.MODULES_SCENES_MOUSE_NEW_POSITION, this._mouseCoords);
     };
 
-    getCachedMouseCoords() {
-        return this._mouseCoords;
-    }
-
     _getMouseCoords() {
         const coords = {
             x: ~~(this.interaction.mouse.global.x / this.world.scale.x),
@@ -204,7 +311,7 @@ class ModulesScenesPixiWrapper {
      * reserve loop, when browser tab is inactive
      * @param {Boolean} isVisible
      */
-    visibilityChangeHandler(isVisible) {
+    _visibilityChangeHandler(isVisible) {
         if (isVisible) {
             if (this.passiveCallIntervalId) {
                 clearInterval(this.passiveCallIntervalId);
@@ -215,22 +322,13 @@ class ModulesScenesPixiWrapper {
 
         this.passiveCallIntervalId = setInterval(() => {
             if (!this._loopStopped && !this._loopPaused) {
-                this.update();
+                this._update();
             }
         }, 16);
     }
 
-    /**
-     * generateTexture from object
-     * @param {Object} obj
-     * @returns {Object} - pixi.Texture
-     */
-     generateTexture(obj) {
-        return this.renderer.generateTexture(obj);
-    }
-
     _subscribeOnce() {
-        this.addListener(Urso.events.EXTRA_BROWSEREVENTS_WINDOW_VISIBILITYCHANGE, this.visibilityChangeHandler.bind(this), true);
+        this.addListener(Urso.events.EXTRA_BROWSEREVENTS_WINDOW_VISIBILITYCHANGE, this._visibilityChangeHandler.bind(this), true);
     }
 }