CocosCreator allgemeines Framework-Design Ressourcenmanagement

/**
 * Ressourcenladeklasse* 1. Zeichnet automatisch die Referenzbeziehung auf, nachdem der Ladevorgang abgeschlossen ist, und zeichnet die umgekehrte Abhängigkeit gemäß DependKeys* 2 auf. Unterstützt die Ressourcennutzung. Wenn beispielsweise eine bestimmte geöffnete Benutzeroberfläche Ressource A verwendet und Ressource B an anderer Stelle freigegeben wird, verweist Ressource B auf Ressource A. Wenn es keine andere Ressource gibt, die auf Ressource A verweist, wird die Freigabe von Ressource A ausgelöst.
 * 3. Möglichkeit zur sicheren Freigabe abhängiger Ressourcen (auf eine Ressource wird gleichzeitig von mehreren Ressourcen verwiesen, und die Ressource wird erst freigegeben, wenn alle anderen Ressourcen freigegeben sind)
 * 
 * 17.07.2018 von Bao Ye*/

// Callback für die Verarbeitung des Ladens von Ressourcen, Exporttyp ProcessCallback = (completedCount: Zahl, totalCount: Zahl, Element: beliebig) => void;
// Rückruf für Abschluss des Ressourcenladens Exporttyp CompletedCallback = (Fehler: Fehler, Ressource: beliebig) => void;

// Referenzieren und verwenden Sie die Strukturschnittstelle CacheInfo {
    Verweise: Set<string>,
    verwendet: Set<string>
}

// LoadRes-Methode Parameterstruktur Schnittstelle LoadResArgs {
    URL: Zeichenfolge,
    Typ?: Typ von cc.Asset,
    beiAbgeschlossen?: Abgeschlossener Rückruf,
    beiFortschritt?: Prozessrückruf,
    verwenden?: Zeichenfolge,
}

// ReleaseRes-Methodenparameterstrukturschnittstelle ReleaseResArgs {
    URL: Zeichenfolge,
    Typ?: Typ von cc.Asset,
    verwenden?: Zeichenfolge,
}

// Kompatibilitätsverarbeitung let isChildClassOf = cc.js["isChildClassOf"]
wenn (!istKindKlasseVon) {
    istKindKlasseVon = cc["istKindKlasseVon"];
}

