add adaptive performance module

@types/jsb.d.ts

@@ -64,13 +64,13 @@ declare namespace jsb {
         wheelDeltaX: number,
         wheelDeltaY: number,
     }
-    type  MouseWheelEventCallback = (mouseEvent: MouseWheelEvent) => void;
+    type MouseWheelEventCallback = (mouseEvent: MouseWheelEvent) => void;
     export let onMouseDown: MouseEventCallback | undefined;
     export let onMouseMove: MouseEventCallback | undefined;
     export let onMouseUp: MouseEventCallback | undefined;
     export let onMouseWheel: MouseWheelEventCallback | undefined;
 
-    type TouchEventCallback = (touchList: TouchList, windowId?: number) =>  void;
+    type TouchEventCallback = (touchList: TouchList, windowId?: number) => void;
     export let onTouchStart: TouchEventCallback | undefined;
     export let onTouchMove: TouchEventCallback | undefined;
     export let onTouchEnd: TouchEventCallback | undefined;
@@ -123,7 +123,7 @@ declare namespace jsb {
     }
     type KeyboardEventCallback = (keyboardEvent: KeyboardEvent) => void;
     export let onKeyDown: KeyboardEventCallback | undefined;
-    export let onKeyUp: KeyboardEventCallback| undefined;
+    export let onKeyUp: KeyboardEventCallback | undefined;
 
     export interface WindowEvent {
         windowId: number;
@@ -136,7 +136,7 @@ declare namespace jsb {
      * @zh WindowEvent.width 和 WindowEvent.height 都已乘以 DPR
      */
     export let onResize: (event: WindowEvent) => void | undefined;
-    export let onOrientationChanged: (event: {orientation: number}) => void | undefined;  // TODO: enum orientation type
+    export let onOrientationChanged: (event: { orientation: number }) => void | undefined;  // TODO: enum orientation type
     export let onResume: () => void | undefined;
     export let onPause: () => void | undefined;
     export let onClose: () => void | undefined;
@@ -161,43 +161,43 @@ declare namespace jsb {
         channelCount: number;
     }
     export namespace AudioEngine {
-        export function preload (url: string, cb: (isSuccess: boolean) => void);
-
-        export function play2d (url: string, loop: boolean, volume: number): number;
-        export function pause (id: number);
-        export function pauseAll ();
-        export function resume (id: number);
-        export function resumeAll ();
-        export function stop (id: number);
-        export function stopAll ();
-
-        export function getPlayingAudioCount (): number;
-        export function getMaxAudioInstance (): number;
-        export function getState (id: number): any;
-        export function getDuration (id: number): number;
-        export function getVolume (id: number): number;
-        export function isLoop (id: number): boolean;
-        export function getCurrentTime (id: number): number;
-
-        export function setVolume (id: number, val: number);
-        export function setLoop (id: number, val: boolean);
-        export function setCurrentTime (id: number, val: number);
-
-        export function uncache (url: string);
-        export function uncacheAll ();
-        export function setErrorCallback (id: number, cb: (err: any) => void);
-        export function setFinishCallback (id: number, cb: () => void);
+        export function preload(url: string, cb: (isSuccess: boolean) => void);
+
+        export function play2d(url: string, loop: boolean, volume: number): number;
+        export function pause(id: number);
+        export function pauseAll();
+        export function resume(id: number);
+        export function resumeAll();
+        export function stop(id: number);
+        export function stopAll();
+
+        export function getPlayingAudioCount(): number;
+        export function getMaxAudioInstance(): number;
+        export function getState(id: number): any;
+        export function getDuration(id: number): number;
+        export function getVolume(id: number): number;
+        export function isLoop(id: number): boolean;
+        export function getCurrentTime(id: number): number;
+
+        export function setVolume(id: number, val: number);
+        export function setLoop(id: number, val: boolean);
+        export function setCurrentTime(id: number, val: number);
+
+        export function uncache(url: string);
+        export function uncacheAll();
+        export function setErrorCallback(id: number, cb: (err: any) => void);
+        export function setFinishCallback(id: number, cb: () => void);
 
         /**
          * Get PCM header without pcm data. if you want to get pcm data, use getOriginalPCMBuffer instead
          */
-        export function getPCMHeader (url: string): PCMHeader;
+        export function getPCMHeader(url: string): PCMHeader;
         /**
          * Get PCM Data in decode format for example Int16Array, the format information is written in PCMHeader.
          * @param url: file relative path, for example player._path
          * @param channelID: ChannelID which should smaller than channel count, start from 0
          */
-        export function getOriginalPCMBuffer (url: string, channelID: number): ArrayBuffer | undefined;
+        export function getOriginalPCMBuffer(url: string, channelID: number): ArrayBuffer | undefined;
     }
 
     class NativePOD {
@@ -230,22 +230,22 @@ declare namespace jsb {
     }
 
     export class Manifest {
-        constructor (manifestUrl: string);
-        constructor (content: string, manifestRoot: string);
-        parseFile (manifestUrl: string): void;
-        parseJSONString (content: string, manifestRoot: string): void;
+        constructor(manifestUrl: string);
+        constructor(content: string, manifestRoot: string);
+        parseFile(manifestUrl: string): void;
+        parseJSONString(content: string, manifestRoot: string): void;
 
-        getManifestRoot (): string;
-        getManifestFileUrl (): string;
-        getVersionFileUrl (): string;
-        getSearchPaths (): [string];
-        getVersion (): string;
-        getPackageUrl (): boolean;
+        getManifestRoot(): string;
+        getManifestFileUrl(): string;
+        getVersionFileUrl(): string;
+        getSearchPaths(): [string];
+        getVersion(): string;
+        getPackageUrl(): boolean;
 
-        setUpdating (isUpdating: boolean): void;
-        isUpdating (): boolean;
-        isVersionLoaded (): boolean;
-        isLoaded (): boolean;
+        setUpdating(isUpdating: boolean): void;
+        isUpdating(): boolean;
+        isVersionLoaded(): boolean;
+        isLoaded(): boolean;
     }
 
     export class EventAssetsManager {
@@ -262,23 +262,23 @@ declare namespace jsb {
         static UPDATE_FAILED: number;
         static ERROR_DECOMPRESS: number;
 
-        constructor (eventName: string, manager: AssetsManager, eventCode: number,
+        constructor(eventName: string, manager: AssetsManager, eventCode: number,
             assetId?: string, message?: string, curleCode?: number, curlmCode?: number);
-        getAssetsManagerEx (): AssetsManager;
-        isResuming (): boolean;
+        getAssetsManagerEx(): AssetsManager;
+        isResuming(): boolean;
 
-        getDownloadedFiles (): number;
-        getDownloadedBytes (): number;
-        getTotalFiles (): number;
-        getTotalBytes (): number;
-        getPercent (): number;
-        getPercentByFile (): number;
+        getDownloadedFiles(): number;
+        getDownloadedBytes(): number;
+        getTotalFiles(): number;
+        getTotalBytes(): number;
+        getPercent(): number;
+        getPercentByFile(): number;
 
-        getEventCode (): number;
-        getMessage (): string;
-        getAssetId (): string;
-        getCURLECode (): number;
-        getCURLMCode (): number;
+        getEventCode(): number;
+        getMessage(): string;
+        getAssetId(): string;
+        getCURLECode(): number;
+        getCURLMCode(): number;
     }
 
     export namespace AssetsManager {
@@ -301,44 +301,55 @@ declare namespace jsb {
     }
 
     export class AssetsManager {
-        constructor (manifestUrl: string, storagePath: string, versionCompareHandle?: (versionA: string, versionB: string) => number);
-        static create (manifestUrl: string, storagePath: string): AssetsManager;
+        constructor(manifestUrl: string, storagePath: string, versionCompareHandle?: (versionA: string, versionB: string) => number);
+        static create(manifestUrl: string, storagePath: string): AssetsManager;
 
-        getState (): AssetsManager.State;
-        getStoragePath (): string
-        getMaxConcurrentTask (): number;
+        getState(): AssetsManager.State;
+        getStoragePath(): string
+        getMaxConcurrentTask(): number;
         // setMaxConcurrentTask (max: number): void;  // actually not supported
 
-        checkUpdate (): void;
-        prepareUpdate (): void;
-        update (): void;
-        isResuming (): boolean;
+        checkUpdate(): void;
+        prepareUpdate(): void;
+        update(): void;
+        isResuming(): boolean;
 
-        getDownloadedFiles (): number;
-        getDownloadedBytes (): number;
-        getTotalFiles (): number;
-        getTotalBytes (): number;
-        downloadFailedAssets (): void;
+        getDownloadedFiles(): number;
+        getDownloadedBytes(): number;
+        getTotalFiles(): number;
+        getTotalBytes(): number;
+        downloadFailedAssets(): void;
 
-        getLocalManifest (): Manifest;
-        loadLocalManifest (manifestUrl: string): boolean;
-        loadLocalManifest (localManifest: Manifest, storagePath: string): boolean;
-        getRemoteManifest (): Manifest;
-        loadRemoteManifest (remoteManifest: Manifest): boolean;
+        getLocalManifest(): Manifest;
+        loadLocalManifest(manifestUrl: string): boolean;
+        loadLocalManifest(localManifest: Manifest, storagePath: string): boolean;
+        getRemoteManifest(): Manifest;
+        loadRemoteManifest(remoteManifest: Manifest): boolean;
 
         /**
          * Setup your own version compare handler, versionA and B is versions in string.
          * if the return value greater than 0, versionA is greater than B,
          * if the return value equals 0, versionA equals to B,
          * if the return value smaller than 0, versionA is smaller than B.
          */
-        setVersionCompareHandle (versionCompareHandle?: (versionA: string, versionB: string) => number): void;
+        setVersionCompareHandle(versionCompareHandle?: (versionA: string, versionB: string) => number): void;
         /**
          * Setup the verification callback, Return true if the verification passed, otherwise return false
          */
-        setVerifyCallback (verifyCallback: (path: string, asset: ManifestAsset) => boolean): void;
-        setEventCallback (eventCallback: (event: EventAssetsManager) => void): void;
+        setVerifyCallback(verifyCallback: (path: string, asset: ManifestAsset) => boolean): void;
+        setEventCallback(eventCallback: (event: EventAssetsManager) => void): void;
     }
+
+    function sendUDP(host: string, port: number, data: string);
+    function listenUDP(port: number): number;
+    function unlistenUDP(port: number): boolean;
+    function recvUDP(fd: number): { port: number, ip: string, data: ArrayBuffer }[];
+
+    const thermalInfo: {
+        thermalValue(): number;
+        thermalStatus(): number;
+        frameTime(): number;
+    } | undefined;
 }
 
 declare namespace ns {

cc.config.json

@@ -111,6 +111,12 @@
             "modules": ["profiler"],
             "dependentAssets": ["871c3b6c-7379-419d-bda3-794b239ab90d"]
         },
+        "adaptive-performance":{
+            "modules": ["adaptive-performance"],
+            "intrinsicFlags": {
+                "ADAPTIVE_PERFORMANCE": true
+            }
+        },
         "occlusion-query": {
             "modules": [],
             "dependentAssets": ["d9937e59-61fe-4ec6-92ab-7ac5a19c89b0"]
@@ -363,6 +369,13 @@
                 "cocos/animation/marionette/runtime-exports.ts": "cocos/animation/marionette/index-empty.ts"
             }
         },
+        {
+            "test": "!context.buildTimeConstants.ADAPTIVE_PERFORMANCE",
+            "isVirtualModule": false,
+            "overrides": {
+                "cocos/adaptive-performance": "cocos/adaptive-performance/index-empty.ts"
+            }
+        },
         {
             "test": "!context.buildTimeConstants.PROCEDURAL_ANIMATION",
             "isVirtualModule": false,

cocos/adaptive-performance/decorator.ts

@@ -0,0 +1,14 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+
+import { PriorityLevel } from './enums';
+import type { Scaler } from './scaler';
+import { registerScalerType } from './indexer';
+
+export function scaler<T extends Scaler> (name: string, priority: number | PriorityLevel = PriorityLevel.LOW) {
+    return function whatEver (ctor: { new(...args: any[]): T }): any {
+        (ctor as any)._scalerName = name;
+        (ctor as any)._priority = name;
+        registerScalerType(name, priority, ctor as any);
+        return ctor;
+    };
+}

cocos/adaptive-performance/dev/index.ts

@@ -0,0 +1,2 @@
+// export * from './node-generator';
+export * from './jsb-generator';

cocos/adaptive-performance/dev/jsb-generator.ts

@@ -0,0 +1,26 @@
+import { ThermalLevel } from '../enums';
+import { profiler } from '../profiler';
+
+export function generateSinLevels (): number {
+    const info = jsb.thermalInfo;
+    if (!info) return ThermalLevel.NoWarning;
+    const s = info.thermalStatus();
+    if (s > 0.8) {
+        return ThermalLevel.Critical;
+    }
+    if (s > 0.5) {
+        return ThermalLevel.WarningLevel2;
+    }
+    if (s > 0.3) {
+        return ThermalLevel.WarningLevel1;
+    }
+    return ThermalLevel.NoWarning;
+}
+
+export function generateFrameTime (): { frameTime: number, cpuTime: number, gpuTime: number, thermalValue: number } {
+    const frameTime = profiler.frameTime / 1000; // seconds
+    const gpuTime = profiler.gpuTime  / 1000; // seconds
+    const cpuTime = profiler.cpuTime  / 1000; //seconds
+    const thermalValue = jsb.thermalInfo?.thermalValue();
+    return { frameTime, gpuTime, cpuTime, thermalValue: thermalValue! };
+}

cocos/adaptive-performance/dev/node-generator.ts

@@ -0,0 +1,35 @@
+
+import { PassThrough } from 'stream';
+import { ThermalLevel } from '../enums';
+
+const startTime = (new Date).getTime();
+
+function getPastTime() {
+    const nowTime = (new Date).getTime();
+    const past = (nowTime - startTime) / 1000;
+    return past;
+}
+
+export function generateSinLevels() {
+    const s = Math.sin(getPastTime()/5) / 2 + 0.5;
+    if (s > 0.8) {
+        return ThermalLevel.Critical;
+    }
+    if (s > 0.5) {
+        return ThermalLevel.WarningLevel2;
+    }
+    if (s > 0.3) {
+        return ThermalLevel.WarningLevel1;
+    }
+    return ThermalLevel.NoWarning;
+}
+
+export function generateFramTime(): {frameTime:number, cpuTime:number, gpuTime:number} {        
+    const fx = (x:number) => Math.cos(x / 10) * 30 + 32;
+    const tx = (x:number) => (Math.sin(x * 3.3)/2 + 0.5) * 0.9 + 0.1;
+    const pastTime = getPastTime();
+    const frameTime = fx(pastTime);
+    const cpuTime = frameTime * tx(pastTime);
+    const gpuTime = frameTime - cpuTime;
+    return {frameTime, gpuTime, cpuTime};
+}

cocos/adaptive-performance/enums.ts

@@ -0,0 +1,19 @@
+export enum  PriorityLevel{
+    HIGH = 1,
+    MIDDLE =5,
+    LOW = 10,
+}
+
+export enum ThermalLevel {
+    NoWarning,
+    WarningLevel1,
+    WarningLevel2,
+    Critical
+}
+
+export enum BottleneckType {
+    NONE = 0,
+    CPU = 1,
+    GPU = 2,
+    ALL = GPU | CPU,
+}

cocos/adaptive-performance/index-empty.ts

@@ -0,0 +1,4 @@
+export {Scaler} from './scaler';
+
+export function scaler(name: string, priority: number )  {
+}

cocos/adaptive-performance/index.ts

@@ -0,0 +1,5 @@
+export * from './decorator';
+export * from './enums';
+export * from './scaler';
+export { PerformanceManager } from './performance-manager';
+export * as embededScalers from './scalers';