Hook up Tools.PerformanceLogLevel / Tools.StartPerformanceCounter / Tools.EndPerformanceCounter to Babylon Native counterparts (#17450)

NativeTracing has been partially implemented in Babylon Native for a
long time. These changes hook up the Babylon.js perf tracing related
APIs in Tools to the Babylon Native tracing APIs. This extra
functionality will only execute in the context of Babylon Native, and is
resilient to older versions of Babylon Native. For these changes to
fully work, they need
BabylonJS/BabylonNative#1569.

Couple additional changes related to our native interfaces:
- I did a little bit of cleanup on the `INative` interface to make it
more type safe
- ~I added a declation for the `_native` global in
`INativeInterfaces.ts`, which makes it visible globally everywhere so it
doesn't have to be redeclared in every file it is used in. However, I
declared it as potentially undefined (since it is), so I didn't touch a
few files that already declared it as non nullable (like NativeEngine)
as there would be a ton of changes and I didn't want this PR to get too
overloaded.~ Never mind, not in the mood to battle the custom umd type
declaration generation script today.

Author: ryantrem

packages/dev/core/src/Engines/Native/nativeInterfaces.ts

@@ -414,14 +414,35 @@ interface INativeDataStreamConstructor {
     readonly VALIDATION_BOOLEAN: number;
 }
 
+// Note: These values need to match those in Babylon Native's NativeTracing plugin.
+export const enum NativeTraceLevel {
+    Mark = 1,
+    Log = 2,
+}
+
 /** @internal */
 export interface INative {
+    // NativeEngine plugin
     Engine: INativeEngineConstructor;
-    Camera: INativeCameraConstructor;
-    Canvas: INativeCanvasConstructor;
-    Image: INativeImageConstructor;
-    Path2D: INativePath2DConstructor;
-    XMLHttpRequest: any; // TODO: how to do this?
-    DeviceInputSystem: IDeviceInputSystemConstructor;
     NativeDataStream: INativeDataStreamConstructor;
+
+    // NativeCamera plugin
+    Camera?: INativeCameraConstructor;
+
+    // NativeCanvas plugin
+    Canvas?: INativeCanvasConstructor;
+    Image?: INativeImageConstructor;
+    Path2D?: INativePath2DConstructor;
+
+    // Native XMLHttpRequest polyfill
+    XMLHttpRequest?: typeof XMLHttpRequest;
+
+    // NativeInput plugin
+    DeviceInputSystem?: IDeviceInputSystemConstructor;
+
+    // NativeTracing plugin
+    enablePerformanceLogging?(level?: NativeTraceLevel): void;
+    disablePerformanceLogging?(): void;
+    startPerformanceCounter?(counter: string): unknown;
+    endPerformanceCounter?(counter: unknown): void;
 }

packages/dev/core/src/Engines/nativeEngine.ts

@@ -2615,7 +2615,7 @@ export class NativeEngine extends Engine {
      * @returns IImage interface
      */
     public override createCanvasImage(): IImage {
-        if (!_native.Canvas) {
+        if (!_native.Image) {
             throw new Error("Native Canvas plugin not available.");
         }
         const image = new _native.Image();
@@ -2628,7 +2628,7 @@ export class NativeEngine extends Engine {
      * @param d SVG path string
      */
     public override createCanvasPath2D(d?: string): IPath2D {
-        if (!_native.Canvas) {
+        if (!_native.Path2D) {
             throw new Error("Native Canvas plugin not available.");
         }
         const path2d = new _native.Path2D(d);

packages/dev/core/src/Misc/fileTools.ts

@@ -14,12 +14,10 @@ import { _FunctionContainer } from "../Engines/Processors/shaderProcessor";
 import { EngineStore } from "../Engines/engineStore";
 import { Logger } from "./logger";
 import { TimingTools } from "./timingTools";
-import type { INative } from "../Engines/Native/nativeInterfaces";
 import { EngineFunctionContext } from "core/Engines/abstractEngine.functions";
 import { AbstractEngine } from "../Engines/abstractEngine";
 
 const Base64DataUrlRegEx = new RegExp(/^data:([^,]+\/[^,]+)?;base64,/i);
-declare const _native: INative;
 
 /** @ignore */
 export class LoadFileError extends RuntimeError {

packages/dev/core/src/Misc/tools.ts

@@ -29,6 +29,11 @@ import type { IColor4Like } from "../Maths/math.like";
 import { IsExponentOfTwo, Mix } from "./tools.functions";
 import type { AbstractEngine } from "../Engines/abstractEngine";
 import type { RenderTargetTexture } from "core/Materials/Textures/renderTargetTexture";
+import type { INative } from "../Engines/Native/nativeInterfaces";
+import { NativeTraceLevel } from "../Engines/Native/nativeInterfaces";
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+declare const _native: INative;
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
 declare function importScripts(...urls: string[]): void;
@@ -1328,24 +1333,39 @@ export class Tools {
 
     private static _Performance: Performance;
 
+    private static readonly _NativePerformanceCounterHandles = new Map<string, unknown>();
+
     /**
      * Sets the current performance log level
      */
     public static set PerformanceLogLevel(level: number) {
         if ((level & Tools.PerformanceUserMarkLogLevel) === Tools.PerformanceUserMarkLogLevel) {
-            Tools.StartPerformanceCounter = Tools._StartUserMark;
-            Tools.EndPerformanceCounter = Tools._EndUserMark;
+            if (_native?.enablePerformanceLogging) {
+                _native.enablePerformanceLogging(NativeTraceLevel.Mark);
+                Tools.StartPerformanceCounter = Tools._StartMarkNative;
+                Tools.EndPerformanceCounter = Tools._EndMarkNative;
+            } else {
+                Tools.StartPerformanceCounter = Tools._StartUserMark;
+                Tools.EndPerformanceCounter = Tools._EndUserMark;
+            }
             return;
         }
 
         if ((level & Tools.PerformanceConsoleLogLevel) === Tools.PerformanceConsoleLogLevel) {
-            Tools.StartPerformanceCounter = Tools._StartPerformanceConsole;
-            Tools.EndPerformanceCounter = Tools._EndPerformanceConsole;
+            if (_native?.enablePerformanceLogging) {
+                _native.enablePerformanceLogging(NativeTraceLevel.Log);
+                Tools.StartPerformanceCounter = Tools._StartMarkNative;
+                Tools.EndPerformanceCounter = Tools._EndMarkNative;
+            } else {
+                Tools.StartPerformanceCounter = Tools._StartPerformanceConsole;
+                Tools.EndPerformanceCounter = Tools._EndPerformanceConsole;
+            }
             return;
         }
 
         Tools.StartPerformanceCounter = Tools._StartPerformanceCounterDisabled;
         Tools.EndPerformanceCounter = Tools._EndPerformanceCounterDisabled;
+        _native?.disablePerformanceLogging?.();
     }
 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -1398,6 +1418,29 @@ export class Tools {
         console.timeEnd(counterName);
     }
 
+    private static _StartMarkNative(counterName: string, condition = true): void {
+        if (condition && _native?.startPerformanceCounter) {
+            if (Tools._NativePerformanceCounterHandles.has(counterName)) {
+                Tools.Warn(`Performance counter with name ${counterName} is already started.`);
+            } else {
+                const handle = _native.startPerformanceCounter(counterName);
+                Tools._NativePerformanceCounterHandles.set(counterName, handle);
+            }
+        }
+    }
+
+    private static _EndMarkNative(counterName: string, condition = true): void {
+        if (condition && _native?.endPerformanceCounter) {
+            const handle = Tools._NativePerformanceCounterHandles.get(counterName);
+            if (handle) {
+                _native.endPerformanceCounter(handle);
+                Tools._NativePerformanceCounterHandles.delete(counterName);
+            } else {
+                Tools.Warn(`Performance counter with name ${counterName} was not started.`);
+            }
+        }
+    }
+
     /**
      * Starts a performance counter
      */