Accélérez les flux de travail de vos programmeurs

Nous avons récemment publié deux articles de blog, Cinq façons d'accélérer vos flux de travail dans l'éditeur et Accélérez vos flux de travail d'artiste, tous deux basés sur notre e-book pour les développeurs professionnels, 70+ astuces pour augmenter votre productivité avec Unity 2020 LTS. Dans ce troisième et dernier article de blog de la série, nous nous concentrons sur les flux de travail et les fonctionnalités qui aident les programmeurs à faire plus en moins de temps. Commençons par la façon dont vous pouvez économiser du temps de compilation lors des tests de jeu.

Lorsque vous passez en mode lecture, votre projet commence à s'exécuter comme il le ferait dans une compilation. Toutes les modifications apportées dans l'éditeur pendant le mode lecture seront réinitialisées lorsque vous quitterez le mode lecture.

Chaque fois que vous entrez en mode lecture dans l'éditeur, Unity effectue deux actions importantes :

• Rechargement du domaine : Unity sauvegarde, décharge et recrée les états des scripts.
• Rechargement de la scène : Unity détruit la scène et la charge à nouveau.

Ces deux actions prennent de plus en plus de temps au fur et à mesure que vos scripts et vos scènes deviennent plus complexes.

Si vous n'avez pas l'intention d'apporter d'autres modifications au script, tirez parti des paramètres d'entrée en mode lecture (Édition > Paramètres du projet > Éditeur) pour gagner du temps lors de la compilation. Unity vous donne la possibilité de désactiver le rechargement du domaine, le rechargement de la scène ou les deux. Cela peut accélérer l'entrée et la sortie du mode lecture.

N'oubliez pas que si vous envisagez d'apporter d'autres modifications au script, vous devez réactiver le rechargement du domaine. De même, si vous modifiez la hiérarchie de la scène, vous devez réactiver le rechargement de la scène. Dans le cas contraire, des comportements inattendus peuvent survenir.

Un assemblage est une bibliothèque de code C#, un ensemble de types et de ressources construits pour fonctionner ensemble et former une unité logique de fonctionnalité. Par défaut, Unity compile presque tous vos scripts de jeu dans l'assemblage prédéfini, Assembly-CSharp.dll. Cette méthode fonctionne bien pour les petits projets, mais elle présente quelques inconvénients :

• Chaque fois que vous modifiez un script, Unity recompile tous les autres scripts.
• Un script peut accéder à des types définis dans n'importe quel autre script.
• Tous les scripts sont compilés pour toutes les plateformes.

L'organisation de vos scripts en assemblages personnalisés favorise la modularité et la réutilisation. Il les empêche d'être ajoutés automatiquement aux assemblages par défaut et limite les scripts auxquels ils peuvent accéder.

Vous pouvez diviser votre code en plusieurs assemblages, comme le montre le diagramme ci-dessus. Ici, toute modification du code dans Main ne peut pas affecter le code dans Stuff. De même, comme Library ne dépend d'aucun autre assemblage, vous pouvez facilement réutiliser le code de Library dans n'importe quel autre projet.

Assemblies in .NET contient des informations générales sur les assemblages en C#. Reportez-vous à la section Définitions d'assemblages dans la documentation Unity pour plus d'informations sur la définition de vos propres assemblages dans Unity.

Vous arrive-t-il de répéter les mêmes changements lorsque vous créez un nouveau script ? Vous ajoutez instinctivement un espace de noms ou vous supprimez la fonction d'événement de mise à jour ? Économisez quelques frappes et créez une cohérence au sein de l'équipe en configurant le modèle de script à votre point de départ préféré.

Chaque fois que vous créez un nouveau script ou shader, Unity utilise un modèle stocké dans le fichier

%EDITOR_PATH%\Data\ResourcesScript\Templates:

• Fenêtres : C:\Program Files\Unity\Editor\Data\Resources\ScriptTemplates
• Mac : /Applications/Hub/Editor/[version]/Unity/Unity.app/Contents/Resources/ScriptTemplates

