{
  "ver": "1.2.7",
  "uuid": "a8accd2e-6622-4c31-8a1e-4db5f2b568b5",
  "optimizationPolicy": "AUTO",     // prefab創建優化策略
  "asyncLoadAssets": false,         // 是否延遲加載
  "readonly": false,
  "subMetas": {}
}

{
  "9836134e-b892-4283-b6b2-78b5acf3ed45": {
    "asset": 1594351233259,
    "meta": 1594351616611,
    "relativePath": "effects"
  },
  "430eccbf-bf2c-4e6e-8c0c-884bbb487f32": {
    "asset": 1594351233254,
    "meta": 1594351616643,
    "relativePath": "effects\__builtin-editor-gizmo-line.effect"
  },
  ...
}

{
  "__type__": "cc.Texture2D",
  "content": "0,9729,9729,33071,33071,0,0,1"
}

cc.resources.load("test assets/prefab", function (err, prefab) {
    var newNode = cc.instantiate(prefab);
    cc.director.getScene().addChild(newNode);
});

cc.assetManager.loadBundle("01_graphics", (err, bundle) => {
    bundle.load("xxx");
});

// 當復用其他項目的 Asset Bundle 時
cc.assetManager.loadBundle("https://othergame.com/remote/01_graphics", (err, bundle) => {
    bundle.load("xxx");
});

// 原生平臺
cc.assetManager.loadBundle(jsb.fileUtils.getWritablePath() + "/pathToBundle/bundleName", (err, bundle) => {
    // ...
});

// 微信小游戲平臺
cc.assetManager.loadBundle(wx.env.USER_DATA_PATH + "/pathToBundle/bundleName", (err, bundle) => {
    // ...
});

// 正常加載
this.pipeline = pipeline.append(preprocess).append(load);
// 預加載
this.fetchPipeline = fetchPipeline.append(preprocess).append(fetch);
// 轉換資源路徑
this.transformPipeline = transformPipeline.append(parse).append(combine);

// bundle類的load方法
load (paths, type, onProgress, onComplete) {
  var { type, onProgress, onComplete } = parseLoadResArgs(type, onProgress, onComplete);
  cc.assetManager.loadAny(paths, { __requestType__: RequestType.PATH, type: type, bundle: this.name }, onProgress, onComplete);
},

// assetManager的loadAny方法
loadAny (requests, options, onProgress, onComplete) {
  var { options, onProgress, onComplete } = parseParameters(options, onProgress, onComplete);
  
  options.preset = options.preset || "default";
  let task = new Task({input: requests, onProgress, onComplete: asyncify(onComplete), options});
  pipeline.async(task);
},

let subTask = Task.create({input: task.input, options: subOptions});
task.output = task.source = transformPipeline.sync(subTask);

function parse (task) {
    // 將input轉換成數組
    var input = task.input, options = task.options;
    input = Array.isArray(input) ? input : [ input ];

    task.output = [];
    for (var i = 0; i < input.length; i ++ ) {
        var item = input[i];
        var out = RequestItem.create();
        if (typeof item === "string") {
            // 先創建object
            item = Object.create(null);
            item[options.__requestType__ || RequestType.UUID] = input[i];
        }
        if (typeof item === "object") {
            // local options will overlap glabal options
            // 將options的屬性復制到item身上，addon會復制options上有，而item沒有的屬性
            cc.js.addon(item, options);
            if (item.preset) {
                cc.js.addon(item, cc.assetManager.presets[item.preset]);
            }
            for (var key in item) {
                switch (key) {
                    // uuid類型資源，從bundle中取出該資源的詳細信息
                    case RequestType.UUID: 
                        var uuid = out.uuid = decodeUuid(item.uuid);
                        if (bundles.has(item.bundle)) {
                            var config = bundles.get(item.bundle)._config;
                            var info = config.getAssetInfo(uuid);
                            if (info && info.redirect) {
                                if (!bundles.has(info.redirect)) throw new Error(`Please load bundle ${info.redirect} first`);
                                config = bundles.get(info.redirect)._config;
                                info = config.getAssetInfo(uuid);
                            }
                            out.config = config;
                            out.info = info;
                        }
                        out.ext = item.ext || ".json";
                        break;
                    case "__requestType__":
                    case "ext": 
                    case "bundle":
                    case "preset":
                    case "type": break;
                    case RequestType.DIR: 
                        // 解包后動態添加到input列表尾部，后續的循環會自動parse這些資源
                        if (bundles.has(item.bundle)) {
                            var infos = [];
                            bundles.get(item.bundle)._config.getDirWithPath(item.dir, item.type, infos);
                            for (let i = 0, l = infos.length; i < l; i++) {
                                var info = infos[i];
                                input.push({uuid: info.uuid, __isNative__: false, ext: ".json", bundle: item.bundle});
                            }
                        }
                        out.recycle();
                        out = null;
                        break;
                    case RequestType.PATH: 
                        // PATH類型的資源根據路徑和type取出該資源的詳細信息
                        if (bundles.has(item.bundle)) {
                            var config = bundles.get(item.bundle)._config;
                            var info = config.getInfoWithPath(item.path, item.type);
                            
                            if (info && info.redirect) {
                                if (!bundles.has(info.redirect)) throw new Error(`you need to load bundle ${info.redirect} first`);
                                config = bundles.get(info.redirect)._config;
                                info = config.getAssetInfo(info.uuid);
                            }

                            if (!info) {
                                out.recycle();
                                throw new Error(`Bundle ${item.bundle} doesn"t contain ${item.path}`);
                            }
                            out.config = config; 
                            out.uuid = info.uuid;
                            out.info = info;
                        }
                        out.ext = item.ext || ".json";
                        break;
                    case RequestType.SCENE:
                        // 場景類型，從bundle中的config調用getSceneInfo取出該場景的詳細信息
                        if (bundles.has(item.bundle)) {
                            var config = bundles.get(item.bundle)._config;
                            var info = config.getSceneInfo(item.scene);
                            
                            if (info && info.redirect) {
                                if (!bundles.has(info.redirect)) throw new Error(`you need to load bundle ${info.redirect} first`);
                                config = bundles.get(info.redirect)._config;
                                info = config.getAssetInfo(info.uuid);
                            }
                            if (!info) {
                                out.recycle();
                                throw new Error(`Bundle ${config.name} doesn"t contain scene ${item.scene}`);
                            }
                            out.config = config; 
                            out.uuid = info.uuid;
                            out.info = info;
                        }
                        break;
                    case "__isNative__": 
                        out.isNative = item.__isNative__;
                        break;
                    case RequestType.URL: 
                        out.url = item.url;
                        out.uuid = item.uuid || item.url;
                        out.ext = item.ext || cc.path.extname(item.url);
                        out.isNative = item.__isNative__ !== undefined ? item.__isNative__ : true;
                        break;
                    default: out.options[key] = item[key];
                }
                if (!out) break;
            }
        }
        if (!out) continue;
        task.output.push(out);
        if (!out.uuid && !out.url) throw new Error("unknown input:" + item.toString());
    }
    return null;
}