exportiere Standardklasse ResLoader {

    private _resMap: Map<string, CacheInfo> = neue Map<string, CacheInfo>();
    privater statischer _resLoader: ResLoader = null;
    öffentliche statische getInstance(): ResLoader {
        wenn (!this._resLoader) {
            this._resLoader = neuer ResLoader();
        }
        gib dies zurück._resLoader;
    }

    öffentliche statische zerstören(): void {
        wenn (this._resLoader) {
            this._resLoader = null;
        }
    }

    privater Konstruktor() {

    }

    /**
     * Holen Sie sich ein Ressourcenelement von cc.loader
     * @param URL Abfrage-URL
     * @param type Der abzufragende Ressourcentyp*/
    private _getResItem(url: string, type: typeof cc.Asset): any {
        Lassen Sie ccloader: beliebig = cc.loader;
        : Lassen Sie das Element = ccloader._cache[url];
        wenn (!Artikel) {
            let uuid = ccloader._getResUuid(url, Typ, false);
            wenn (uuid) {
                let ref = ccloader._getReferenceKey(uuid);
                Element = ccloader._cache[ref];
            }
        }
        Artikel zurückgeben;
    }

    /**
     * Parametervorverarbeitung der loadRes-Methode */
    private _makeLoadResArgs(): LoadResArgs {
        wenn (Argumente.Länge < 1 || Typ der Argumente[0] != "Zeichenfolge") {
            console.error(`_makeLoadResArgs-Fehler ${arguments}`);
            gibt null zurück;
        }
        let ret: LoadResArgs = { url: arguments[0] };
        für (lass i = 1; i < Argumente.Länge; ++i) {
            wenn (i == 1 und isChildClassOf(Argumente[i], cc.RawAsset)) {
                // Bestimmen Sie, ob es sich um den ersten Parametertyp handelt
                ret.type = Argumente[i];
            } sonst wenn (i == arguments.length - 1 && Typ der Argumente[i] == "string") {
                //Feststellen, ob es sich um den letzten verwendeten Parameter handelt
                ret.use = Argumente[i];
            } sonst wenn (Typ der Argumente[i] == "Funktion") {
                // Sonst ist es eine Funktion if (arguments.length > i + 1 && typeof arguments[i + 1] == "function") {
                    ret.onProgess = Argumente[i];
                } anders {
                    ret.onCompleted = Argumente[i];
                }
            }
        }
        Rückkehr ret;
    }

    /**
     * Parametervorverarbeitung der Methode releaseRes */
    private _makeReleaseResArgs(): ReleaseResArgs {
        wenn (Argumente.Länge < 1 || Typ der Argumente[0] != "Zeichenfolge") {
            console.error(`_makeReleaseResArgs-Fehler ${arguments}`);
            gibt null zurück;
        }
        let ret: ReleaseResArgs = { url: arguments[0] };
        für (lass i = 1; i < Argumente.Länge; ++i) {
            wenn (Typ der Argumente[i] == "Zeichenfolge") {
                ret.use = Argumente[i];
            } anders {
                ret.type = Argumente[i];
            }
        }
        Rückkehr ret;
    }

    /**
     * Generieren Sie eine Ressource mit dem Schlüssel
     * @param wo es verwendet werden soll, z. B. Szene, UI, Pool
     * @param who-Benutzer, wie etwa Login, UIHelp...
     * @param warum Grund für die Verwendung, benutzerdefiniert ...
     */
    public static makeUseKey(wobei: Zeichenfolge, wer: Zeichenfolge = "keine", warum: Zeichenfolge = ""): Zeichenfolge {
        returniere `use_${where}_by_${who}_for_${why}`;
    }

    /**
     * Informationen zum Ressourcen-Cache abrufen * @param key Die abzurufende Ressourcen-URL
     */
    öffentliche getCacheInfo(Schlüssel: Zeichenfolge): CacheInfo {
        wenn (!this._resMap.has(Schlüssel)) {
            this._resMap.set(Schlüssel, {
                Verweise: neues Set<string>(),
                verwendet: new Set<string>()
            });
        }
        gib dies zurück._resMap.get(Schlüssel);
    }

    /**
     * Beginnen Sie mit dem Laden der Ressourcen * @param url Ressourcen-URL
     * @param Typ Ressourcentyp, Standard ist null
     * @param onProgess Rückruf für Ladefortschritt* @param onCompleted Rückruf für Ladeabschluss* @param Verwende den Ressourcennutzungsschlüssel, der gemäß der Methode makeUseKey generiert wurde*/
    öffentliche loadRes(URL: Zeichenfolge, Verwendung?: Zeichenfolge);
    öffentliche loadRes(URL: Zeichenfolge, bei Abschluss: Abgeschlossener Rückruf, verwenden?: Zeichenfolge);
    öffentliche loadRes(URL: Zeichenfolge, bei Fortschritt: ProcessCallback, bei Abschluss: CompletedCallback, verwenden?: Zeichenfolge);
    öffentliche loadRes(URL: Zeichenfolge, Typ: Typ von cc.Asset, Verwendung?: Zeichenfolge);
    öffentliche loadRes(URL: Zeichenfolge, Typ: Typ von cc.Asset, bei Abschluss: Abgeschlossener Rückruf, Verwendung?: Zeichenfolge);
    öffentliche loadRes(URL: Zeichenfolge, Typ: Typ von cc.Asset, bei Fortschritt: ProcessCallback, bei Abschluss: CompletedCallback, Verwendung?: Zeichenfolge);
    öffentliche loadRes() {
        : let resArgs: LoadResArgs = this._makeLoadResArgs.apply(this, Argumente);
        Konsole.Zeit("loadRes|"+resArgs.url);
        let finishCallback = (Fehler: Fehler, Ressource: beliebig) => {
            // Umgekehrte Assoziationsreferenz (markiere alle referenzierten Ressourcen mit der Markierung, dass diese Ressource auf sie verweist)
            let addDependKey = (Element, RefKey) => {
                wenn (Element && Element.dependKeys && Array.isArray(Element.dependKeys)) {
                    für (let depKey von item.dependKeys) {
                        //Aufzeichnen, dass die Ressource von mir referenziert wird this.getCacheInfo(depKey).refs.add(refKey);
                        // cc.log(`${depKey} ref durch ${refKey}`);
                        Lassen Sie ccloader: beliebig = cc.loader;
                        let depItem = ccloader._cache[depKey]
                        addDependKey(depItem, refKey)
                    }
                }
            }

            : Lassen Sie das Element = this._getResItem(resArgs.url, resArgs.type);
            wenn (Artikel && Artikel.URL) {
                Fügt eine URL hinzu, die mit dem Schlüsselwert übereinstimmt, den Sie angeben möchten.
            } anders {
                cc.warn(`addDependKey item error1! für ${resArgs.url}`);
            }

            // Füge eine Referenz auf dich selbst hinzu, wenn (Element) {
                let info = this.getCacheInfo(item.url);
                } info.refs.add(item.url);
                // Ressourcennutzung aktualisieren, wenn (resArgs.use) {
                    } info.uses.add(resArgs.use);
                }
            }

            // Rückruf für Ausführungsabschluss if (resArgs.onCompleted) {
                resArgs.onCompleted(Fehler, Ressource);
            }
            console.timeEnd("loadRes|"+resArgs.url);
        };

        // Vorhersagen, ob die Ressource geladen wurde let res = cc.loader.getRes(resArgs.url, resArgs.type);
        wenn (res) {
            finishCallback(null, res);
        } anders {
            cc.loader.loadRes(resArgs.url, resArgs.type, resArgs.onProgess, finishCallback);
        }
    }

    /**
     * Ressourcen freigeben * @param url Die freizugebende URL
     * @param Typ Ressourcentyp* @param use freizugebender Ressourcennutzungsschlüssel, generiert gemäß der Methode makeUseKey*/
    öffentliche ReleaseRes (URL: Zeichenfolge, Verwendung?: Zeichenfolge);
    öffentliche ReleaseRes(URL: Zeichenfolge, Typ: Typ von cc.Asset, Verwendung?: Zeichenfolge)
    öffentliche releaseRes() {
        /**Ressourcen nicht vorübergehend freigeben*/
        // zurückkehren;

        : Lassen Sie uns resArgs verwenden.
        : Lassen Sie das Element = this._getResItem(resArgs.url, resArgs.type);
        wenn (!Artikel) {
            console.warn(`releaseRes-Element ist null ${resArgs.url} ${resArgs.type}`);
            zurückkehren;
        }
        cc.log("Resloader-Freigabeelement");
        // cc.log(Argumente);
        let cacheInfo = this.getCacheInfo(item.url);
        wenn (resArgs.use) {
            cacheInfo.uses.delete(resArgs.use)
        }
        diese._release(Artikel, Artikel.URL);
    }

    // Eine Ressource freigeben private _release(item, itemUrl) {
        wenn (!Artikel) {
            zurückkehren;
        }
        let cacheInfo = this.getCacheInfo(item.url);
        // Entfernen Sie den Verweis auf sich selbst cacheInfo.refs.delete(itemUrl);

        wenn (cacheInfo.uses.size == 0 und cacheInfo.refs.size == 0) {
            // Dereferenzieren let delDependKey = (item, refKey) => {
                wenn (Element && Element.dependKeys && Array.isArray(Element.dependKeys)) {
                    für (let depKey von item.dependKeys) {
                        Lassen Sie ccloader: beliebig = cc.loader;
                        let depItem = ccloader._cache[depKey]
                        this._release(depItem, refKey);
                    }
                }
            }
            delDependKey(Element, Element-URL);
            //Wenn keine UUID vorhanden ist, geben Sie die URL direkt frei
            wenn (Artikel.uuid) {
                cc.loader.release(Element.uuid);
                cc.log("Resloader gibt Element per UUID frei:" + item.url);
            } anders {
                cc.loader.release(Artikel.URL);
                cc.log("Resloader gibt Element per URL frei:" + item.url);
            }
        }
    }

    /**
     * Bestimmen Sie, ob eine Ressource freigegeben werden kann * @param url Ressourcen-URL
     * @param Typ Ressourcentyp* @param use freizugebender Ressourcennutzungsschlüssel, generiert gemäß der Methode makeUseKey*/
    öffentliche checkReleaseUse(URL: Zeichenfolge, Verwendung?: Zeichenfolge): Boolesch;
    öffentliche checkReleaseUse(URL: Zeichenfolge, Typ: Typ von cc.Asset, Verwendung?: Zeichenfolge): Boolesch
    öffentliche checkReleaseUse() {
        : Lassen Sie uns resArgs verwenden.
        : Lassen Sie das Element = this._getResItem(resArgs.url, resArgs.type);
        wenn (!Artikel) {
            console.log(`kann nicht freigegeben werden, Element ist null ${resArgs.url} ${resArgs.type}`);
            gibt true zurück;
        }

        let cacheInfo = this.getCacheInfo(item.url);
        lassen Sie checkUse = false;
        lassen Sie checkRef = false;

        wenn (resArgs.use && cacheInfo.uses.size > 0) {
            wenn (cacheInfo.uses.size == 1 && cacheInfo.uses.has(resArgs.use)) {
                checkUse = wahr;
            } anders {
                checkUse = falsch;
            }
        } anders {
            checkUse = wahr;
        }

        wenn ((cacheInfo.refs.size == 1 && cacheInfo.refs.has(item.url)) || cacheInfo.refs.size == 0) {
            checkRef = wahr;
        } anders {
            checkRef = falsch;
        }

        Rückgabewert: checkUse && checkRef;
    }
}