Le modèle MonoBehaviour par défaut est celui-ci :

81-C# Script-NewBehaviourScript.cs.txt

Il existe également des modèles pour les shaders, d'autres scripts de comportement et des définitions d'assemblages.

Pour les modèles de script spécifiques à un projet, créez un dossier Assets/ScriptTemplates, puis copiez les modèles de script dans ce dossier pour remplacer les valeurs par défaut.

Vous pouvez également modifier directement les modèles de script par défaut pour tous les projets, mais veillez à sauvegarder les originaux avant d'effectuer toute modification.

Le fichier 81-C# Script-NewBehaviourScript.cs.txt original se présente comme suit :

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

#ROOTNAMESPACEBEGIN#
public class #SCRIPTNAME# : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        #NOTRIM#
    }

    // Update is called once per frame
    void Update()
    {
        #NOTRIM#
    }
}
#ROOTNAMESPACEEND#

Il est utile de garder ces deux mots-clés à l'esprit :

• #SCRIPTNAME# indique le nom de fichier saisi ou le nom de fichier par défaut (par exemple, NewBehaviourScript).
• #NOTRIM# garantit que les crochets contiennent une ligne d'espacement.

Relancez l'éditeur Unity, et vos modifications devraient apparaître chaque fois que vous créez un MonoBehaviour personnalisé.

Vous pouvez également modifier les autres modèles de la même manière. N'oubliez pas de conserver une copie de l'original, ainsi que des modifications, en dehors du projet Unity.

Unity dispose d'une variété d'attributs qui peuvent être placés au-dessus d'une classe, d'une propriété ou d'une fonction pour indiquer un comportement particulier. En C#, les noms d'attributs sont placés entre crochets.

Voici quelques attributs courants que vous pouvez ajouter à vos scripts :

Il ne s'agit là que d'un petit échantillon des nombreux attributs avec lesquels vous pouvez travailler. Vous souhaitezrenommer vos variables sans perdre leurs valeurs? Ou invoquer une certaine logique sans un GameObjects vide? Consultez la liste complète des attributs de l'API de création de scripts pour voir ce qu'il est possible de faire.

Vous pouvez même créer vos propres PropertyAttribute pour définir des attributs personnalisés pour vos variables de script.

L'une des fonctionnalités les plus puissantes d'Unity est son éditeur extensible. Utilisez la UI Toolkit ou le paquet IMGUI pour créer des interfaces utilisateur d'éditeur, telles que des fenêtres et des inspecteurs personnalisés.

UI Toolkit a un flux de travail similaire à celui du développement web standard. Utilisez son langage de balisage inspiré de HTML et XML, UXML, pour définir des interfaces utilisateur et des modèles d'interface réutilisables. Appliquez ensuite les feuilles de style Unity (USS) pour modifier le style visuel et les comportements de vos interfaces utilisateur.

Vous pouvez également utiliser le mode immédiat, IMGUI, comme indiqué ci-dessus. Dérivez d'abord de la classe de base Editor, puis utilisez l'attribut CustomEditor.

L'une ou l'autre solution permet de créer un inspecteur personnalisé.

Un éditeur personnalisé modifie la façon dont le script MyPlayer apparaît dans l'inspecteur :

Consultez la section Création d'interfaces utilisateur (IU) pour en savoir plus sur la manière de mettre en œuvre des scripts d'éditeur personnalisés à l'aide d'UI Toolkit ou d'IMGUI. Pour une introduction rapide à UI Toolkit, regardez le tutoriel " Getting started with Editor scripting".

Le système d'actifs Addressables simplifie la gestion des actifs qui composent votre jeu. Tout élément, y compris les scènes, les préfabriqués, les éléments de texte, etc., peut être marqué comme "adressable" et recevoir un nom unique. Vous pouvez appeler cet alias de n'importe où.

L'ajout de ce niveau d'abstraction supplémentaire entre le jeu et ses ressources peut rationaliser certaines tâches, telles que la création d'un pack de contenu téléchargeable distinct. Ce système facilite également le référencement de ces packs d'actifs, qu'ils soient locaux ou distants.