function combine (task) {
    var input = task.output = task.input;
    for (var i = 0; i < input.length; i++) {
        var item = input[i];
        // 如果item已經包含了url，則跳過，直接使用item的url
        if (item.url) continue;

        var url = "", base = "";
        var config = item.config;
        // 決定目錄的前綴
        if (item.isNative) {
            base = (config && config.nativeBase) ? (config.base + config.nativeBase) : cc.assetManager.generalNativeBase;
        } 
        else {
            base = (config && config.importBase) ? (config.base + config.importBase) : cc.assetManager.generalImportBase;
        }

        let uuid = item.uuid;
            
        var ver = "";
        if (item.info) {
            if (item.isNative) {
                ver = item.info.nativeVer ? ("." + item.info.nativeVer) : "";
            }
            else {
                ver = item.info.ver ? ("." + item.info.ver) : "";
            }
        }

        // 拼接最終的url
        // ugly hack, WeChat does not support loading font likes "myfont.dw213.ttf". So append hash to directory
        if (item.ext === ".ttf") {
            url = `${base}/${uuid.slice(0, 2)}/${uuid}${ver}/${item.options.__nativeName__}`;
        }
        else {
            url = `${base}/${uuid.slice(0, 2)}/${uuid}${ver}${item.ext}`;
        }
        
        item.url = url;
    }
    return null;
}

function load (task, done) {
    if (!task.progress) {
        task.progress = {finish: 0, total: task.input.length};
    }
    
    var options = task.options, progress = task.progress;
    options.__exclude__ = options.__exclude__ || Object.create(null);
    task.output = [];
    forEach(task.input, function (item, cb) {
        // 對每個input項都創建一個子任務，并交由loadOneAssetPipeline執行
        let subTask = Task.create({ 
            input: item, 
            onProgress: task.onProgress, 
            options, 
            progress, 
            onComplete: function (err, item) {
                if (err && !task.isFinish && !cc.assetManager.force) done(err);
                task.output.push(item);
                subTask.recycle();
                cb();
            }
        });
        // 執行子任務，loadOneAssetPipeline有fetch和parse組成
        loadOneAssetPipeline.async(subTask);
    }, function () {
        // 每個input執行完成后，最后執行該函數
        options.__exclude__ = null;
        if (task.isFinish) {
            clear(task, true);
            return task.dispatch("error");
        }
        gatherAsset(task);
        clear(task, true);
        done();
    });
}

var loadOneAssetPipeline = new Pipeline("loadOneAsset", [
    function fetch (task, done) {
        var item = task.output = task.input;
        var { options, isNative, uuid, file } = item;
        var { reload } = options;
        // 如果assets里面已經加載了這個資源，則直接完成
        if (file || (!reload && !isNative && assets.has(uuid))) return done();
        // 下載文件，這是一個異步的過程，文件下載完會被放到item.file中，并執行done驅動管線
        packManager.load(item, task.options, function (err, data) {
            if (err) {
                if (cc.assetManager.force) {
                    err = null;
                } else {
                    cc.error(err.message, err.stack);
                }
                data = null;
            }
            item.file = data;
            done(err);
        });
    },
    // 將資源文件轉換成資源對象的過程
    function parse (task, done) {
        var item = task.output = task.input, progress = task.progress, exclude = task.options.__exclude__;
        var { id, file, options } = item;

        if (item.isNative) {
            // 對于原生資源，調用parser.parse進行處理，將處理完的資源放到item.content中，并結束流程
            parser.parse(id, file, item.ext, options, function (err, asset) {
                if (err) {
                    if (!cc.assetManager.force) {
                        cc.error(err.message, err.stack);
                        return done(err);
                    }
                }
                item.content = asset;
                task.dispatch("progress", ++progress.finish, progress.total, item);
                files.remove(id);
                parsed.remove(id);
                done();
            });
        } else {
            var { uuid } = item;
            // 非原生資源，如果在task.options.__exclude__中，直接結束
            if (uuid in exclude) {
                var { finish, content, err, callbacks } = exclude[uuid];
                task.dispatch("progress", ++progress.finish, progress.total, item);
    
                if (finish || checkCircleReference(uuid, uuid, exclude) ) {
                    content && content.addRef();
                    item.content = content;
                    done(err);
                } else {
                    callbacks.push({ done, item });
                }
            } else {
                // 如果不是reload，且asset中包含了該uuid
                if (!options.reload && assets.has(uuid)) {
                    var asset = assets.get(uuid);
                    // 開啟了options.__asyncLoadAssets__，或asset.__asyncLoadAssets__為false，直接結束，不加載依賴
                    if (options.__asyncLoadAssets__ || !asset.__asyncLoadAssets__) {
                        item.content = asset.addRef();
                        task.dispatch("progress", ++progress.finish, progress.total, item);
                        done();
                    }
                    else {
                        loadDepends(task, asset, done, false);
                    }
                } else {
                    // 如果是reload，或者assets中沒有，則進行解析，并加載依賴
                    parser.parse(id, file, "import", options, function (err, asset) {
                        if (err) {
                            if (cc.assetManager.force) {
                                err = null;
                            }
                            else {
                                cc.error(err.message, err.stack);
                            }
                            return done(err);
                        }
                        
                        asset._uuid = uuid;
                        loadDepends(task, asset, done, true);
                    });
                }
            }
        }
    }
]);

