Utilisation de ressources externes dans Unity3D

Présentation

Bonjour chers lecteurs, nous allons parler aujourd'hui de travailler avec des ressources externes dans l'environnement Unity 3d.

Par tradition, pour commencer, nous déterminerons ce que c'est et pourquoi nous en avons besoin. Alors, quelles sont exactement ces ressources externes. Dans le cadre du développement de jeux, ces ressources peuvent être tout ce qui est nécessaire au fonctionnement de l'application et ne doivent pas être stockées dans la version finale du projet. Les ressources externes peuvent être situées à la fois sur le disque dur de l'ordinateur de l'utilisateur et sur un serveur Web externe. Dans le cas général, ces ressources sont tout fichier ou ensemble de données que nous chargeons dans notre application déjà en cours d'exécution. S'exprimant dans le cadre d'Unity 3d, alors ils peuvent être:

• Fichier texte
• Fichier de texture
• Fichier audio
• Tableau d'octets
• AssetBundle (archive avec les actifs du projet Unity 3d)

Ci-dessous, nous examinerons plus en détail les mécanismes intégrés pour travailler avec ces ressources qui sont présents dans Unity 3d, ainsi que pour écrire des gestionnaires simples pour interagir avec le serveur Web et charger des ressources dans l'application.

Remarque : le reste de cet article utilise du code utilisant C # 7+ et est conçu pour le compilateur Roslyn utilisé dans Unity3d dans les versions 2018.3+.

Caractéristiques de Unity 3D

Avant Unity 2017, un mécanisme (à l'exclusion de l'auto-description) était utilisé pour travailler avec les données du serveur et les ressources externes, qui étaient incluses dans le moteur - il s'agit de la classe WWW. Cette classe a permis l'utilisation de diverses commandes http (get, post, put, etc.) sous forme synchrone ou asynchrone (via Coroutine). Le travail avec cette classe était assez simple et direct.

IEnumerator LoadFromServer(string url) { var www = new WWW(url); yield return www; Debug.Log(www.text); } 

De même, vous pouvez obtenir non seulement des données texte, mais également d'autres:

• Tableau d'octets - www.bytes
• Texture - www.texture
• Audio - www.GetAudioClip ()
• Atout - www.assetBundle

Cependant, à partir de la version 2017, Unity dispose d'un nouveau système de serveur introduit par la classe UnityWebRequest , qui se trouve dans l'espace de noms Networking. Jusqu'à Unity 2018, il existait avec WWW , mais dans la dernière version du moteur WWW , il n'était plus recommandé, et à l'avenir, il sera complètement supprimé. Par conséquent, nous nous concentrerons davantage sur UnityWebRequest (ci-après UWR).

Travailler avec UWR dans son ensemble est similaire à WWW dans son cœur, mais il existe des différences, qui seront discutées plus tard. Voici un exemple similaire de chargement de texte.

 IEnumerator LoadFromServer(string url) { var request = new UnityWebRequest(url); yield return request.SendWebRequest(); Debug.Log(request.downloadHandler.text); request.Dispose(); } 