Pour commencer, installez le paquet Addressables à partir du gestionnaire de paquets et ajoutez quelques paramètres de base au projet. Chaque bien ou préfabriqué du projet doit avoir la possibilité d'être rendu "Addressables". Cochez l'option située sous le nom d'un actif dans l'inspecteur pour lui attribuer une adresse unique par défaut.

Une fois marqués, les actifs correspondants apparaissent dans la fenêtre Fenêtre > Gestion des actifs > Addressables > Groupes.

Pour plus de commodité, vous pouvez soit renommer chaque adresse dans le champ Addressables individuel de l'actif, soit les simplifier toutes en même temps.

Regroupez ces ressources pour les héberger sur un autre serveur ou les distribuer localement au sein de votre projet. Quel que soit l'endroit où se trouve chaque bien, le système peut le localiser à l'aide de la chaîne de noms Addressables.

Vous pouvez désormais utiliser vos actifs Addressables via l'API Addressables.

Il est intéressant de noter que, sans Addressables, vous devriez effectuer les opérations suivantes pour instancier un préfabriqué dans votre scène :

public GameObject prefabToCreate;

public void CreatePrefab() 
{
    GameObject.Instantiate(prefabToCreate);
}
view rawgistfile1.txt hosted with ❤ by GitHub

L'inconvénient est que tout préfabriqué référencé (comme prefabToCreate) sera chargé en mémoire, même si la scène n'en a pas besoin.

Si vous utilisez des Addressables, procédez plutôt comme suit :

public string prefabByAddress;
… 
public void CreatePrefabWithAddress() 
{
    Addressables.Instantiate(prefabByAddress, instantiationParameters, bool);
}

Cela permet de charger l'élément par sa chaîne d'adresse, ce qui signifie que le préfabriqué n'est pas chargé en mémoire tant qu'il n'est pas nécessaire (lorsque nous invoquons Adressables.Instantiate à l'intérieur de CreatedPrefabWithAddress). En outre, vous pouvez utiliser Addressables pour un comptage de référence de haut niveau, afin de décharger automatiquement les paquets et leurs actifs associés lorsqu'ils ne sont plus utilisés.

Histoires des tranchées de l'optimisation : Économiser de la mémoire avec Addressables montre un exemple de la manière dont vous pouvez organiser vos groupes d'Addressables de manière à ce qu'ils soient plus efficaces en termes de mémoire. Entre-temps, le site Addressables : Introduction aux concepts Le didacticiel offre un aperçu rapide de la manière dont le système d'actifs Addressables peut fonctionner dans votre projet.

Si vous gérez un jeu en direct, alors vous pourriez envisager d'utiliser la solution Cloud Content Delivery (CCD) d'Unity avec Addressables. Le système Addressables stocke et catalogue les ressources du jeu afin qu'elles puissent être localisées et appelées automatiquement. Le CCD transmet ensuite ces ressources directement à vos lecteurs, sans aucun lien avec votre code. Cela permet de réduire la taille de votre version et d'éviter à vos joueurs de devoir télécharger et installer de nouvelles versions du jeu à chaque fois que vous effectuez une mise à jour. Pour en savoir plus, lisez ce blog sur l'intégration entre Addressables et Cloud Content Delivery.

La fonction de compilation en fonction de la plate-forme vous permet de partitionner vos scripts afin de compiler et d'exécuter le code pour une plate-forme spécifique.

Cet exemple utilise les directives #define de la plate-forme avec la directive #if du compilateur :

using UnityEngine;
using System.Collections;

public class PlatformDefines : MonoBehaviour 
{
  void Start () 
  {
    #if UNITY_EDITOR
      Debug.Log("Unity Editor");
    #endif

    #if UNITY_IOS
      Debug.Log("Iphone");
    #endif

    #if UNITY_STANDALONE_OSX
      Debug.Log("Stand Alone OSX");
    #endif

    #if UNITY_STANDALONE_WIN
      Debug.Log("Stand Alone Windows");
    #endif

  }          
}

