CocosCreator 一般的なフレームワーク設計リソース管理

/**
 * リソース読み込みクラス* 1. 読み込み完了後に参照関係を自動的に記録し、DependKeys に従って逆依存関係を記録します。* 2. リソースの使用をサポートします。たとえば、特定の開かれた UI がリソース A を使用していて、リソース B が他の場所で解放された場合、リソース B はリソース A を参照します。リソース A を参照する他のリソースがない場合、リソース A の解放がトリガーされます。
 * 3. 依存リソースを安全に解放する機能（リソースが複数のリソースによって同時に参照され、他のすべてのリソースが解放された場合にのみリソースが解放される）
 * 
 * 2018-7-17 by Bao Ye*/

// リソース読み込み処理コールバック export type ProcessCallback = (completedCount: number, totalCount: number, item: any) => void;
// リソース読み込み完了コールバック export type CompletedCallback = (error: Error, resource: any) => void;

// 構造体インターフェースCacheInfoの参照と使用{
    参照: Set<文字列>、
    使用法: Set<文字列>
}

// LoadRes メソッドパラメータ構造インターフェース LoadResArgs {
    url: 文字列、
    タイプ?: typeof cc.Asset、
    onCompleted?: CompletedCallback、
    onProgess?: プロセスコールバック、
    使用?: 文字列、
}

// ReleaseRes メソッドパラメータ構造インターフェース ReleaseResArgs {
    url: 文字列、
    タイプ?: typeof cc.Asset、
    使用?: 文字列、
}

// 互換性処理 let isChildClassOf = cc.js["isChildClassOf"]
if (!isChildClassOf) {
    子クラスを cc に代入します。
}