// packManager.load的實現
load (item, options, onComplete) {
  // 如果資源沒有被打包，則直接調用downloader.download下載（download內部也有已下載和加載中的判斷）
  if (item.isNative || !item.info || !item.info.packs) return downloader.download(item.id, item.url, item.ext, item.options, onComplete);
  // 如果文件已經下載過了，則直接返回
  if (files.has(item.id)) return onComplete(null, files.get(item.id));

  var packs = item.info.packs;
  // 如果pack已經在加載中，則將回調添加到_loading隊列，等加載完成后觸發回調
  var pack = packs.find(isLoading);
  if (pack) return _loading.get(pack.uuid).push({ onComplete, id: item.id });

  // 下載一個新的pack
  pack = packs[0];
  _loading.add(pack.uuid, [{ onComplete, id: item.id }]);
  let url = cc.assetManager._transform(pack.uuid, {ext: pack.ext, bundle: item.config.name});
  // 下載pack并解包，
  downloader.download(pack.uuid, url, pack.ext, item.options, function (err, data) {
      files.remove(pack.uuid);
      if (err) {
          cc.error(err.message, err.stack);
      }
      // unpack package，內部實現包含2種解包，一種針對prefab、圖集等json數組的分割解包，另一種針對Texture2D的content進行解包
      packManager.unpack(pack.packs, data, pack.ext, item.options, function (err, result) {
          if (!err) {
              for (var id in result) {
                  files.add(id, result[id]);
              }
          }
          var callbacks = _loading.remove(pack.uuid);
          for (var i = 0, l = callbacks.length; i < l; i++) {
              var cb = callbacks[i];
              if (err) {
                  cb.onComplete(err);
                  continue;
              }

              var data = result[cb.id];
              if (!data) {
                  cb.onComplete(new Error("can not retrieve data from package"));
              }
              else {
                  cb.onComplete(null, data);
              }
          }
      });
  });
}

download (id, url, type, options, onComplete) {
  // 取出downloaders中對應類型的下載回調
  let func = downloaders[type] || downloaders["default"];
  let self = this;
  // 避免重復下載
  let file, downloadCallbacks;
  if (file = files.get(id)) {
      onComplete(null, file);
  }
  // 如果在下載中，添加到隊列
  else if (downloadCallbacks = _downloading.get(id)) {
      downloadCallbacks.push(onComplete);
      for (let i = 0, l = _queue.length; i < l; i++) {
          var item = _queue[i];
          if (item.id === id) {
              var priority = options.priority || 0;
              if (item.priority < priority) {
                  item.priority = priority;
                  _queueDirty = true;
              } 
              return;
          }
      } 
  }
  else {
      // 進行下載，并設置好下載失敗的重試
      var maxRetryCount = options.maxRetryCount || this.maxRetryCount;
      var maxConcurrency = options.maxConcurrency || this.maxConcurrency;
      var maxRequestsPerFrame = options.maxRequestsPerFrame || this.maxRequestsPerFrame;

      function process (index, callback) {
          if (index === 0) {
              _downloading.add(id, [onComplete]);
          }
          if (!self.limited) return func(urlAppendTimestamp(url), options, callback);
          updateTime();

          function invoke () {
              func(urlAppendTimestamp(url), options, function () {
                  // when finish downloading, update _totalNum
                  _totalNum--;
                  if (!_checkNextPeriod && _queue.length > 0) {
                      callInNextTick(handleQueue, maxConcurrency, maxRequestsPerFrame);
                      _checkNextPeriod = true;
                  }
                  callback.apply(this, arguments);
              });
          }

          if (_totalNum < maxConcurrency && _totalNumThisPeriod < maxRequestsPerFrame) {
              invoke();
              _totalNum++;
              _totalNumThisPeriod++;
          }
          else {
              // when number of request up to limitation, cache the rest
              _queue.push({ id, priority: options.priority || 0, invoke });
              _queueDirty = true;

              if (!_checkNextPeriod && _totalNum < maxConcurrency) {
                  callInNextTick(handleQueue, maxConcurrency, maxRequestsPerFrame);
                  _checkNextPeriod = true;
              }
          }
      }

      // retry完成后，將文件添加到files緩存中，從_downloading隊列中移除，并執行callbacks回調
      // when retry finished, invoke callbacks
      function finale (err, result) {
          if (!err) files.add(id, result);
          var callbacks = _downloading.remove(id);
          for (let i = 0, l = callbacks.length; i < l; i++) {
              callbacks[i](err, result);
          }
      }

      retry(process, maxRetryCount, this.retryInterval, finale);
  }
}