Utilisez l'option #define DEVELOPMENT_BUILD pour déterminer si votre script s'exécute dans un lecteur qui a été construit avec l'option Development Build.

Vous pouvez compiler sélectivement pour des versions particulières d'Unity et/ou des backends de script, et même fournir vos propres directives #define personnalisées lorsque vous testez dans l'éditeur. Ouvrez le panneau Autres paramètres, qui fait partie des paramètres du lecteur, et naviguez jusqu'à Scripting Define Symbols.

Reportez-vous à la section Compilation en fonction de la plate-forme pour plus d'informations sur les directives de préprocesseur d'Unity.

Un ScriptableObject est un conteneur de données qui enregistre de grandes quantités de données, séparément des instances de classe. Les ScriptableObjects évitent de copier les valeurs, ce qui peut réduire l'utilisation de la mémoire de votre projet. Consultez le livre électronique complet pour obtenir des exemples d'utilisation de ScriptableObjects. Sinon, consultez la documentation ScriptableObject pour plus de détails sur l'utilisation des ScriptableObjects dans votre application.

Vous en voulez encore plus ? Regardez Better data with ScriptablesObjects in Unity pour une introduction rapide, et voyez comment ils peuvent aider à la gestion des scènes dans Achieve better Scene workflow with ScriptableObjects.

Conseil d'optimisation

Nous recommandons les formats de sérialisation binaires tels que MessagePack ou Protocol Buffers pour les données sauvegardées, plutôt que les formats basés sur le texte, tels que JSON ou XML. Dans les revues de projet, ces formats de sérialisation binaires réduisent les problèmes de mémoire et de performance associés à ces derniers.

Unity prend en charge les environnements de développement intégrés(IDE) suivants :

• Visual Studio: IDE par défaut sur Windows et macOS
• Visual Studio Code: Windows, macOS, Linux
• JetBrains Rider: Windows, macOS, Linux

Les intégrations IDE pour ces trois environnements apparaissent sous forme de paquets dans le gestionnaire de paquets.

Lorsque vous installez Unity sur Windows et macOS, Visual Studio est installé par défaut. Si vous souhaitez utiliser un autre IDE, recherchez simplement l'éditeur dans Unity > Préférences > Outils externes > Editeur de script externe.

Rider est construit au-dessus de ReSharper et inclut la plupart de ses fonctionnalités. Il prend en charge le débogage C# sur le runtime de script .NET 4.6 dans Unity (C# 8.0). Pour plus d'informations, consultez la documentation de JetBrains sur Rider pour Unity.

VS Code est un éditeur de code gratuit et rationalisé qui prend en charge le débogage, l'exécution de tâches et le contrôle de version. Notez que Unity nécessite Mono (macOS et Linux), Visual Studio Code C# et Visual Studio Code Debugger for Unity (non officiellement pris en charge) lorsque vous utilisez VS Code.

Chaque IDE a ses propres mérites. Pour plus d'informations sur le choix d'un environnement de développement intégré (IDE) adapté à vos besoins, reportez-vous à la rubrique Prise en charge de l'environnement de développement intégré (IDE).

Jetez un coup d'œil à l'e-book pour obtenir une liste de raccourcis qui peuvent être utiles à votre projet, et regardez les conseils et astuces de Visual Studio pour stimuler votre productivité afin d'améliorer davantage le flux de travail avec Visual Studio.

Vous souhaitez découvrir JetBrains Rider ? Consultez la page Fast C# scripting in Unity with JetBrains Rider, ou ces conseils sur l'utilisation de JetBrains Rider en tant qu'éditeur de code.

Le débogueur Unity vous permet de déboguer votre code C# pendant que l'entité Unity est en mode lecture. Vous pouvez attacher des points d'arrêt dans l'éditeur de code pour inspecter l'état du code de votre script et de ses variables actuelles au moment de l'exécution.

