@babylonjs/core 9.10.1 → 9.12.0

package/Engines/abstractEngine.pure.d.ts

@@ -36,6 +36,7 @@ import { type IAudioEngine } from "../Audio/Interfaces/IAudioEngine.js";
 import { type WebRequest } from "../Misc/webRequest.js";
 import { type PerformanceMonitor } from "../Misc/performanceMonitor.js";
 import { type ILoadingScreen } from "../Loading/loadingScreen.pure.js";
+import { type ICustomAnimationFrameRequester } from "../Misc/customAnimationFrameRequester.js";
 import { DepthCullingState } from "../States/depthCullingState.js";
 import { StencilStateComposer } from "../States/stencilStateComposer.js";
 import { StencilState } from "../States/stencilState.js";
@@ -505,6 +506,10 @@ export declare abstract class AbstractEngine {
     _frameHandler: number;
     /** @internal */
     protected _activeRenderLoops: (() => void)[];
+    /**
+     * If set, will be used to request the next animation frame for the render loop
+     */
+    customAnimationFrameRequester: Nullable<ICustomAnimationFrameRequester>;
     /**
      * Gets the list of current active render loop functions
      * @returns a read only array with the current render loop functions
@@ -549,7 +554,7 @@ export declare abstract class AbstractEngine {
     protected _isOverFrameTime(timestamp?: number): boolean;
     protected _processFrame(timestamp?: number): void;
     /** @internal */
-    _renderLoop(timestamp: number | undefined): void;
+    _renderLoop(timestamp?: number): void;
     /** @internal */
     _renderFrame(): void;
     /** @internal */
@@ -559,6 +564,7 @@ export declare abstract class AbstractEngine {
      * @internal
      */
     protected _queueNewFrame(bindedRenderFunction: any, requester?: any): number;
+    protected _queueNewFrameForRenderLoop(): void;
     /**
      * Register and execute a render loop. The engine can have more than one render function
      * @param renderFunction defines the function to continuously execute

package/Engines/abstractEngine.pure.js

@@ -26,6 +26,12 @@ export function QueueNewFrame(func, requester) {
     // Note that there is kind of a typing issue here, as `setTimeout` might return something else than a number (NodeJs returns a NodeJS.Timeout object).
     // Also if the global `requestAnimationFrame`'s returnType is number, `requester.requestPostAnimationFrame` and `requester.requestAnimationFrame` types
     // are `any`.
+    if (requester) {
+        const { requestAnimationFrame } = requester;
+        if (typeof requestAnimationFrame === "function") {
+            return requestAnimationFrame(func);
+        }
+    }
     if (!IsWindowObjectExist()) {
         if (typeof requestAnimationFrame === "function") {
             return requestAnimationFrame(func);
@@ -347,6 +353,17 @@ export class AbstractEngine {
         }
     }
     _cancelFrame() {
+        if (this.customAnimationFrameRequester) {
+            if (this._frameHandler !== 0) {
+                this._frameHandler = 0;
+                const { cancelAnimationFrame } = this.customAnimationFrameRequester;
+                if (cancelAnimationFrame) {
+                    cancelAnimationFrame(this.customAnimationFrameRequester.requestID);
+                }
+                delete this.customAnimationFrameRequester.requestID;
+            }
+            return;
+        }
         if (this._frameHandler !== 0) {
             const handlerToCancel = this._frameHandler;
             this._frameHandler = 0;
@@ -435,7 +452,7 @@ export class AbstractEngine {
         // `stopRenderLoop` is called mid frame). The second condition prevents queuing another frame if one has
         // already been queued (e.g., if `stopRenderLoop` and `runRenderLoop` is called mid frame).
         if (this._activeRenderLoops.length > 0 && this._frameHandler === 0) {
-            this._frameHandler = this._queueNewFrame(this._boundRenderFunction, this.getHostWindow());
+            this._queueNewFrameForRenderLoop();
         }
     }
     /** @internal */
@@ -456,6 +473,15 @@ export class AbstractEngine {
     _queueNewFrame(bindedRenderFunction, requester) {
         return QueueNewFrame(bindedRenderFunction, requester);
     }
+    _queueNewFrameForRenderLoop() {
+        if (this.customAnimationFrameRequester) {
+            this.customAnimationFrameRequester.requestID = this._queueNewFrame(this.customAnimationFrameRequester.renderFunction || this._boundRenderFunction, this.customAnimationFrameRequester);
+            this._frameHandler = this.customAnimationFrameRequester.requestID;
+        }
+        else {
+            this._frameHandler = this._queueNewFrame(this._boundRenderFunction, this.getHostWindow());
+        }
+    }
     /**
      * Register and execute a render loop. The engine can have more than one render function
      * @param renderFunction defines the function to continuously execute
@@ -467,7 +493,7 @@ export class AbstractEngine {
         this._activeRenderLoops.push(renderFunction);
         // On the first added function, start the render loop.
         if (this._activeRenderLoops.length === 1 && this._frameHandler === 0) {
-            this._frameHandler = this._queueNewFrame(this._boundRenderFunction, this.getHostWindow());
+            this._queueNewFrameForRenderLoop();
         }
     }
     /**
@@ -813,13 +839,13 @@ export class AbstractEngine {
      */
     // Not mixed with Version for tooling purpose.
     static get NpmPackage() {
-        return "babylonjs@9.10.1";
+        return "babylonjs@9.12.0";
     }
     /**
      * Returns the current version of the framework
      */
     static get Version() {
-        return "9.10.1";
+        return "9.12.0";
     }
     /**
      * Gets the HTML canvas attached with the current webGL context
@@ -1042,6 +1068,10 @@ export class AbstractEngine {
         this._frameHandler = 0;
         /** @internal */
         this._activeRenderLoops = new Array();
+        /**
+         * If set, will be used to request the next animation frame for the render loop
+         */
+        this.customAnimationFrameRequester = null;
         /** @internal */
         this._windowIsBackground = false;
         /** @internal */