function downloadFile (url, options, onProgress, onComplete) {
    var { options, onProgress, onComplete } = parseParameters(options, onProgress, onComplete);
    var xhr = new XMLHttpRequest(), errInfo = "download failed: " + url + ", status: ";
    xhr.open("GET", url, true);
    
    if (options.responseType !== undefined) xhr.responseType = options.responseType;
    if (options.withCredentials !== undefined) xhr.withCredentials = options.withCredentials;
    if (options.mimeType !== undefined && xhr.overrideMimeType ) xhr.overrideMimeType(options.mimeType);
    if (options.timeout !== undefined) xhr.timeout = options.timeout;

    if (options.header) {
        for (var header in options.header) {
            xhr.setRequestHeader(header, options.header[header]);
        }
    }

    xhr.onload = function () {
        if ( xhr.status === 200 || xhr.status === 0 ) {
            onComplete && onComplete(null, xhr.response);
        } else {
            onComplete && onComplete(new Error(errInfo + xhr.status + "(no response)"));
        }

    };

    if (onProgress) {
        xhr.onprogress = function (e) {
            if (e.lengthComputable) {
                onProgress(e.loaded, e.total);
            }
        };
    }

    xhr.onerror = function(){
        onComplete && onComplete(new Error(errInfo + xhr.status + "(error)"));
    };
    xhr.ontimeout = function(){
        onComplete && onComplete(new Error(errInfo + xhr.status + "(time out)"));
    };
    xhr.onabort = function(){
        onComplete && onComplete(new Error(errInfo + xhr.status + "(abort)"));
    };

    xhr.send(null);
    return xhr;
}

downloader.register({
    // JS
    ".js" : downloadScript,
    ".jsc" : downloadScript,

    // Images
    ".png" : downloadAsset,
    ".jpg" : downloadAsset,
    ...
});

// func傳入的是下載完成之后的處理，比如腳本下載完成后需要執行，此時會調用window.require
// 如果說要下載的是json資源之類的，傳入的func是doNothing，也就是直接調用onComplete方法
function download (url, func, options, onFileProgress, onComplete) {
    var result = transformUrl(url, options);
    // 如果是本地文件，直接指向func
    if (result.inLocal) {
        func(result.url, options, onComplete);
    }
    // 如果在緩存中，更新資源的最后使用時間（lru）
    else if (result.inCache) {
        cacheManager.updateLastTime(url)
        func(result.url, options, function (err, data) {
            if (err) {
                cacheManager.removeCache(url);
            }
            onComplete(err, data);
        });
    }
    else {
        // 未下載的網絡資源，調用downloadFile進行下載
        var time = Date.now();
        var storagePath = "";
        if (options.__cacheBundleRoot__) {
            storagePath = `${cacheManager.cacheDir}/${options.__cacheBundleRoot__}/${time}${suffix++}${cc.path.extname(url)}`;
        }
        else {
            storagePath = `${cacheManager.cacheDir}/${time}${suffix++}${cc.path.extname(url)}`;
        }
        // 使用downloadFile下載并緩存
        downloadFile(url, storagePath, options.header, onFileProgress, function (err, path) {
            if (err) {
                onComplete(err, null);
                return;
            }
            func(path, options, function (err, data) {
                if (!err) {
                    cacheManager.cacheFile(url, storagePath, options.__cacheBundleRoot__);
                }
                onComplete(err, data);
            });
        });
    }
}

function transformUrl (url, options) {
    var inLocal = false;
    var inCache = false;
    // 通過正則匹配是不是URL
    if (REGEX.test(url)) {
        if (options.reload) {
            return { url };
        }
        else {
            // 檢查是否在緩存中（本地磁盤緩存）
            var cache = cacheManager.cachedFiles.get(url);
            if (cache) {
                inCache = true;
                url = cache.url;
            }
        }
    }
    else {
        inLocal = true;
    }
    return { url, inLocal, inCache };
}

downloadFile (remoteUrl, filePath, header, onProgress, onComplete) {
  downloading.add(remoteUrl, { onProgress, onComplete });
  var storagePath = filePath;
  if (!storagePath) storagePath = tempDir + "/" + performance.now() + cc.path.extname(remoteUrl);
  jsb_downloader.createDownloadFileTask(remoteUrl, storagePath, header);
},

parse (id, file, type, options, onComplete) {
  let parsedAsset, parsing, parseHandler;
  if (parsedAsset = parsed.get(id)) {
      onComplete(null, parsedAsset);
  }
  else if (parsing = _parsing.get(id)){
      parsing.push(onComplete);
  }
  else if (parseHandler = parsers[type]){
      _parsing.add(id, [onComplete]);
      parseHandler(file, options, function (err, data) {
          if (err) {
              files.remove(id);
          } 
          else if (!isScene(data)){
              parsed.add(id, data);
          }
          let callbacks = _parsing.remove(id);
          for (let i = 0, l = callbacks.length; i < l; i++) {
              callbacks[i](err, data);
          }
      });
  }
  else {
      onComplete(null, file);
  }
}

// 映射圖片格式到解析方法
var parsers = {
  ".png" : parser.parseImage,
  ".jpg" : parser.parseImage,
  ".bmp" : parser.parseImage,
  ".jpeg" : parser.parseImage,
  ".gif" : parser.parseImage,
  ".ico" : parser.parseImage,
  ".tiff" : parser.parseImage,
  ".webp" : parser.parseImage,
  ".image" : parser.parseImage,
  ".pvr" : parser.parsePVRTex,
  ".pkm" : parser.parsePKMTex,
  // Audio
  ".mp3" : parser.parseAudio,
  ".ogg" : parser.parseAudio,
  ".wav" : parser.parseAudio,
  ".m4a" : parser.parseAudio,

  // plist
  ".plist" : parser.parsePlist,
  "import" : parser.parseImport
};