デフォルトクラスResLoaderをエクスポートします。

    プライベート _resMap: Map<string, CacheInfo> = 新しい Map<string, CacheInfo>();
    プライベート静的_resLoader: ResLoader = null;
    パブリック静的getInstance(): ResLoader {
        if (!this._resLoader) {
            this._resLoader = 新しい ResLoader();
        }
        this._resLoader を返します。
    }

    パブリック静的破棄(): void {
        if (this._resLoader) {
            this._resLoader = null;
        }
    }

    プライベートコンストラクタ() {

    }

    /**
     * cc.loaderからリソースアイテムを取得する
     * @param url クエリURL
     * @param type クエリするリソースタイプ*/
    プライベート_getResItem(url: 文字列、タイプ: typeof cc.Asset): 任意{
        ccloader: any = cc.loader; とします。
        item = ccloader._cache[url]とします。
        if (!item) {
            uuid = ccloader._getResUuid(url, type, false);
            （UUID）の場合{
                ref = ccloader._getReferenceKey(uuid); とします。
                アイテム = ccloader._cache[ref];
            }
        }
        返品商品;
    }

    /**
     * loadRes メソッドのパラメータ前処理 */
    プライベート_makeLoadResArgs(): LoadResArgs {
        引数の長さが 1 の場合、引数の型は [0] != "文字列") {
            console.error(`_makeLoadResArgs エラー ${arguments}`);
            null を返します。
        }
        ret: LoadResArgs = { url: arguments[0] };
        (i = 1 とします; i < 引数の長さ; ++i) {
            i == 1 の場合、isChildClassOf(arguments[i], cc.RawAsset) {
                // 最初のパラメータ型かどうかを判定する
                ret.type = 引数[i];
            } そうでない場合、(i == arguments.length - 1 && typeof arguments[i] == "string") {
                // 最後のパラメータ使用かどうかを判定する
                ret.use = 引数[i];
            } そうでない場合 (typeof arguments[i] == "function") {
                // それ以外の場合は関数です if (arguments.length > i + 1 && typeof arguments[i + 1] == "function") {
                    ret.onProgess = 引数[i];
                } それ以外 {
                    ret.onCompleted = 引数[i];
                }
            }
        }
        ret を返します。
    }

    /**
     * releaseRes メソッドのパラメータ前処理 */
    プライベート_makeReleaseResArgs(): ReleaseResArgs {
        引数の長さが 1 の場合、引数の型は [0] != "文字列") {
            console.error(`_makeReleaseResArgs エラー ${arguments}`);
            null を返します。
        }
        ret: ReleaseResArgs = { url: arguments[0] };
        (i = 1 とします; i < 引数の長さ; ++i) {
            if (typeof 引数[i] == "文字列") {
                ret.use = 引数[i];
            } それ以外 {
                ret.type = 引数[i];
            }
        }
        ret を返します。
    }

    /**
     * キーを使用してリソースを生成する
     * @param シーン、UI、プールなど、使用する場所
     * @param who ユーザー (Login、UIHelp など)
     * @param why 使用理由、カスタム...
     */
    パブリック静的 makeUseKey(where: 文字列、who: 文字列 = "none", why: 文字列 = ""): 文字列 {
        `use_${where}_by_${who}_for_${why}` を返します。
    }

    /**
     * リソースキャッシュ情報を取得する * @param key 取得するリソースURL
     */
    パブリックgetCacheInfo(キー: 文字列): CacheInfo {
        if (!this._resMap.has(key)) {
            this._resMap.set(キー、{
                参照: 新しい Set<string>()、
                使用法: new Set<string>()
            });
        }
        this._resMap.get(key) を返します。
    }

    /**
     * リソースの読み込みを開始 * @param url リソースのURL
     * @param type リソースタイプ、デフォルトは null
     * @param onProgess 読み込み進捗状況コールバック* @param onCompleted 読み込み完了コールバック* @param use makeUseKey メソッドに従って生成されたリソース使用キー*/
    パブリック loadRes(url: 文字列、use?: 文字列);
    パブリック loadRes(url: string, onCompleted: CompletedCallback, use?: string);
    パブリック loadRes(url: 文字列、onProgess: ProcessCallback、onCompleted: CompletedCallback、use?: 文字列);
    パブリック loadRes(url: 文字列、タイプ: typeof cc.Asset、使用方法: 文字列);
    パブリック loadRes(url: string, type: typeof cc.Asset, onCompleted: CompletedCallback, use?: string);
    パブリック loadRes(url: string、type: typeof cc.Asset、onProgess: ProcessCallback、onCompleted: CompletedCallback、use?: string);
    パブリックloadRes() {
        resArgs: LoadResArgs = this._makeLoadResArgs.apply(this, arguments); とします。
        console.time("loadRes|"+resArgs.url);
        let finishCallback = (error: Error, resource: any) => {
            // 逆関連付け参照 (参照されているすべてのリソースに、このリソースが参照していることを示すマークを付ける)
            addDependKey = (item, refKey) を追加します => {
                if (item && item.dependKeys && Array.isArray(item.dependKeys)) {
                    for (let depKey of item.dependKeys) {
                        //リソースが自分によって参照されていることを記録します this.getCacheInfo(depKey).refs.add(refKey);
                        // cc.log(`${depKey} は ${refKey} によって参照されます`);
                        ccloader: any = cc.loader; とします。
                        depItem = ccloader._cache[depKey]とします。
                        依存キーを追加します(depItem、refKey)
                    }
                }
            }

            item = this._getResItem(resArgs.url, resArgs.type); とします。
            if (アイテム && item.url) {
                DependKey を追加します(アイテム、アイテム.url);
            } それ以外 {
                cc.warn(`addDependKey 項目エラー1! for ${resArgs.url}`);
            }

            // 自分自身への参照を追加する if (item) {
                info = this.getCacheInfo(item.url); とします。
                info.refs.add(item.url);
                // リソース使用量を更新する if (resArgs.use) {
                    info.uses.add(resArgs.use);
                }
            }

            // 実行完了コールバック if (resArgs.onCompleted) {
                resArgs.onCompleted(エラー、リソース);
            }
            console.timeEnd("loadRes|"+resArgs.url);
        };

        // リソースがロードされたかどうかを予測します。let res = cc.loader.getRes(resArgs.url, resArgs.type);
        もし（res）{
            終了コールバック(null、res);
        } それ以外 {
            cc.loader.loadRes(resArgs.url、resArgs.type、resArgs.onProgess、finishCallback);
        }
    }

    /**
     * リソースを解放する * @param url 解放するURL
     * @param type リソースタイプ* @param use 解放するリソース使用キー。makeUseKey メソッドに従って生成されます*/
    パブリック releaseRes(url: 文字列、use?: 文字列);
    パブリック releaseRes(url: 文字列、タイプ: typeof cc.Asset、使用方法: 文字列)
    パブリックreleaseRes() {
        /**リソースを一時的に解放しない*/
        // 戻る;

        resArgs: ReleaseResArgs = this._makeReleaseResArgs.apply(this, arguments); とします。
        item = this._getResItem(resArgs.url, resArgs.type); とします。
        if (!item) {
            console.warn(`releaseRes 項目が null ${resArgs.url} ${resArgs.type} です`);
            戻る;
        }
        cc.log("resloader リリースアイテム");
        // cc.log(引数);
        cacheInfo を this.getCacheInfo(item.url); に設定します。
        （resArgs.use）の場合{
            cacheInfo.uses.delete(resArgs.use)
        }
        this._release(アイテム、アイテム.url);
    }

    // リソースを解放する private _release(item, itemUrl) {
        if (!item) {
            戻る;
        }
        cacheInfo を this.getCacheInfo(item.url); に設定します。
        // 自身への参照を削除します。cacheInfo.refs.delete(itemUrl);

        （cacheInfo.uses.size == 0 && cacheInfo.refs.size == 0）の場合{
            // 逆参照 let delDependKey = (item, refKey) => {
                if (item && item.dependKeys && Array.isArray(item.dependKeys)) {
                    for (let depKey of item.dependKeys) {
                        ccloader: any = cc.loader; とします。
                        depItem = ccloader._cache[depKey]とします。
                        this._release(depItem、refKey);
                    }
                }
            }
            delDependKey(アイテム、アイテムUrl);
            //UUIDがない場合はURLを直接解放します
            if (item.uuid) {
                cc.loader.release(item.uuid);
                cc.log("resloader が uuid でアイテムを解放:" + item.url);
            } それ以外 {
                cc.loader.release(アイテムのURL);
                cc.log("resloader は URL でアイテムをリリースしました:" + item.url);
            }
        }
    }

    /**
     * リソースを解放できるかどうかを決定する * @param url リソースのURL
     * @param type リソースタイプ* @param use 解放するリソース使用キー。makeUseKey メソッドに従って生成されます*/
    パブリック checkReleaseUse(url: string, use?: string): boolean;
    パブリック checkReleaseUse(url: 文字列、タイプ: typeof cc.Asset、使用?: 文字列): ブール値
    パブリック checkReleaseUse() {
        resArgs: ReleaseResArgs = this._makeReleaseResArgs.apply(this, arguments); とします。
        item = this._getResItem(resArgs.url, resArgs.type); とします。
        if (!item) {
            console.log(`解放できません、アイテムが null ${resArgs.url} ${resArgs.type}`);
            true を返します。
        }

        cacheInfo を this.getCacheInfo(item.url); に設定します。
        checkUse を false にします。
        checkRef = false とします。

        resArgs.use と cacheInfo.uses.size > 0 の場合 {
            cacheInfo.uses.size == 1 の場合、cacheInfo.uses.has(resArgs.use) になります。
                チェック使用 = true;
            } それ以外 {
                チェック使用 = false;
            }
        } それ以外 {
            チェック使用 = true;
        }

        （（cacheInfo.refs.size == 1 && cacheInfo.refs.has(item.url)）|| cacheInfo.refs.size == 0）の場合{
            チェックRef = true;
        } それ以外 {
            チェックRef = false;
        }

        checkUse && checkRef; を返します。
    }
}