Les principaux changements que le nouveau système UWR a introduits (en plus de changer le principe de travailler à l'intérieur) sont la possibilité d'affecter des gestionnaires pour télécharger et télécharger des données depuis le serveur lui-même, plus de détails peuvent être lus ici . Par défaut, ce sont les classes UploadHandler et DownloadHandler . Unity lui-même fournit un ensemble d'extensions de ces classes pour travailler avec diverses données, telles que l'audio, les textures, les actifs, etc. Envisageons de travailler avec eux plus en détail.

Travailler avec des ressources

Texte

Travailler avec du texte est l'une des options les plus simples. La méthode de téléchargement a déjà été décrite ci-dessus. Nous le réécrivons un peu en utilisant la création d'une requête http Get directe.

 IEnumerator LoadTextFromServer(string url, Action<string> response) { var request = UnityWebRequest.Get(url); yield return request.SendWebRequest(); if (!request.isHttpError && !request.isNetworkError) { response(uwr.downloadHandler.text); } else { Debug.LogErrorFormat("error request [{0}, {1}]", url, request.error); response(null); } request.Dispose(); } 

Comme vous pouvez le voir dans le code, le DownloadHandler par défaut est utilisé ici. La propriété text est un getter qui convertit un tableau d'octets en texte codé UTF8. L'utilisation principale du chargement de texte à partir du serveur est de recevoir un fichier json (représentation sérialisée des données sous forme de texte). Vous pouvez obtenir ces données à l'aide de la classe Unity JsonUtility .

 var data = JsonUtility.FromJson<T>(value); // T  ,    . 

Audio

Pour travailler avec l'audio, vous devez utiliser la méthode spéciale de création de la demande UnityWebRequestMultimedia.GetAudioClip , et pour obtenir la représentation des données sous la forme nécessaire pour travailler dans Unity, vous devez utiliser DownloadHandlerAudioClip . De plus, lors de la création d'une demande, vous devez spécifier le type de données audio représenté par l'énumération AudioType , qui définit le format (wav, aiff, oggvorbis, etc.).

 IEnumerator LoadAudioFromServer(string url, AudioType audioType, Action<AudioClip> response) { var request = UnityWebRequestMultimedia.GetAudioClip(url, audioType); yield return request.SendWebRequest(); if (!request.isHttpError && !request.isNetworkError) { response(DownloadHandlerAudioClip.GetContent(request)); } else { Debug.LogErrorFormat("error request [{0}, {1}]", url, request.error); response(null); } request.Dispose(); } 

La texture

Le téléchargement des textures est similaire à celui des fichiers audio. La demande est créée à l'aide de UnityWebRequestTexture.GetTexture . Pour obtenir les données sous la forme nécessaire pour Unity, DownloadHandlerTexture est utilisé.

 IEnumerator LoadTextureFromServer(string url, Action<Texture2D> response) { var request = UnityWebRequestTexture.GetTexture(url); yield return request.SendWebRequest(); if (!request.isHttpError && !request.isNetworkError) { response(DownloadHandlerTexture.GetContent(request)); } else { Debug.LogErrorFormat("error request [{0}, {1}]", url, request.error); response(null); } request.Dispose(); } 

Ensemble d'actifs

Comme mentionné précédemment, le bundle est, en fait, une archive avec des ressources Unity qui peuvent être utilisées dans un jeu déjà en cours d'exécution. Ces ressources peuvent être n'importe quel actif du projet, y compris des scènes. L'exception concerne les scripts C #, ils ne peuvent pas être transmis. Pour charger le AssetBundle , une requête est utilisée qui est créée à l'aide de UnityWebRequestAssetBundle.GetAssetBundle. DownloadHandlerAssetBundle est utilisé pour obtenir des données sous la forme nécessaire pour Unity.

 IEnumerator LoadBundleFromServer(string url, Action<AssetBundle> response) { var request = UnityWebRequestAssetBundle.GetAssetBundle(url); yield return request.SendWebRequest(); if (!request.isHttpError && !request.isNetworkError) { response(DownloadHandlerAssetBundle.GetContent(request)); } else { Debug.LogErrorFormat("error request [{0}, {1}]", url, request.error); response(null); } request.Dispose(); } 

Les principaux problèmes et solutions lors de l'utilisation d'un serveur Web et de données externes

Des méthodes simples d'interaction entre une application et un serveur en termes de chargement de différentes ressources ont été décrites ci-dessus. Cependant, dans la pratique, les choses sont beaucoup plus compliquées. Considérez les principaux problèmes qui accompagnent les développeurs et insistez sur les moyens de les résoudre.

Pas assez d'espace libre

L'un des premiers problèmes lors du téléchargement de données à partir du serveur est un éventuel manque d'espace libre sur l'appareil. Il arrive souvent que l'utilisateur utilise de vieux appareils pour les jeux (en particulier sur Android), ainsi que la taille des fichiers téléchargés lui-même peut être assez grande (bonjour PC). Dans tous les cas, cette situation doit être correctement traitée et le joueur doit être informé à l'avance qu'il n'y a pas assez d'espace et combien. Comment faire La première chose que vous devez savoir est la taille du fichier téléchargé, cela se fait au moyen de la demande UnityWebRequest.Head () . Voici le code pour obtenir la taille.

 IEnumerator GetConntentLength(string url, Action<int> response) { var request = UnityWebRequest.Head(url); yield return request.SendWebRequest(); if (!request.isHttpError && !request.isNetworkError) { var contentLength = request.GetResponseHeader("Content-Length"); if (int.TryParse(contentLength, out int returnValue)) { response(returnValue); } else { response(-1); } } else { Debug.LogErrorFormat("error request [{0}, {1}]", url, request.error); response(-1); } } 

Il est important de noter une chose ici, pour que la requête fonctionne correctement, le serveur doit être en mesure de renvoyer la taille du contenu, sinon (comme, en fait, pour afficher la progression), la mauvaise valeur sera retournée.

Après avoir obtenu la taille des données téléchargées, nous pouvons les comparer avec la taille de l'espace disque libre. Pour obtenir ce dernier, j'utilise le plugin gratuit du Asset Store .

Remarque : vous pouvez utiliser la classe Cache dans Unity3d, elle peut afficher l'espace de cache libre et utilisé. Cependant, il convient de considérer le fait que ces données sont relatives. Ils sont calculés en fonction de la taille du cache lui-même, par défaut, il est de 4 Go. Si l'utilisateur a plus d'espace libre que la taille du cache, il n'y aura pas de problème, mais si ce n'est pas le cas, les valeurs peuvent prendre des valeurs incorrectes par rapport à la situation réelle.

Vérification de l'accès Internet

Très souvent, avant de télécharger quoi que ce soit à partir du serveur, il est nécessaire de gérer la situation de manque d'accès à Internet. Il existe plusieurs façons de procéder: du ping d'une adresse à une demande GET sur google.ru. Cependant, à mon avis, le résultat le plus correct et le plus rapide et le plus stable consiste à télécharger à partir de votre propre serveur (le même à partir duquel les fichiers seront téléchargés) un petit fichier. La procédure à suivre est décrite ci-dessus dans la section sur l'utilisation du texte.
En plus de vérifier le fait d'avoir accès à Internet, il est également nécessaire de déterminer son type (mobile ou WiFi), car il est peu probable qu'un joueur veuille télécharger plusieurs centaines de mégaoctets sur le trafic mobile. Cela peut être fait via la propriété Application.internetReachability .

Mise en cache

Le suivant, et l'un des problèmes les plus importants, est la mise en cache des fichiers téléchargés. À quoi sert cette mise en cache?

1. Économisez du trafic (ne téléchargez pas les données déjà téléchargées)
2. Assurer le travail en l'absence d'Internet (vous pouvez afficher les données du cache).

Qu'est-ce qui doit être mis en cache? La réponse à cette question est tout, tous les fichiers que vous téléchargez doivent être mis en cache. Comment faire, considérez ci-dessous et commencez avec des fichiers texte simples.
Malheureusement, Unity n'a pas de mécanisme intégré pour la mise en cache du texte, ainsi que des textures et des fichiers audio. Par conséquent, pour ces ressources, il est nécessaire d'écrire votre système, ou de ne pas écrire, selon les besoins du projet. Dans le cas le plus simple, nous écrivons simplement le fichier dans le cache et, en l'absence d'Internet, nous en prenons le fichier. Dans une version légèrement plus complexe (je l'utilise dans des projets), nous envoyons une requête au serveur, qui retourne json indiquant les versions des fichiers qui sont stockés sur le serveur. Vous pouvez écrire et lire des fichiers à partir du cache à l'aide de la classe C # de la classe File ou de toute autre manière pratique et acceptée par votre équipe.

 private void CacheText(string fileName, string data) { var cacheFilePath = Path.Combine("CachePath", "{0}.text".Fmt(fileName)); File.WriteAllText(cacheFilePath, data); } private void CacheTexture(string fileName, byte[] data) { var cacheFilePath = Path.Combine("CachePath", "{0}.texture".Fmt(fileName)); File.WriteAllBytes(cacheFilePath, data); } 

De même, obtenir des données du cache.

 private string GetTextFromCache(string fileName) { var cacheFilePath = Path.Combine(Utils.Path.Cache, "{0}.text".Fmt(fileName)); if (File.Exists(cacheFilePath)) { return File.ReadAllText(cacheFilePath); } return null; } private Texture2D GetTextureFromCache(string fileName) { var cacheFilePath = Path.Combine(Utils.Path.Cache, "{0}.texture".Fmt(fileName)); Texture2D texture = null; if (File.Exists(cacheFilePath)) { var data = File.ReadAllBytes(cacheFilePath); texture = new Texture2D(1, 1); texture.LoadImage(data, true); } return texture; } 

Remarque : pourquoi le même UWR avec une URL du fichier de formulaire: // n'est pas utilisé pour charger les textures. Pour le moment, il y a des problèmes avec cela, le fichier ne se charge tout simplement pas, j'ai donc dû trouver une solution de contournement.

Remarque : Je n'utilise pas le chargement direct d'AudioClip dans les projets, je stocke toutes ces données dans AssetBundle. Cependant, si nécessaire, cela peut facilement être fait en utilisant les fonctions de la classe AudioClip GetData et SetData.

Les ressources simples d'Unity pour AssetBundle , Unity dispose d'un mécanisme de mise en cache intégré. Examinons-le plus en détail.

Fondamentalement, ce mécanisme peut utiliser deux approches:

1. Utilisation du CRC et du numéro de version
2. Utilisation des valeurs de hachage

En principe, vous pouvez utiliser n'importe lequel d'entre eux, mais j'ai décidé moi-même que Hash est le plus acceptable, car j'ai mon propre système de version et il prend en compte non seulement la version AssetBundle , mais aussi la version de l'application, car souvent le bundle peut ne pas être compatible avec la version, présenté en magasin.

Alors, comment se fait la mise en cache:

1. Nous demandons un fichier de bundle au serveur manifeste (ce fichier est créé automatiquement lors de sa création et contient une description des actifs qu'il contient, ainsi que le hachage, le crc, la taille, etc.). Le fichier a le même nom que le bundle plus l'extension .manifest.
2. Obtenez la valeur hash128 du manifeste
3. Nous créons une demande au serveur pour obtenir un AssetBundle, où en plus de l'URL, spécifiez la valeur de hachage128 reçue

Dans l'exemple ci-dessus, Unity, lors de l'interrogation du serveur, cherche d'abord à voir s'il y a un fichier dans le cache avec la valeur de hachage 128 spécifiée, si c'est le cas, il sera renvoyé; sinon, le fichier mis à jour sera téléchargé. Pour gérer tous les fichiers de cache dans Unity, il existe une classe de mise en cache , avec laquelle nous pouvons savoir s'il y a un fichier dans le cache, obtenir toutes les versions mises en cache, ainsi que supprimer les versions inutiles ou les effacer complètement.

Remarque : pourquoi une telle façon étrange d'obtenir des valeurs de hachage? Cela est dû au fait que l'obtention de hachage128 de la manière décrite dans la documentation nécessite le chargement de l'ensemble complet, puis la réception de l'actif AssetBundleManifest de celui-ci et de là déjà des valeurs de hachage. L'inconvénient de cette approche est que l'ensemble du AssetBundle oscille, mais nous avons juste besoin qu'il ne le soit pas. Par conséquent, nous téléchargeons d'abord uniquement le fichier manifeste depuis le serveur, prenons hash128 de celui-ci, et seulement ensuite, si nécessaire, téléchargeons le fichier de bundle, et la valeur hash128 doit être extraite via l'interprétation des lignes.

Travailler avec des ressources en mode éditeur

Le dernier problème, ou plutôt la question du débogage et de la commodité du développement, est de travailler avec des ressources téléchargeables en mode éditeur, s'il n'y a pas de problèmes avec les fichiers normaux, alors les choses ne sont pas si simples avec les bundles. Bien sûr, vous pouvez construire leur build à chaque fois, le télécharger sur le serveur et lancer l'application dans l'éditeur Unity et regarder comment tout fonctionne, mais même cette description ressemble à une "béquille". Quelque chose doit être fait avec cela et pour cela la classe AssetDatabase nous aidera.

Afin d'unifier le travail avec les bundles, j'ai créé un wrapper spécial:

 public class AssetBundleWrapper { private readonly AssetBundle _assetBundle; public AssetBundleWrapper(AssetBundle assetBundle) { _assetBundle = assetBundle; } } 

Maintenant, nous devons ajouter deux modes de travail avec les actifs, selon que nous sommes dans l'éditeur ou dans la build. Pour la construction, nous utilisons des wrappers sur les fonctions de la classe AssetBundle , et pour l'éditeur, nous utilisons la classe AssetDatabase mentionnée ci-dessus.


Remarque : le code utilise la classe TaskManager , il sera discuté ci-dessous, en bref, c'est un wrapper pour travailler avec Coroutine .

En plus de ce qui précède, il est également utile pendant le développement de regarder ce que nous avons téléchargé et ce qui est actuellement dans le cache. À cette fin, vous pouvez profiter de la possibilité de définir votre propre dossier, qui sera utilisé pour la mise en cache (vous pouvez également écrire du texte téléchargé et d'autres fichiers dans le même dossier):

 #if UNITY_EDITOR var path = Path.Combine(Directory.GetParent(Application.dataPath).FullName, "_EditorCache"); #else var path = Path.Combine(Application.persistentDataPath, "_AppCache"); #endif Caching.currentCacheForWriting = Caching.AddCache(path); 

Nous écrivons un gestionnaire de requêtes réseau ou travaillons avec un serveur web

Ci-dessus, nous avons examiné les principaux aspects du travail avec des ressources externes dans Unity, maintenant je voudrais m'attarder sur la mise en œuvre de l'API, qui généralise et unifie tout ce qui précède. Et d'abord, attardons-nous sur le gestionnaire de requêtes réseau.

Remarque : ci-après, nous utilisons le wrapper sur Coroutine sous la forme de la classe TaskManager . J'ai écrit sur ce wrapper dans un autre article .

Obtenons la classe correspondante:

 public class Network { public enum NetworkTypeEnum { None, Mobile, WiFi } public static NetworkTypeEnum NetworkType; private readonly TaskManager _taskManager = new TaskManager(); } 

Le champ statique NetworkType est requis pour que l'application reçoive des informations sur le type de connexion Internet. En principe, cette valeur peut être stockée n'importe où, j'ai décidé que c'était la place dans la classe Network .


Comme vous pouvez le voir dans le code, la méthode de traitement de l'achèvement d'une demande a été modifiée par rapport au code des sections précédentes. Il s'agit de montrer la progression du chargement des données. De plus, toutes les demandes envoyées sont stockées dans une liste afin que, si nécessaire, elles puissent être annulées.


De même, des fonctions sont créées pour la texture, l'audio, le texte, le tableau d'octets.

Vous devez maintenant vous assurer que le serveur envoie des données via la commande Post. Souvent, vous devez transmettre quelque chose au serveur et, en fonction de quoi exactement, obtenir une réponse. Ajoutez les fonctions appropriées.




De même, des méthodes sont ajoutées pour la texture, le fichier audio, le texte, etc.


À ce sujet, notre gestionnaire pour travailler avec les demandes de réseau est terminé. Si nécessaire, chaque sous-système du jeu qui nécessite de travailler avec le serveur peut créer ses propres instances de la classe.

Écrire un gestionnaire de chargement de ressources externes

En plus de la classe décrite ci-dessus, pour travailler pleinement avec des données externes, nous avons besoin d'un gestionnaire distinct qui non seulement téléchargera les données, mais informera également l'application du début du chargement, de l'achèvement, de la progression, du manque d'espace libre et traitera également les problèmes de mise en cache.


Comme vous pouvez le voir, le concepteur définit le dossier pour la mise en cache, selon que nous soyons dans l'éditeur ou non. De plus, nous avons configuré un champ privé pour une instance de la classe Network, que nous avons décrite précédemment.

Nous allons maintenant ajouter des fonctions auxiliaires pour travailler avec le cache, ainsi que pour déterminer la taille du fichier téléchargé et vérifier l'espace libre pour celui-ci. Plus loin et plus bas, le code est donné sur un exemple de travail avec AssetBundle, pour le reste des ressources tout se fait par analogie.



Alors, que se passe-t-il dans cette fonction:

• La directive de précompilation DONT_USE_SERVER_IN_EDITOR est utilisée pour désactiver le chargement réel des bundles depuis le serveur.
• La première étape consiste à faire une demande au serveur pour obtenir le fichier manifeste du bundle
• - , , - ( _externalResourcesStorage ) , , ( , ), , null
• , Caching , , ( )
• , , , , - ( ). , ( )

: -. , , , - , , .

/ : GetJson, GetTexture, GetText, GetAudio ..


Ici, il vaut la peine de comprendre la particularité du TaskManager , qui est utilisé dans le gestionnaire de requêtes réseau, par défaut, il fonctionne, effectuant toutes les tâches à tour de rôle. Par conséquent, le téléchargement des fichiers se fera en conséquence.

Remarque : pour ceux qui n'aiment pas Coroutine , tout peut être facilement traduit en async / wait , mais dans ce cas, dans l'article, j'ai décidé d'utiliser une option plus compréhensible pour les débutants (comme il me semble).

Conclusion

. , . , ( f2p ), , , , , .

, :
assetstore.unity.com/packages/tools/simple-disk-utils-59382
habr.com/post/352296
habr.com/post/282524