// 圖片并不會解析成Asset對象，而是解析成對應的圖片對象
parseImage (file, options, onComplete) {
  if (capabilities.imageBitmap && file instanceof Blob) {
      let imageOptions = {};
      imageOptions.imageOrientation = options.__flipY__ ? "flipY" : "none";
      imageOptions.premultiplyAlpha = options.__premultiplyAlpha__ ? "premultiply" : "none";
      createImageBitmap(file, imageOptions).then(function (result) {
          result.flipY = !!options.__flipY__;
          result.premultiplyAlpha = !!options.__premultiplyAlpha__;
          onComplete && onComplete(null, result);
      }, function (err) {
          onComplete && onComplete(err, null);
      });
  }
  else {
      onComplete && onComplete(null, file);
  }
},

// Asset對象的解析，通過deserialize實現，大致流程是解析json然后找到對應的class，并調用對應class的_deserialize方法拷貝數據、初始化變量，并將依賴資源放到asset.__depends
parseImport (file, options, onComplete) {
  if (!file) return onComplete && onComplete(new Error("Json is empty"));
  var result, err = null;
  try {
      result = deserialize(file, options);
  }
  catch (e) {
      err = e;
  }
  onComplete && onComplete(err, result);
},

parser.register({
    ".png" : downloader.downloadDomImage,
    ".binary" : parseArrayBuffer,
    ".txt" : parseText,
    ".plist" : parsePlist,
    ".font" : loadFont,
    ".ExportJson" : parseJson,
    ...
});