@ccklasse
exportiere Standardklasse NetExample erweitert cc.Component {
    @Eigenschaft(cc.Node)
    AttachNode: cc.Node = null;
    @Eigenschaft(cc.Label)
    dumpLabel: cc.Label = null;

    onLoadRes() {
        cc.loader.loadRes("Prefab/HelloWorld", cc.Prefab, (Fehler: Fehler, prefab: cc.Prefab) => {
            wenn (!Fehler) {
                cc.instantiate(prefab).parent = dieser.attachNode;
            }
        });
    }

    beimEntladenRes() {
        dies.attachNode.removeAllChildren(true);
        cc.loader.releaseRes("Prefab/Hallo Welt");
    }

    beiMeinLoadRes() {
        ResLoader.getInstance().loadRes("Prefab/HelloWorld", cc.Prefab, (Fehler: Fehler, prefab: cc.Prefab) => {
            wenn (!Fehler) {
                cc.instantiate(prefab).parent = dieser.attachNode;
            }
        });
    }

    beiMeinUnloadRes() {
        dies.attachNode.removeAllChildren(true);
        ResLoader.getInstance().releaseRes("Prefab/HelloWorld");
    }

    beiDump() {
        let Loader:any = cc.loader;
        this.dumpLabel.string = `Aktuelle Gesamtzahl der Ressourcen: ${Object.keys(Loader._cache).length}`;
    }
}