Allez en bas à droite de la barre d'état de l'éditeur Unity pour régler le mode d'optimisation du code sur Debug. Vous pouvez également changer ce mode au démarrage dans Edit > Preferences > General > Code Optimization On Startup (Édition > Préférences > Général > Optimisation du code au démarrage).

Dans l'éditeur de code, placez un point d'arrêt à l'endroit où vous souhaitez que le débogueur interrompe l'exécution. Il vous suffit de cliquer sur la marge gauche/la gouttière à l'endroit où vous souhaitez basculer un point d'arrêt (ou de cliquer avec le bouton droit de la souris pour afficher le menu contextuel proposant d'autres options). Un cercle rouge apparaît à côté du numéro de la ligne mise en évidence (voir l'image ci-dessous).

Sélectionnez Attacher à Unity dans votre éditeur de code, puis exécutez le projet dans l'éditeur Unity.

En mode lecture, l'application se met en pause au point d'arrêt, ce qui vous donne le temps d'inspecter les variables et d'étudier tout comportement non intentionnel.

Comme indiqué ci-dessus, vous pouvez inspecter les variables lors du débogage en observant la liste se construire, étape par étape, au cours de l'exécution.

Utilisez les contrôles Continuer l'exécution, Passer par-dessus, Entrer et Sortir pour naviguer dans le flux de contrôle.

Appuyez sur Stop pour arrêter le débogage et reprendre l'exécution dans l'éditeur.

Vous pouvez également déboguer le code d'un script dans un lecteur Unity. Assurez-vous simplement que les options Development Build et Script Debugging sont toutes deux activées dans File > Build Settings avant de créer le lecteur. Cochez Wait for Managed Debugger pour attendre le Debugger avant que le lecteur n'exécute un code de script. Pour attacher l'éditeur de code au lecteur Unity, sélectionnez l'adresse IP (ou le nom de la machine) et le port de votre lecteur. Procédez ensuite normalement dans Visual Studio avec l'option Attach To Unity.

Unity fournit une classe Debug pour vous aider à visualiser les informations dans l'éditeur pendant qu'il s'exécute. Apprenez à imprimer des messages ou des avertissements dans la fenêtre de la console, à tracer des lignes de visualisation dans les vues Scène et Jeu, et à mettre en pause le mode Lecture dans l'Éditeur à partir d'un script. Voici quelques conseils supplémentaires pour vous aider à démarrer :

1. Interrompez l'exécution avec Debug.Break. Cette fonction est utile pour vérifier certaines valeurs dans l'inspecteur lorsque l'application est difficile à mettre en pause manuellement.

2. Vous devez être familier avec Debug.Log, Debug.LogWarninget Debug.LogError pour l'impression des messages de la console. Il est également possible d'utiliser Debug.Assertqui affirme une condition et enregistre une erreur en cas d'échec. Notez toutefois que cela ne fonctionne que si le symbole UNITY_ASSERTIONS est défini. Consigner les messages, les avertissements et les erreurs dans la console.

3. Lorsque vous utilisez Debug.Logvous pouvez transmettre un objet en tant que contexte. Si vous cliquez sur le message dans la console, Unity mettra en évidence le GameObject dans la fenêtre Hiérarchie.

4. Utilisez le texte enrichi pour marquer votre Debug.Log de l'entreprise. Cela peut vous aider à améliorer les rapports d'erreur dans la console.

5. Unity ne supprime pas automatiquement le champ Debug des API de journalisation dans les versions qui ne sont pas des versions de développement. Enveloppez vos appels au journal de débogage dans des méthodes personnalisées et décorez-les avec l'attribut [Conditional]. Pour compiler les journaux de débogage en une seule fois, supprimez le symbole Scripting Define correspondant dans les paramètres du lecteur. Cela revient à les envelopper dans des blocs de préprocesseur #if... #endif. Consultez le guide des optimisations générales pour plus de détails.

6. Comment résoudre les problèmes de physique ? Debug.DrawLine et Debug.DrawRay peuvent vous aider à visualiser la diffusion de rayons.