var Texture2D = cc.Class({
    name: "cc.Texture2D",
    extends: require("../assets/CCAsset"),
    mixins: [EventTarget],

    properties: {
        _nativeAsset: {
            get () {
                // maybe returned to pool in webgl
                return this._image;
            },
            set (data) {
                if (data._data) {
                    this.initWithData(data._data, this._format, data.width, data.height);
                }
                else {
                    this.initWithElement(data);
                }
            },
            override: true
        },

// 在jsb-loader.js文件中
function parseText (url, options, onComplete) {
    readText(url, onComplete);
}

function parseArrayBuffer (url, options, onComplete) {
    readArrayBuffer(url, onComplete);
}

function parseJson (url, options, onComplete) {
    readJson(url, onComplete);
}

// 在jsb-fs-utils.js文件中
    readText (filePath, onComplete) {
        fsUtils.readFile(filePath, "utf8", onComplete);
    },

    readArrayBuffer (filePath, onComplete) {
        fsUtils.readFile(filePath, "", onComplete);
    },

    readJson (filePath, onComplete) {
        fsUtils.readFile(filePath, "utf8", function (err, text) {
            var out = null;
            if (!err) {
                try {
                    out = JSON.parse(text);
                }
                catch (e) {
                    cc.warn("Read json failed: " + e.message);
                    err = new Error(e.message);
                }
            }
            onComplete && onComplete(err, out);
        });
    },

// 加載指定asset的依賴項
function loadDepends (task, asset, done, init) {

    var item = task.input, progress = task.progress;
    var { uuid, id, options, config } = item;
    var { __asyncLoadAssets__, cacheAsset } = options;

    var depends = [];
    // 增加引用計數來避免加載依賴的過程中資源被釋放，調用getDepends獲取依賴資源
    asset.addRef && asset.addRef();
    getDepends(uuid, asset, Object.create(null), depends, false, __asyncLoadAssets__, config);
    task.dispatch("progress", ++progress.finish, progress.total += depends.length, item);

    var repeatItem = task.options.__exclude__[uuid] = { content: asset, finish: false, callbacks: [{ done, item }] };

    let subTask = Task.create({ 
        input: depends, 
        options: task.options, 
        onProgress: task.onProgress, 
        onError: Task.prototype.recycle, 
        progress, 
        onComplete: function (err) {
            // 在所有依賴項加載完成之后回調
            asset.decRef && asset.decRef(false);
            asset.__asyncLoadAssets__ = __asyncLoadAssets__;
            repeatItem.finish = true;
            repeatItem.err = err;

            if (!err) {
                var assets = Array.isArray(subTask.output) ? subTask.output : [subTask.output];
                // 構造一個map，記錄uuid到asset的映射
                var map = Object.create(null);
                for (let i = 0, l = assets.length; i < l; i++) {
                    var dependAsset = assets[i];
                    dependAsset && (map[dependAsset instanceof cc.Asset ? dependAsset._uuid + "@import" : uuid + "@native"] = dependAsset);
                }

                // 調用setProperties將對應的依賴資源設置到asset的成員變量中
                if (!init) {
                    if (asset.__nativeDepend__ && !asset._nativeAsset) {
                        var missingAsset = setProperties(uuid, asset, map);
                        if (!missingAsset) {
                            try {
                                asset.onLoad && asset.onLoad();
                            }
                            catch (e) {
                                cc.error(e.message, e.stack);
                            }
                        }
                    }
                }
                else {
                    var missingAsset = setProperties(uuid, asset, map);
                    if (!missingAsset) {
                        try {
                            asset.onLoad && asset.onLoad();
                        }
                        catch (e) {
                            cc.error(e.message, e.stack);
                        }
                    }
                    files.remove(id);
                    parsed.remove(id);
                    cache(uuid, asset, cacheAsset !== undefined ? cacheAsset : cc.assetManager.cacheAsset); 
                }
                subTask.recycle();
            }
            
            // 這個repeatItem可能有很多個地方都加載了它，要通知所有回調加載完成
            var callbacks = repeatItem.callbacks;
            for (var i = 0, l = callbacks.length; i < l; i++) {
                var cb = callbacks[i];
                asset.addRef && asset.addRef();
                cb.item.content = asset;
                cb.done(err);
            }
            callbacks.length = 0;
        }
    });

    pipeline.async(subTask);
}

getDepends (uuid, data, exclude, depends, preload, asyncLoadAssets, config) {
  var err = null;
  try {
      var info = dependUtil.parse(uuid, data);
      var includeNative = true;
      if (data instanceof cc.Asset && (!data.__nativeDepend__ || data._nativeAsset)) includeNative = false; 
      if (!preload) {
          asyncLoadAssets = !CC_EDITOR && (!!data.asyncLoadAssets || (asyncLoadAssets && !info.preventDeferredLoadDependents));
          for (let i = 0, l = info.deps.length; i < l; i++) {
              let dep = info.deps[i];
              if (!(dep in exclude)) {
                  exclude[dep] = true;
                  depends.push({uuid: dep, __asyncLoadAssets__: asyncLoadAssets, bundle: config && config.name});
              }
          }

          if (includeNative && !asyncLoadAssets && !info.preventPreloadNativeObject && info.nativeDep) {
              config && (info.nativeDep.bundle = config.name);
              depends.push(info.nativeDep);
          }
          
      } else {
          for (let i = 0, l = info.deps.length; i < l; i++) {
              let dep = info.deps[i];
              if (!(dep in exclude)) {
                  exclude[dep] = true;
                  depends.push({uuid: dep, bundle: config && config.name});
              }
          }
          if (includeNative && info.nativeDep) {
              config && (info.nativeDep.bundle = config.name);
              depends.push(info.nativeDep);
          }
      }
  }
  catch (e) {
      err = e;
  }
  return err;
},

// 根據json信息獲取其資源依賴列表，實際上json信息就是asset對象
parse (uuid, json) {
  var out = null;
  // 如果是場景或者Prefab，data會是一個數組，scene or prefab
  if (Array.isArray(json)) {
      // 如果已經解析過了，在_depends中有依賴列表，則直接返回
      if (this._depends.has(uuid)) return this._depends.get(uuid)
      out = {
          // 對于Prefab或場景，直接使用_parseDepsFromJson方法返回
          deps: cc.Asset._parseDepsFromJson(json),
          asyncLoadAssets: json[0].asyncLoadAssets
      };
  }
  // 如果包含__type__，獲取其構造函數，并從json中查找依賴資源 get deps from json
  // 實際測試，預加載的資源會走下面這個分支，預加載的資源并沒有把json反序列化成Asset對象
  else if (json.__type__) {
      if (this._depends.has(uuid)) return this._depends.get(uuid);
      var ctor = js._getClassById(json.__type__);
      // 部分資源重寫了_parseDepsFromJson和_parseNativeDepFromJson方法
      // 比如cc.Texture2D
      out = {
          preventPreloadNativeObject: ctor.preventPreloadNativeObject,
          preventDeferredLoadDependents: ctor.preventDeferredLoadDependents,
          deps: ctor._parseDepsFromJson(json),
          nativeDep: ctor._parseNativeDepFromJson(json)
      };
      out.nativeDep && (out.nativeDep.uuid = uuid);
  }
  // get deps from an existing asset 
  // 如果沒有__type__字段，則無法找到它對應的ctor，從asset的__depends__字段中取出依賴
  else {
      if (!CC_EDITOR && (out = this._depends.get(uuid)) && out.parsedFromExistAsset) return out;
      var asset = json;
      out = {
          deps: [],
          parsedFromExistAsset: true,
          preventPreloadNativeObject: asset.constructor.preventPreloadNativeObject,
          preventDeferredLoadDependents: asset.constructor.preventDeferredLoadDependents
      };
      let deps = asset.__depends__;
      for (var i = 0, l = deps.length; i < l; i++) {
          var dep = deps[i].uuid;
          out.deps.push(dep);
      }
  
      if (asset.__nativeDepend__) {
          // asset._nativeDep會返回類似這樣的對象 {__isNative__: true, uuid: this._uuid, ext: this._native}
          out.nativeDep = asset._nativeDep;
      }
  }
  // 第一次找到依賴，直接放到_depends列表中，cache dependency list
  this._depends.add(uuid, out);
  return out;
}

_parseDepsFromJson (json) {
      var depends = [];
      parseDependRecursively(json, depends);
      return depends;
},

_parseNativeDepFromJson (json) {
if (json._native) return { __isNative__: true, ext: json._native};
      return null;
}

runSceneImmediate: function (scene, onBeforeLoadScene, onLaunched) {
  // 省略代碼...
  var oldScene = this._scene;
  if (!CC_EDITOR) {
      // 自動釋放資源
      CC_BUILD && CC_DEBUG && console.time("AutoRelease");
      cc.assetManager._releaseManager._autoRelease(oldScene, scene, persistNodeList);
      CC_BUILD && CC_DEBUG && console.timeEnd("AutoRelease");
  }

  // unload scene
  CC_BUILD && CC_DEBUG && console.time("Destroy");
  if (cc.isValid(oldScene)) {
      oldScene.destroy();
  }
  // 省略代碼...
},

// do auto release
_autoRelease (oldScene, newScene, persistNodes) { 
  // 所有持久節點依賴的資源自動addRef、并記錄到sceneDeps.persistDeps中
  for (let i = 0, l = persistNodes.length; i < l; i++) {
      var node = persistNodes[i];
      var sceneDeps = dependUtil._depends.get(newScene._id);
      var deps = _persistNodeDeps.get(node.uuid);
      for (let i = 0, l = deps.length; i < l; i++) {
          var dependAsset = assets.get(deps[i]);
          if (dependAsset) {
              dependAsset.addRef();
          }
      }
      if (sceneDeps) {
          !sceneDeps.persistDeps && (sceneDeps.persistDeps = []);
          sceneDeps.persistDeps.push.apply(sceneDeps.persistDeps, deps);
      }
  }

  // 釋放老場景的依賴
  if (oldScene) {
      var childs = dependUtil.getDeps(oldScene._id);
      for (let i = 0, l = childs.length; i < l; i++) {
          let asset = assets.get(childs[i]);
          asset && asset.decRef(CC_TEST || oldScene.autoReleaseAssets);
      }
      var dependencies = dependUtil._depends.get(oldScene._id);
      if (dependencies && dependencies.persistDeps) {
          var persistDeps = dependencies.persistDeps;
          for (let i = 0, l = persistDeps.length; i < l; i++) {
              let asset = assets.get(persistDeps[i]);
              asset && asset.decRef(CC_TEST || oldScene.autoReleaseAssets);
          }
      }
      dependUtil.remove(oldScene._id);
  }
},

// CCAsset.js 減少引用
decRef (autoRelease) {
  this._ref--;
  autoRelease !== false && cc.assetManager._releaseManager.tryRelease(this);
  return this;
}

// CCAssetManager.js 手動釋放資源
releaseAsset (asset) {
  releaseManager.tryRelease(asset, true);
},

tryRelease (asset, force) {
  if (!(asset instanceof cc.Asset)) return;
  if (force) {
      releaseManager._free(asset, force);
  }
  else {
      _toDelete.add(asset._uuid, asset);
      // 在下次Director繪制完成之后，執行freeAssets
      if (!eventListener) {
          eventListener = true;
          cc.director.once(cc.Director.EVENT_AFTER_DRAW, freeAssets);
      }
  }
}

// 釋放資源
_free (asset, force) {
  _toDelete.remove(asset._uuid);

  if (!cc.isValid(asset, true)) return;

  if (!force) {
      if (asset.refCount > 0) {
          // 檢查資源內部的循環引用
          if (checkCircularReference(asset) > 0) return; 
      }
  }

  // 從緩存中移除
  assets.remove(asset._uuid);
  var depends = dependUtil.getDeps(asset._uuid);
  for (let i = 0, l = depends.length; i < l; i++) {
      var dependAsset = assets.get(depends[i]);
      if (dependAsset) {
          dependAsset.decRef(false);
          releaseManager._free(dependAsset, false);
      }
  }
  asset.destroy();
  dependUtil.remove(asset._uuid);
},

// 釋放_toDelete中的資源并清空
function freeAssets () {
  eventListener = false;
  _toDelete.forEach(function (asset) {
      releaseManager._free(asset);
  });
  _toDelete.clear();
}

prototype.destroy = function () {
    if (this._objFlags & Destroyed) {
        cc.warnID(5000);
        return false;
    }
    if (this._objFlags & ToDestroy) {
        return false;
    }
    this._objFlags |= ToDestroy;
    objectsToDestroy.push(this);

    if (CC_EDITOR && deferredDestroyTimer === null && cc.engine && ! cc.engine._isUpdating) {
        // 在編輯器模式下可以立即銷毀
        deferredDestroyTimer = setImmediate(deferredDestroy);
    }
    return true;
};

// Director每一幀都會調用這個方法
function deferredDestroy () {
    var deleteCount = objectsToDestroy.length;
    for (var i = 0; i < deleteCount; ++i) {
        var obj = objectsToDestroy[i];
        if (!(obj._objFlags & Destroyed)) {
            obj._destroyImmediate();
        }
    }
    // 當我們在a.onDestroy中調用b.destroy，objectsToDestroy數組的大小會變化，我們只銷毀在這次deferredDestroy之前objectsToDestroy中的元素
    if (deleteCount === objectsToDestroy.length) {
        objectsToDestroy.length = 0;
    }
    else {
        objectsToDestroy.splice(0, deleteCount);
    }

    if (CC_EDITOR) {
        deferredDestroyTimer = null;
    }
}

// 真正的資源釋放
prototype._destroyImmediate = function () {
    if (this._objFlags & Destroyed) {
        cc.errorID(5000);
        return;
    }
    // 執行回調
    if (this._onPreDestroy) {
        this._onPreDestroy();
    }

    if ((CC_TEST ? (/* make CC_EDITOR mockable*/ Function("return !CC_EDITOR"))() : !CC_EDITOR) || cc.engine._isPlaying) {
        this._destruct();
    }

    this._objFlags |= Destroyed;
};

prototype._destruct = function () {
    var ctor = this.constructor;
    var destruct = ctor.__destruct__;
    if (!destruct) {
        destruct = compileDestruct(this, ctor);
        js.value(ctor, "__destruct__", destruct, true);
    }
    destruct(this);
};

function compileDestruct (obj, ctor) {
    var shouldSkipId = obj instanceof cc._BaseNode || obj instanceof cc.Component;
    var idToSkip = shouldSkipId ? "_id" : null;

    var key, propsToReset = {};
    for (key in obj) {
        if (obj.hasOwnProperty(key)) {
            if (key === idToSkip) {
                continue;
            }
            switch (typeof obj[key]) {
                case "string":
                    propsToReset[key] = "";
                    break;
                case "object":
                case "function":
                    propsToReset[key] = null;
                    break;
            }
        }
    }
    // Overwrite propsToReset according to Class
    if (cc.Class._isCCClass(ctor)) {
        var attrs = cc.Class.Attr.getClassAttrs(ctor);
        var propList = ctor.__props__;
        for (var i = 0; i < propList.length; i++) {
            key = propList[i];
            var attrKey = key + cc.Class.Attr.DELIMETER + "default";
            if (attrKey in attrs) {
                if (shouldSkipId && key === "_id") {
                    continue;
                }
                switch (typeof attrs[attrKey]) {
                    case "string":
                        propsToReset[key] = "";
                        break;
                    case "object":
                    case "function":
                        propsToReset[key] = null;
                        break;
                    case "undefined":
                        propsToReset[key] = undefined;
                        break;
                }
            }
        }
    }

    if (CC_SUPPORT_JIT) {
        // compile code
        var func = "";
        for (key in propsToReset) {
            var statement;
            if (CCClass.IDENTIFIER_RE.test(key)) {
                statement = "o." + key + "=";
            }
            else {
                statement = "o[" + CCClass.escapeForJS(key) + "]=";
            }
            var val = propsToReset[key];
            if (val === "") {
                val = """";
            }
            func += (statement + val + ";
");
        }
        return Function("o", func);
    }
    else {
        return function (o) {
            for (var key in propsToReset) {
                o[key] = propsToReset[key];
            }
        };
    }
}

// Node的_onPreDestroy
_onPreDestroy () {
  // 調用_onPreDestroyBase方法，實際是調用BaseNode.prototype._onPreDestroy，這個方法下面介紹
  var destroyByParent = this._onPreDestroyBase();

  // 注銷Actions
  if (ActionManagerExist) {
      cc.director.getActionManager().removeAllActionsFromTarget(this);
  }

  // 移除_currentHovered
  if (_currentHovered === this) {
      _currentHovered = null;
  }

  this._bubblingListeners && this._bubblingListeners.clear();
  this._capturingListeners && this._capturingListeners.clear();

  // 移除所有觸摸和鼠標事件監聽
  if (this._touchListener || this._mouseListener) {
      eventManager.removeListeners(this);
      if (this._touchListener) {
          this._touchListener.owner = null;
          this._touchListener.mask = null;
          this._touchListener = null;
      }
      if (this._mouseListener) {
          this._mouseListener.owner = null;
          this._mouseListener.mask = null;
          this._mouseListener = null;
      }
  }

  if (CC_JSB && CC_NATIVERENDERER) {
      this._proxy.destroy();
      this._proxy = null;
  }

  // 回收到對象池中
  this._backDataIntoPool();

  if (this._reorderChildDirty) {
      cc.director.__fastOff(cc.Director.EVENT_AFTER_UPDATE, this.sortAllChildren, this);
  }

  if (!destroyByParent) {
      if (CC_EDITOR) {
          // 確保編輯模式下的，節點的被刪除后可以通過ctrl+z撤銷（重新添加到原來的父節點）
          this._parent = null;
      }
  }
},

// BaseNode的_onPreDestroy
_onPreDestroy () {
  var i, len;

  // 加上Destroying標記
  this._objFlags |= Destroying;
  var parent = this._parent;
  
  // 根據檢測父節點的標記判斷是不是由父節點的destroy發起的釋放
  var destroyByParent = parent && (parent._objFlags & Destroying);
  if (!destroyByParent && (CC_EDITOR || CC_TEST)) {
      // 從編輯器中移除
      this._registerIfAttached(false);
  }

  // 把所有子節點進行釋放，它們的_onPreDestroy也會被執行
  var children = this._children;
  for (i = 0, len = children.length; i < len; ++i) {
      children[i]._destroyImmediate();
  }

  // 把所有的組件進行釋放，它們的_onPreDestroy也會被執行
  for (i = 0, len = this._components.length; i < len; ++i) {
      var component = this._components[i];
      component._destroyImmediate();
  }

  // 注銷事件監聽，比如otherNode.on(type, callback, thisNode) 注冊了事件
  // thisNode被釋放時，需要注銷otherNode身上的監聽，避免事件回調到已銷毀的對象上
  var eventTargets = this.__eventTargets;
  for (i = 0, len = eventTargets.length; i < len; ++i) {
      var target = eventTargets[i];
      target && target.targetOff(this);
  }
  eventTargets.length = 0;

  // 如果自己是常駐節點，則從常駐節點列表中移除
  if (this._persistNode) {
      cc.game.removePersistRootNode(this);
  }

  // 如果是自己釋放的自己，而不是從父節點釋放的，要通知父節點，把這個失效的子節點移除掉
  if (!destroyByParent) {
      if (parent) {
          var childIndex = parent._children.indexOf(this);
          parent._children.splice(childIndex, 1);
          parent.emit && parent.emit("child-removed", this);
      }
  }

  return destroyByParent;
},

// Component的_onPreDestroy
_onPreDestroy () {
  // 移除ActionManagerExist和schedule
  if (ActionManagerExist) {
      cc.director.getActionManager().removeAllActionsFromTarget(this);
  }
  this.unscheduleAllCallbacks();

  // 移除所有的監聽
  var eventTargets = this.__eventTargets;
  for (var i = eventTargets.length - 1; i >= 0; --i) {
      var target = eventTargets[i];
      target && target.targetOff(this);
  }
  eventTargets.length = 0;

  // 編輯器模式下停止監控
  if (CC_EDITOR && !CC_TEST) {
      _Scene.AssetsWatcher.stop(this);
  }

  // destroyComp的實現為調用組件的onDestroy回調，各個組件會在回調中銷毀自身的資源
  // 比如RigidBody3D組件會調用body的destroy方法，而Animation組件會調用stop方法
  cc.director._nodeActivator.destroyComp(this);

  // 將組件從節點身上移除
  this.node._removeComponent(this);
},    

public static traceObject(obj : cc.Asset) {
  let addRefFunc = obj.addRef;
  let decRefFunc = obj.decRef;
  let traceMap = new Map();

  obj.addRef = function() : cc.Asset {
      let stack = ResUtil.getCallStack(1);
      let cnt = traceMap.has(stack) ? traceMap.get(stack) + 1 : 1;
      traceMap.set(stack, cnt);
      return addRefFunc.apply(obj, arguments);
  }

  obj.decRef = function() : cc.Asset {
      let stack = ResUtil.getCallStack(1);
      let cnt = traceMap.has(stack) ? traceMap.get(stack) + 1 : 1;
      traceMap.set(stack, cnt);
      return decRefFunc.apply(obj, arguments);
  }

  obj["dump"] = function() {
      console.log(traceMap);
  }
}