idioms/idiom/assets/core/util/ResUtil.ts

/**
 *
 * @file ResUtil.ts
 * @author
 * @description Cocos方法整合，如果Cocos版本升级，造成API修改，仅需修改此处
 */
import { Asset, assetManager, AssetManager, director, ImageAsset, resources, SceneAsset, Texture2D } from "cc";
//export type Constructor<T extends Asset> = new () => T;
export const headImgExt = ".head";
export module ResUtil {
    /**
    * @description 原生加载资源
    * @param object {url: 远程地址 option: 参数类型}
    * @returns 
    */
    export function loadRemote<T extends Asset>(url:string, option?: any):Promise<T>{
        return new Promise((resolve, reject) => {
            assetManager.loadRemote<T>(url, option, (err: Error | null, asset: T) => {
                resolve && resolve(err ? null : asset);
            });
        });
    }
    /**
     * 加载bundle
     * @param bundleName 
     * @returns 
     */
    export function loadBundle(bundleName: string):Promise<AssetManager.Bundle> {
        return new Promise((resolve, reject) => {
            assetManager.loadBundle(bundleName, (err, bundle) => {
                resolve && resolve(err ? null : bundle);
            });
        });
    }
    /**获取已加载的bundle*/
    export function getBundle(bundleName?: string):AssetManager.Bundle|null{
        if (null == bundleName || '' === bundleName) {
            return resources;
        } else {
            return assetManager.getBundle(bundleName)!;
        }
    }
    /**
     * 加载资源
     * @param  path  资源名
     * @param  bundle 所属包名或 包
     * @type 资源类型
     * @returns 
    */
    export async function loadAsset<T extends Asset>(path: string, bundle?: string | AssetManager.Bundle):Promise<T>{
        let bd:AssetManager.Bundle;
        if(!bundle) bundle='';
        if(typeof bundle === 'string'){
           bd = getBundle(bundle);
           if(!bd) bd = await loadBundle(bundle);
        } else if (bundle instanceof AssetManager.Bundle) {  
           bd = bundle;
        }
        const asset = bd.get<T>(path);
        if (null != asset) {
            return Promise.resolve(asset);
        }
        return new Promise((resolve, reject) => {
            bd.load<T>(path,(err, asset: T) => {
                resolve(err ? null : asset);
            });
        });
    }
    export async function loadDir<T extends Asset>(path: string, bundle?: string | AssetManager.Bundle,progressCallback?: (completed: number, total: number) => void):Promise<T[]>{
        let bd:AssetManager.Bundle;
        if(!bundle) bundle='';
        if(typeof bundle === 'string'){
           bd = getBundle(bundle);
           if(!bd) bd = await loadBundle(bundle);
        } else if (bundle instanceof AssetManager.Bundle) {  
           bd = bundle;
        }
        return new Promise((resolve, reject) => {
            bd.loadDir<T>(path,(finished:number,total:number,item)=>{
                progressCallback?.(finished,total);
            }, (err, assets:T[]) => {    
                resolve(err ? null : assets);
            });
        });
    }
    export async function loadAssets<T extends Asset>(list: string[], bundle?: string | AssetManager.Bundle,progressCallback?: (completed: number, total: number) => void):Promise<T[]>{
        let bd:AssetManager.Bundle;
        if(!bundle) bundle='';
        if(typeof bundle === 'string'){
           bd = getBundle(bundle);
           if(!bd) bd = await loadBundle(bundle);
        } else if (bundle instanceof AssetManager.Bundle) {  
           bd = bundle;
        }
        return new Promise((resolve, reject) => {
            bd.load<T>(list,(finished: number, total: number, item:any) => {
                progressCallback?.(finished,total);
            }, (err: Error | null, data) => {
                resolve(err ? null : data);
            });
        });
    }

    export async function loadScene(scene_name:string, bundle?: string | AssetManager.Bundle,show:Boolean=false):Promise<SceneAsset>{
        let bd:AssetManager.Bundle;
        if(!bundle) bundle='';
        if(typeof bundle === 'string'){
           bd = getBundle(bundle);
           if(!bd) bd = await loadBundle(bundle);
        } else if (bundle instanceof AssetManager.Bundle) {  
           bd = bundle;
        }
        return new Promise((resolve, reject) => {
            bd.loadScene(scene_name, (err, asset:SceneAsset) => {    
                resolve(err ? null : asset);
                if(show)director.loadScene(scene_name);
            });
        });
    }
    export function releaseAll():void{
        assetManager.releaseAll();
    }
    export function releaseAsset(asset:Asset){
        assetManager.releaseAsset(asset);
    }
    export function release(path:string|null,bundle?: string | AssetManager.Bundle){
        let bd:AssetManager.Bundle;
        if(!bundle) bundle='';
        if(typeof bundle === 'string'){
           bd = getBundle(bundle);
        } else if (bundle instanceof AssetManager.Bundle) {  
           bd = bundle;
        }
        if(path && path!=''){
            bd?.release(path); 
        }else{
            bd?.releaseAll();
        }
    }
    /**
    * 自定义头像加载流程
    * 加载头像使用 ResUtil.loadRemote({url, option:{ext:headImgExt}})
    */
    export function registerHeadImgLoader() {
        assetManager.downloader.register(headImgExt, (content, options, onComplete) => {
            onComplete(null, content);
        });
        assetManager.parser.register(headImgExt, downloadDomImage);
        assetManager.factory.register(headImgExt, createTexture);
    }
    function createTexture(id: string, data: any, options: any, onComplete: Function) {
        let out: Texture2D | null = null;
        let err: Error | null = null;
        try {
            out = new Texture2D();
            const imageAsset = new ImageAsset(data);
            out.image = imageAsset;
        } catch (e) {
            err = e as any as Error;
        }
        onComplete && onComplete(err, out);
    }

    function downloadDomImage(url: string, options: any, onComplete: Function) {
        const img = new Image();
        if (window.location.protocol !== 'file:') {
            img.crossOrigin = 'anonymous';
        }
        function loadCallback() {
            img.removeEventListener('load', loadCallback);
            img.removeEventListener('error', errorCallback);
            if (onComplete) {
                onComplete(null, img);
            }
        }

        function errorCallback() {
            img.removeEventListener('load', loadCallback);
            img.removeEventListener('error', errorCallback);
            if (onComplete) {
                onComplete(new Error(url));
            }
        }

        img.addEventListener('load', loadCallback);
        img.addEventListener('error', errorCallback);
        img.src = url;
        return img;
    }
}