System.register(["cc"], function (_export, _context) {
  "use strict";

  var _cclegacy, __checkObsolete__, __checkObsoleteInNamespace__, assetManager, AssetManager, director, ImageAsset, resources, Texture2D, _crd, headImgExt, ResUtil;

  _export("ResUtil", void 0);

  return {
    setters: [function (_cc) {
      _cclegacy = _cc.cclegacy;
      __checkObsolete__ = _cc.__checkObsolete__;
      __checkObsoleteInNamespace__ = _cc.__checkObsoleteInNamespace__;
      assetManager = _cc.assetManager;
      AssetManager = _cc.AssetManager;
      director = _cc.director;
      ImageAsset = _cc.ImageAsset;
      resources = _cc.resources;
      Texture2D = _cc.Texture2D;
    }],
    execute: function () {
      _crd = true;

      _cclegacy._RF.push({}, "fdca4buPvxCtqd20MSvpC7T", "ResUtil", undefined);
      /**
       *
       * @file ResUtil.ts
       * @author
       * @description Cocos方法整合，如果Cocos版本升级，造成API修改，仅需修改此处
       */


      //export type Constructor<T extends Asset> = new () => T;
      __checkObsolete__(['Asset', 'assetManager', 'AssetManager', 'director', 'ImageAsset', 'resources', 'SceneAsset', 'Texture2D']);

      _export("headImgExt", headImgExt = ".head");

      (function (_ResUtil) {
        function loadRemote(url, option) {
          return new Promise((resolve, reject) => {
            assetManager.loadRemote(url, option, (err, asset) => {
              resolve && resolve(err ? null : asset);
            });
          });
        }

        _ResUtil.loadRemote = loadRemote;

        function loadBundle(bundleName) {
          return new Promise((resolve, reject) => {
            assetManager.loadBundle(bundleName, (err, bundle) => {
              resolve && resolve(err ? null : bundle);
            });
          });
        }

        _ResUtil.loadBundle = loadBundle;

        function getBundle(bundleName) {
          if (null == bundleName || '' === bundleName) {
            return resources;
          } else {
            return assetManager.getBundle(bundleName);
          }
        }

        _ResUtil.getBundle = getBundle;

        async function loadAsset(path, bundle) {
          let bd;
          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(path);

          if (null != asset) {
            return Promise.resolve(asset);
          }

          return new Promise((resolve, reject) => {
            bd.load(path, (err, asset) => {
              resolve(err ? null : asset);
            });
          });
        }

        _ResUtil.loadAsset = loadAsset;

        async function loadDir(path, bundle, progressCallback) {
          let bd;
          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(path, (finished, total, item) => {
              progressCallback == null || progressCallback(finished, total);
            }, (err, assets) => {
              resolve(err ? null : assets);
            });
          });
        }

        _ResUtil.loadDir = loadDir;

        async function loadAssets(list, bundle, progressCallback) {
          let bd;
          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(list, (finished, total, item) => {
              progressCallback == null || progressCallback(finished, total);
            }, (err, data) => {
              resolve(err ? null : data);
            });
          });
        }

        _ResUtil.loadAssets = loadAssets;

        async function loadScene(scene_name, bundle, show = false) {
          let bd;
          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) => {
              resolve(err ? null : asset);
              if (show) director.loadScene(scene_name);
            });
          });
        }

        _ResUtil.loadScene = loadScene;

        function releaseAll() {
          assetManager.releaseAll();
        }

        _ResUtil.releaseAll = releaseAll;

        function releaseAsset(asset) {
          assetManager.releaseAsset(asset);
        }

        _ResUtil.releaseAsset = releaseAsset;

        function release(path, bundle) {
          let bd;
          if (!bundle) bundle = '';

          if (typeof bundle === 'string') {
            bd = getBundle(bundle);
          } else if (bundle instanceof AssetManager.Bundle) {
            bd = bundle;
          }

          if (path && path != '') {
            var _bd;

            (_bd = bd) == null || _bd.release(path);
          } else {
            var _bd2;

            (_bd2 = bd) == null || _bd2.releaseAll();
          }
        }

        _ResUtil.release = release;

        function registerHeadImgLoader() {
          assetManager.downloader.register(headImgExt, (content, options, onComplete) => {
            onComplete(null, content);
          });
          assetManager.parser.register(headImgExt, downloadDomImage);
          assetManager.factory.register(headImgExt, createTexture);
        }

        _ResUtil.registerHeadImgLoader = registerHeadImgLoader;

        function createTexture(id, data, options, onComplete) {
          let out = null;
          let err = null;

          try {
            out = new Texture2D();
            const imageAsset = new ImageAsset(data);
            out.image = imageAsset;
          } catch (e) {
            err = e;
          }

          onComplete && onComplete(err, out);
        }

        function downloadDomImage(url, options, onComplete) {
          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;
        }
      })(ResUtil || _export("ResUtil", ResUtil = {}));

      _cclegacy._RF.pop();

      _crd = false;
    }
  };
});
//# sourceMappingURL=c969313d23703c6a3fcc53d5e71bae664ed7849e.js.map