@ccクラス
デフォルトクラスNetExampleをエクスポートし、cc.Componentを拡張します。
    @property(cc.Node)
    アタッチノード: cc.Node = null;
    @property(cc.ラベル)
    dumpLabel: cc.Label = null;

    onLoadRes() {
        cc.loader.loadRes("Prefab/HelloWorld", cc.Prefab, (エラー: エラー、プレファブ: cc.Prefab) => {
            もしエラーなら
                cc.instantiate(prefab).parent = this.attachNode;
            }
        });
    }

    onUnloadRes() {
        this.attachNode.removeAllChildren(true);
        cc.loader.releaseRes("プレハブ/HelloWorld");
    }

    onMyLoadRes() {
        ResLoader.getInstance().loadRes("Prefab/HelloWorld", cc.Prefab, (エラー: エラー、プレファブ: cc.Prefab) => {
            もしエラーなら
                cc.instantiate(prefab).parent = this.attachNode;
            }
        });
    }

    オンマイアンロードRes() {
        this.attachNode.removeAllChildren(true);
        ResLoader.getInstance().releaseRes("Prefab/HelloWorld");
    }

    オンダンプ() {
        Loader:any = cc.loader; とします。
        this.dumpLabel.string = `現在のリソースの合計数: ${Object.keys(Loader._cache).length}`;
    }
}