1. Si vous souhaitez que le code s'exécute uniquement lorsque la fonction Development Build est activée, vérifiez si la fonction Debug.isDebugBuild retourne vrai.

2. Utilisez Application.SetStackTraceLogTypeou les cases à cocher équivalentes dans les paramètres du lecteur, pour décider quel type de message de journal doit inclure les traces de pile. Les traces de pile peuvent être utiles, mais elles sont lentes et génèrent des déchets.

Par défaut, l'entrée du journal de la console affiche deux lignes. Pour une meilleure lisibilité, vous pouvez les réduire à une seule ligne. Voyez comment ci-dessous.

Vous pouvez également utiliser plus de lignes pour les entrées plus longues.

Lors de la compilation d'Unity, l'icône dans le coin inférieur droit peut être difficile à voir. Utilisez ce script personnalisé de l'éditeur pour appeler EditorApplication.isCompiling. Cela crée une fenêtre flottante pour rendre l'état du compilateur plus visible.

Lancez l'élément de menu pour initialiser la fenêtre. Vous pouvez même modifier son apparence avec un nouveau GUIStyle pour l'adapter à vos préférences.

using UnityEditor;
using UnityEngine;

public class CustomCompileWindow : EditorWindow
{
    [MenuItem("Examples/CustomCompileWindow")]
    static void Init()
    {
        EditorWindow window = GetWindowWithRect(typeof(CustomCompileWindow), new Rect(0, 0, 200, 200));
        window.Show();
    }
   void OnGUI()
    {
        EditorGUILayout.LabelField("Compiling:", EditorApplication.isCompiling ? "Yes" : "No");
       this.Repaint();
    }
}

Unity s'intègre à deux systèmes de contrôle de version (VCS) : Perforce et Plastic SCM. Pour définir les serveurs Perforce ou Plastic SCM pour votre projet Unity, allez dans Paramètres du projet > Éditeur. Configurez le serveur (et vos identifiants pour Perforce) sous Version Control.

Les équipes sur Unity peuvent utiliser gratuitement Plastic SCM Cloud Edition, pour un maximum de 5 Go de stockage et un maximum de trois utilisateurs. En utilisant Plastic SCM pour Unity, vous pouvez synchroniser vos changements avec le travail de vos coéquipiers et consulter l'historique de votre projet sans jamais quitter Unity. Lisez ici les dernières mises à jour de Plastic SCM.

Vous pouvez également utiliser un système externe, tel que Git, y compris Git LFS (Large File Support) pour un contrôle de version plus efficace des ressources plus volumineuses, telles que les ressources graphiques et sonores. Pour travailler plus facilement avec le service d'hébergement GitHub, installez le plug-in GitHub pour Unity. Cette extension open source vous permet de consulter l'historique de votre projet, d'expérimenter dans les branches, de livrer vos modifications et de pousser votre code sur GitHub, le tout dans Unity.

Unity maintient un fichier .gitignore. Cela peut vous aider à décider ce qui doit ou ne doit pas aller dans le dépôt Git, puis à appliquer ces règles.

Unity Teams est une autre option pour rationaliser vos flux de travail, car il vous permet de stocker l'ensemble de votre projet dans le cloud. Cela signifie qu'il est sauvegardé et accessible partout, ce qui facilite grandement l'enregistrement, le partage et la synchronisation de vos projets Unity avec n'importe qui.

Consultez les deux premiers articles de blog de cette série, 5 façons d'accélérer vos flux de travail dans l'éditeur et Accélérez vos flux de travail d'artiste. Vous pouvez également télécharger gratuitement le guide70+ conseils pour augmenter la productivité avec Unity 2020 LTS , qui compile tous les conseils dans un e-book pratique.

Comme toujours, n'hésitez pas à nous faire part de tout autre sujet ou fonctionnalité dont vous aimeriez entendre parler dans les commentaires, et n'hésitez pas à partager vos propres conseils en matière de productivité avec la communauté.