Développez plus rapidement des applications industrielles 3D en temps réel : Conseils essentiels tirés du modèle « Unity Industry Fundamentals »

Des prototypes aux applications de formation, en passant par les Digital Twins, les interfaces homme-machine et les configurateurs de produits, les possibilités d'applications que vous pouvez développer et lancer avec Unity Industry sont pratiquement illimitées.

Vous souhaitez savoir comment votre entreprise peut tirer parti de Unity ? Vous êtes un nouvel abonné ou un développeur Unity Industry expérimenté désireux de perfectionner vos compétences ? Que vous ouvriez l'éditeur pour la première fois ou que vous soyez un développeur chevronné ayant déjà mené à bien plusieurs projets, il est toujours utile d'apprendre à exploiter au mieux les puissantes fonctionnalités de Unity, afin de rendre votre travail quotidien aussi productif et agréable que possible.

Boostez votre productivité grâce à la conversion CAO-3D, à une interface utilisateur intuitive, à une architecture de code optimisée et bien plus encore

Ce guide présente le modèle « Unity Industry Fundamentals », un nouveau modèle d'apprentissage intégré à l'éditeur destiné aux développeurs Unity Industry.

Points clés à retenir des fondamentaux du secteur

À travers une série de tutoriels, le modèle « Unity Industry Fundamentals » vous présente les étapes nécessaires à la mise en œuvre de fonctionnalités clés dans les projets Unity Industry, notamment :

• Comment utiliser la boîte à outils Asset Transformer pour convertir et optimiser des fichiers CAO en ressources 3D prêtes à l'emploi dans un projet industriel en temps réel
• Comment créer une HMI et relier l'interface utilisateur aux données en temps réel
• Comment mettre en place un système de navigation permettant à la fois la navigation automatisée et la navigation manuelle
• Comment configurer des caméras virtuelles pour que les utilisateurs disposent toujours de la vue dont ils ont besoin dans les simulations d'environnements complexes et de grande envergure
• Comment concevoir des scripts C# qui gèrent le comportement des robots, la gestion des états et le flux de données à l'aide de ScriptableObjects afin de maintenir la couche de données découplée

L'objectif de « Industry Fundamentals » est de vous aider à rendre votre expérience de développement avec Unity plus efficace, plus ciblée et plus productive. Les conseils que vous y trouverez s'appliquent à de nombreux types d'applications industrielles 3D en temps réel, notamment les interfaces homme-machine (IHM), les simulations de formation, les Digital Twins et les configurateurs de produits.

Téléchargez le modèle « Principes fondamentaux du secteur »

Avant de commencer, voici la marche à suivre pour trouver et télécharger le modèle, si ce n'est pas déjà fait.

Si vous êtes abonné à Unity Industry :

1. Ouvrez Unity Hub et effectuez la mise à jour vers Unity 6.4

2. Créez un nouveau projet, puis recherchez « Industry Fundamentals », ou rendez-vous dans la catégorie « Apprentissage » et sélectionnez le modèle qui s'y trouve.

Si vous ne disposez pas d'un abonnement Unity Industry :

1. Rendez-vous sur notre page d'essai gratuit et suivez les instructions pour bénéficier d'un essai gratuit.

2. Une fois votre période d'essai lancée, suivez les mêmes étapes que pour les abonnés Industry.

Un modèle que vous pouvez consulter et modifier

Ce modèle comprend quatre tutoriels qui vous guident à travers les processus et les étapes nécessaires à la création d'une application industrielle interactive en 3D. Une fois le projet ouvert dans l'éditeur Unity, vous trouverez la scène terminée, intitulée « Warehouse », dans le dossier « Scenes ». Cette scène représente un entrepôt entièrement aménagé, avec plusieurs robots répartis dans l'espace, prêts à prélever, stocker et déplacer les marchandises.

La scène de démonstration est conçue pour le prototypage rapide ; il suffit de glisser-déposer votre propre modèle 3D dans la scène, d'y ajouter un seul composant, et tout est automatiquement connecté. Votre ressource apparaîtra dans l'interface utilisateur et se comportera immédiatement comme un robot autonome, se déplaçant dans l'environnement et réagissant aux entrées et sorties de l'interface utilisateur.

Ouvrez la vue « Jeu », passez en mode « Jouer » et commencez à interagir dans l'entrepôt simulé via une interface utilisateur qui vous permet de contrôler et de surveiller chacun des robots, en affichant des données en temps réel telles que le niveau de charge de la batterie et l'état de fonctionnement d'un robot. L'interface utilisateur propose une carte miniature qui vous indique où se trouvent actuellement les robots. Vous pouvez également modifier manuellement certains paramètres du robot en passant du mode automatique au mode manuel, et contrôler les mouvements de chaque robot à l'aide des touches WASD. Réglez la vitesse de chaque robot et utilisez le curseur pour allonger ou raccourcir son ARM.

Voyons les principales fonctionnalités de cette simulation d'entrepôt.

À voir : Démarrer

La boîte à outils Asset Transformer : De la CAO aux ressources 3D optimisées

Les logiciels de CAO privilégient la précision mathématique et les détails géométriques dans leurs modèles, tandis que les applications en temps réel doivent trouver un équilibre entre la qualité visuelle et des considérations pratiques liées aux performances, telles qu'un nombre de polygones raisonnable, un échantillonnage efficace des textures et des hiérarchies pouvant faire l'objet d'un culling et d'un traitement par lots.

La Unity Asset Transformer Toolkit, incluse dans la licence Unity Industry, fait le lien entre les données CAO de votre entreprise et vos projets Unity. Il intègre en toute transparence vos données existantes à Unity grâce à des flux de travail automatisés de préparation des données, ce qui vous fait gagner du temps et vous épargne des efforts. Vous pouvez importer n'importe quel type de fichier 3D ou CAO, ce qui vous évite d'avoir à effectuer plusieurs importations ou à recréer le modèle. Vous bénéficiez d'un contrôle total sur la taille et la qualité du maillage, ce qui permet d'optimiser vos données pour garantir des performances optimales sur vos appareils cibles.

Dans l'exemple « Industry Fundamentals », vous découvrirez comment importer un nouvel élément de robot dans Unity. Le modèle de robot, qui repose sur le fichier CAO d'origine, est un fichier volumineux dont l'aspect brut ne se prête pas à une présentation soignée. La boîte à outils Asset Transformer sert à convertir et à optimiser les modèles en vue de leur utilisation dans une application 3D interactive adaptée à des plateformes telles que les ordinateurs de bureau et le Web.

Pour savoir comment installer et ouvrir l'Asset Transformer Toolkit dans l'éditeur, regardez la vidéo à la fin de cette section.

Commençons par examiner la barre d'outils.

Découvrez la barre d'outils de la boîte à outils Asset Transformer

Voici une brève présentation des actions disponibles dans la barre d'outils :

• Modèle d'importation : Cliquez ici pour lancer le processus d'importation de vos données CAO dans Unity.
• Maillage et optimisation : Utilisez ces outils pour simplifier la géométrie et supprimer les détails superflus, comme les trous ou les faces internes.
• Remesh : Cette fonctionnalité vous permet de reconstruire entièrement la géométrie pour des cas d'utilisation exigeant des performances élevées.
• Hiérarchie : Utilisez-les pour nettoyer les structures d'objets désordonnées issues des assemblages CAO.
• Transformer : Résolvez rapidement les problèmes liés aux points de pivot et à l'alignement dans le modèle.
• UV et collisionneurs : Utilisez ces paramètres pour générer les données dont Unity a besoin pour le texturage et les interactions basées sur la physique.

Conserver les paramètres et les modifications du modèle lors de l'importation

Ce guide ne traite pas en détail du processus d'importation ; le tutoriel intégré à l'éditeur et la vidéo à la fin de cette section vous guideront à travers toutes les étapes importantes.

Il est important de souligner ici que lorsque vous sélectionnez le fichier que vous souhaitez importer, un ScriptableObject portant le même nom que votre modèle est créé dans le dossier Assets de la fenêtre Projet.

Ce n'est pas le modèle lui-même ; l'avantage ici est que l'objet ScriptableObject contient un ensemble de paramètres que vous pouvez utiliser pour importer le modèle, ce qui vous permet de conserver ses paramètres et ses modifications. Si des modifications sont apportées au modèle CAO et que vous devez le réimporter, vous n'avez pas besoin de tout reconfigurer depuis le début. Tous ces paramètres seront enregistrés dans le ScriptableObject.

Lorsque vous sélectionnez le ScriptableObject et que sa fenêtre d'Inspector s'ouvre, vous verrez en haut le champ « Import Mode », qui peut être réglé sur « Prefab » ou « Scene » :

• Préfabriqué : Pour les objets individuels
• Scène : Pour les éléments très volumineux et détaillés, comme un gratte-ciel comportant des milliers, voire des millions d'objets

L'Inspecteur propose également trois onglets : Modèle, moteur de règles et LOD :

• Modèle : À partir de là, vous pouvez définir les paramètres d'importation du modèle. C'est à cette étape que le modèle source brut est converti en un élément 3D optimisé.
• Moteur de règles : Définissez un ensemble de règles qui vous permet d'automatiser la préparation des données de votre modèle dès l'étape d'ingestion. Les ensembles de règles sont particulièrement utiles lorsque vous devez réimporter votre modèle source au fur et à mesure de son évolution. Reportez-vous à la section suivante pour une présentation du moteur de règles et des ensembles de règles.
• LODs : Ajoutez des règles LOD pour générer des LOD ; celles-ci peuvent être générées directement lors de l'importation du modèle, en tant qu'étape finale.

Une fois vos paramètres définis, cliquez sur « Importer » : le préfabriqué du modèle sera alors ajouté au dossier « Assets > 3DModels » dans la vue Projet. Vous pouvez faire glisser et déposer le modèle dans la vue Scène, ce qui l'ajoute également à la hiérarchie.

À voir : Installez le Unity Asset Transformer Toolkit

Optimiser les ressources 3D

La boîte à outils Asset Transformer fournit des outils permettant de nettoyer les modèles importés afin de les préparer pour un environnement en temps réel, tout en conservant la fidélité visuelle et toutes les métadonnées requises. Cela peut être effectué automatiquement pendant le processus d'importation à l'aide des ensembles de règles mentionnés ci-dessus, ou manuellement après l'importation sous forme d'actions individuelles à l'aide des outils de la barre d'outils d'Asset Transformer.

Réorganiser la hiérarchie

Dans le modèle, si vous suivez les étapes d'importation d'un nouvel élément robot, vous constaterez que sa structure dans la hiérarchie est trop complexe. Cliquez sur l'un des éléments de base, comme le GameObject nommé body_body_main_01-1, et vous verrez dans son Inspector que toutes les métadonnées associées à cette partie sont ajoutées dans un composant. Cependant, son objet enfant contient le filtre de maillage qui affiche la géométrie réelle ainsi que les informations sur le matériau qui lui sont actuellement attribuées.

Il est plus efficace de regrouper toutes ces informations dans un seul objet avec les métadonnées, plutôt que de les séparer.

Pour résoudre ce problème, utilisez l'outil Fusionner. Par défaut, l'outil « Fusionner » est réglé sur « Tout fusionner ». Tu ne devrais pas appliquer cette option, car cela fusionnera tous les éléments en un seul préfabriqué. Vous souhaitez conserver le niveau final de tous les objets. Si vous sélectionnez l'option « Niveau final » dans le menu déroulant, l'outil de fusion parcourra la liste de la hiérarchie pour trouver le dernier objet de chaque arborescence, puis le fusionnera avec celui situé juste au-dessus.

Découvrez les étapes supplémentaires dans cette vidéo.

Décimation

Vous pouvez supprimer les éléments géométriques superflus d'un modèle afin de l'alléger. L'option « Statistiques » de la boîte à outils Asset Transformer affiche les statistiques relatives à un modèle sélectionné ou à une partie de celui-ci. Le modèle CAO que vous allez importer dans ce tutoriel-modèle comporte 510 GameObjects et plus de 600 000 triangles avant optimisation, ce qui en fait un modèle très dense. Regardez cette vidéo pour découvrir comment les trous du nouveau modèle de robot sont éliminés.

Vérifiez la densité du modèle en ouvrant le menu « Débogage » et en sélectionnant l'affichage « Rapport de sommets ». Cela permet de mettre en évidence en rouge les zones où se trouvent des objets extrêmement denses par rapport au reste de la scène. C'est un bon indicateur des cas où l'on peut recourir à la décimation pour optimiser un modèle.

La décimation peut s'avérer fastidieuse si votre modèle contient beaucoup d'éléments géométriques, comme c'est le cas ici. Vous avez donc également la possibilité de procéder à une décimation à grande échelle.

En définissant l'option « Critère » de l'outil de décimation sur « Qualité » et en sélectionnant le niveau supérieur du modèle CAO dans la hiérarchie, vous pouvez choisir un niveau de qualité cible, puis lancer l'outil pour appliquer la décimation à l'ensemble du modèle.

Lorsque cette action a été appliquée au modèle du robot avec un niveau de qualité réglé sur « faible », le nombre de triangles a été réduit de 65 %, pour s'établir désormais à un peu moins de 200 000, ce qui permet une exécution optimisée sur mobile.

Ajuster les normales

L'un des problèmes qui survient souvent avec une optimisation aussi poussée est qu'elle peut nuire à la fluidité d'un modèle. Son aspect et son rendu à la lumière peuvent changer après la décimation : on peut alors soudainement observer des artefacts ou des angles plus marqués qu'auparavant. Vous pouvez résoudre ce problème en ajustant les normales de votre modèle. La boîte à outils Asset Transformer propose plusieurs outils qui vous permettent d'ajuster ou de réinitialiser les normales de votre modèle.

À voir : Optimiser le modèle CAO

Utilisez les ensembles de règles pour gagner du temps lors de la réimportation de ressources

Les modèles CAO font souvent l'objet de nombreuses itérations au cours du processus de conception, et cela peut s'avérer peu efficace si vous devez répéter toutes les étapes ci-dessus à chaque fois que vous réimportez un modèle après y avoir apporté des modifications dans l'application CAO.

Selon où vous en êtes dans le processus de conception et le nombre d'itérations que vous devez effectuer, cela peut s'avérer fastidieux.

C'est là que les ensembles de règles offrent un avantage considérable. Les ensembles de règles, que vous configurez dans le moteur de règles de l'Unity Asset Transformer Toolkit, constituent une séquence d'instructions, appelées « actions », que Unity exécute lors de l'importation ou que vous pouvez appliquer manuellement, et qui automatisent bon nombre des opérations que vous souhaitez généralement effectuer sur un modèle CAO.

Créer un ensemble de règles

Un ensemble de règles est en substance une procédure qui indique à l'Asset Transformer Toolkit de rechercher un ou plusieurs objets spécifiques en fonction de critères donnés, puis d'appliquer l'action que vous avez définie. À titre d'exemple, lorsque vous voyez ce nom de matériau dans le fichier CAO, associez-le à ce matériau Unity. Lorsque vous trouvez des pièces dont le nom suit ce modèle, regroupez-les. Lorsque le nombre de polygones dépasse ce seuil, générez des niveaux de LOD. Ces règles vous permettent d'automatiser des tâches qui, sans cela, seraient fastidieuses à effectuer manuellement.

Le modèle « Industry Fundamentals » comprend plusieurs ensembles de règles prédéfinis dans le dossier « Rule Sets ». Ils méritent qu'on s'y attarde, non seulement pour ce qu'ils font, mais aussi pour la façon dont ils peuvent vous amener à réfléchir à la hiérarchisation des optimisations. Dans le modèle, un ensemble de règles gère le modèle du robot : celui-ci doit présenter un niveau de détail élevé au niveau des articulations du bras, sur lesquelles les utilisateurs concentrent leur attention, mais peut se contenter d'un niveau de détail moindre au niveau de la base, qui est moins visible. Un autre module gère l'environnement de l'entrepôt, où la géométrie est plus simple mais très abondante, ce qui justifie une génération intensive de niveaux de détail (LOD).

Il existe un ensemble de règles qui appliquera automatiquement les opérations de décimation et de nettoyage de la hiérarchie lors de l'importation. Le modèle propose également un autre ensemble de règles qui intègre automatiquement l'occlusion ambiante dans les données de sommets afin d'améliorer la fidélité visuelle du modèle. Enfin, il existe des ensembles de règles qui vous montreront comment remplacer des matériaux et des objets pendant le processus d'importation

Pour créer un ensemble de règles :

1. Dans le dossier du projet, cliquez avec le bouton droit de la souris et sélectionnez Créer > Transformateur de ressources > Jeu de règles.

2. Définissez le nom de votre ensemble de règles.

3. Modifiez l'ensemble de règles à partir de l'onglet dédié (qui s'ouvre automatiquement à côté de l'Inspecteur)

4. Ajoutez des éléments à la séquence, par exemple des filtres, des actions et des règles supplémentaires. Les règles sont appliquées les unes après les autres, de haut en bas.

Si vous regardez l'image ci-dessous, à droite, un ensemble de règles est ouvert. L'action par défaut est « Get ». Cela sélectionnera un objet dans la scène, et toutes les actions suivantes s'appliqueront à cet objet sélectionné.

L'action « Get » sélectionne l'ensemble du modèle de robot, et toutes les actions suivantes s'appliqueront à l'ensemble du modèle. Vous devez donc trouver un moyen d'identifier les éléments spécifiques à l'intérieur de celui-ci auxquels vous souhaitez appliquer les actions suivantes. Pour ce faire, ajoutez une action de filtrage à cette règle et sélectionnez l'option « Filtrer selon les métadonnées » afin d'utiliser les métadonnées importées avec le modèle CAO.

Réimporter efficacement les ressources

Les ensembles de règles tels que ceux ci-dessus peuvent être exécutés manuellement en :

• Sélectionnez le ou les objets auxquels vous souhaitez appliquer
• Sélectionner l'ensemble de règles, puis cliquer sur le bouton « Exécuter »

Vous pouvez toutefois également configurer le système de manière à ce que les ensembles de règles soient appliqués automatiquement lors du processus d'importation. Pour ce faire, sélectionnez l'objet ScriptableObject des paramètres d'importation qui a été créé dans le dossier Assets > 3DModel ; vous verrez alors dans son Inspector que le bouton « Import » s'appelle désormais « Re-import ».

Cliquez sur le bouton « Moteur de règles », puis sélectionnez l'ensemble de règles que vous souhaitez exécuter pendant le processus d'importation.

Si vous cliquez sur le bouton « Réimporter » après avoir configuré cette option, la règle spécifiée sera appliquée au modèle CAO à chaque fois que celui-ci sera réimporté. Vous pouvez également imbriquer plusieurs règles et ensembles de règles au sein de la règle d'importation afin de vous assurer qu'ils soient tous appliqués pendant le processus d'importation.

À voir : Ensembles de règles

À voir : Ensembles de règles avancées

Ajouter un nouveau robot au modèle

Une fois que vous aurez examiné comment importer, optimiser puis automatiser l'ensemble de ce processus, il sera temps de transformer ces données CAO en un robot fonctionnel et piloté par les données dans le cadre d'une simulation.

Ce modèle contient tous les éléments nécessaires pour suivre le processus, y compris des scripts C# permettant de relier votre modèle à l'interface utilisateur et de le configurer de manière à pouvoir passer d'une variante de robot à l'autre, ainsi que de tester le comportement du robot en temps réel.

Examinons l'un des flux de travail décrits dans le modèle.

Il y a plusieurs robots dans l'entrepôt, et vous souhaitez configurer tout nouveau modèle de robot de manière à ce qu'il dispose des mêmes fonctionnalités que les autres. Pour ce faire, vous devrez réimporter le modèle, une opération désormais simple et prévisible grâce à la mise en place de vos ensembles de règles. Voici la marche à suivre :

1. Dans Projet > Modèles 3D, vous trouverez le ressource ScriptableObject d'importation qui contient tous les paramètres configurés précédemment. Ouvrez l'Inspecteur et vérifiez, dans l'onglet « Moteur de règles », que les règles d'importation sont bien configurées.

2. Dans l'onglet Modèle, vérifiez que l'option Importer les métadonnées est sélectionnée. C'est essentiel pour que les filtres et l'ensemble des règles fonctionnent correctement.

3. Une fois le modèle réimporté, vous le trouverez dans Ressources > Modèles 3D ; de là, vous pourrez le glisser-déposer dans la vue Scène.

4. Dans la hiérarchie, vous remarquerez que les robots présents dans la scène sont regroupés sous un GameObject « Robots » parent. Développez cet élément, sélectionnez l'un des objets robots enfants, et vous verrez qu'il est associé à un script Robot via un ScriptableObject « Robot Data », qui contient toutes les informations relatives à chaque robot.

5. Si vous consultez le dossier Assets > Warehouse > RobotData, vous verrez que les quatre robots actuellement présents dans la scène disposent chacun de leur propre objet ScriptableObject RobotDataSO. Vous devrez associer le même ScriptableObject au nouveau robot.

6. Pour ce faire, cliquez avec le bouton droit de la souris dans le dossier « Assets », puis sélectionnez Créer > Modèle d'industrie > Données du robot. Donnez-lui un nom qui corresponde au numéro de modèle du robot.

7. Cliquez sur le nouveau robot que vous venez d'ajouter pour ouvrir son Inspecteur, puis cliquez sur « Ajouter un composant », recherchez le script du robot dans le menu déroulant (intitulé « Robot.cs ») et ajoutez-le.

8. Faites glisser le nouvel objet ScriptableObject du robot dans le champ « Data » du nouveau script ; cela ajoutera automatiquement tous les autres scripts et composants nécessaires pour que ce robot se comporte comme les autres.

Suivez les tutoriels fournis dans le modèle pour découvrir, étape par étape, comment importer vos données CAO dans une application en temps réel afin de créer un Digital Twin, puis configurer les commandes permettant de contrôler les robots via l'interface utilisateur.

À voir : Interface utilisateur et interactivité

Créer un tableau de bord de surveillance avec UI Toolkit

Unity propose deux systèmes pour créer des interfaces utilisateur (UI) : Unity UI (uGUI) et UI Toolkit. Industry Fundamentals utilise UI Toolkit.

UI Toolkit est conçu pour offrir des performances optimales et une grande adaptabilité sur toutes les plateformes, et s'inspire des technologies web standard. Si vous avez de l'expérience dans le développement de pages Web ou d'applications, les concepts fondamentaux de UI Toolkit devraient vous être familiers. UI Toolkit propose des outils et des flux de travail performants qui tirent parti de vos connaissances en matière de langages de balisage et de feuilles de style.

Boîte à outils UI : Inspiré des technologies web courantes

Avec UI Toolkit, vous pouvez dissocier la structure, le style et le comportement de votre interface utilisateur, à l'instar de ce que vous feriez avec HTML, CSS et JavaScript.

UXML est un langage de balisage inspiré du HTML et du XML qui définit la structure de l'interface utilisateur et des modèles réutilisables. Bien qu'il soit possible de créer des interfaces utilisateur en C#, l'utilisation d'UXML permet de travailler sur la mise en page des interfaces utilisateur directement dans la fenêtre UI Builder de Unity, ce qui offre une expérience de création visuelle.

Les feuilles de style CSS permettent d'appliquer des styles visuels et des règles de mise en page à l'interface utilisateur. Tout comme le CSS, l'USS prend en charge un sous-ensemble des propriétés CSS standard. Bien qu'il soit possible de définir des styles en C#, il est recommandé d'utiliser USS, car cela garantit la réutilisation des styles dans toute l'interface utilisateur, ce qui permet d'obtenir une apparence homogène et de simplifier leur gestion.

UI Toolkit prend en charge un système de liaison de données qui vous permet de relier les propriétés des éléments de l'interface utilisateur à des sources de données. Cela signifie que lorsque les données changent, l'interface utilisateur se met automatiquement à jour, et inversement.

Dans cette section, nous allons examiner la conception du tableau de bord et son fonctionnement avec la liaison de données.

Câblage du tableau de bord dans le module « Fondamentaux de l'industrie »

Le tableau de bord comporte plusieurs sections distinctes : des informations générales en haut, une liste des robots à gauche, ainsi que des détails et des commandes à droite. Le fichier USS du tableau de bord définit un système de conception complet, comprenant notamment des variables de couleur et d'espacement, ainsi que des classes pour les éléments récurrents tels que les boutons et les indicateurs d'état.

Chaque robot dispose de trois états : normal, alerte ou critique, qui doivent être représentés visuellement. L'USS distingue trois catégories : « status-standard », « status-warning » et « status-critical », chacune étant associée à une couleur de fond distincte. Un script C# ajoute et supprime ces classes en fonction de l'état du robot. La santé du robot diminue progressivement lorsque le niveau de sa batterie passe en dessous d'un seuil critique ; plus la batterie est faible, plus la perte de santé est rapide. Si l'état de santé ou le niveau de batterie du robot atteint un seuil d'alerte ou critique, les classes d'état sont mises à jour en conséquence, ce qui permet aux opérateurs de disposer d'un signal visuel immédiat sur le tableau de bord.

Dans un projet concret, cette séparation permet aux concepteurs de modifier la couleur des avertissements sans toucher au code, et aux programmeurs d'ajouter de nouveaux types d'état sans avoir besoin de maîtriser le CSS.

Script UIController

Le script UIController assure la cohésion de l'ensemble. Il met en cache les références aux éléments de l'interface utilisateur au démarrage, enregistre les rappels d'événements pour les boutons et les curseurs, s'abonne aux événements du Robot Manager et met à jour l'interface utilisateur lorsque l'état change. Le modèle illustre les deux approches en matière de mise à jour de l'interface utilisateur : la liaison de données pour les valeurs continues, comme le niveau de batterie, et le code explicite pour les événements discrets, comme la sélection d'un robot.

Liaison de données

Au lieu d'écrire du code pour mettre à jour manuellement chaque étiquette et chaque barre de progression, vous déclarez des liaisons dans UXML qui relient les propriétés des éléments de l'interface utilisateur à celles de la source de données. Lorsque les données changent, l'interface utilisateur se met automatiquement à jour.

Le modèle lie directement les éléments de l'interface utilisateur à l'objet scriptable RobotDataSO de chaque robot. Il indique le niveau de charge de la batterie, son état, sa température et sa vitesse. Le fichier UXML définit des liaisons telles que « le texte de cette étiquette doit correspondre à la propriété Battery de cette source de données, exprimée en pourcentage ».

Cette liaison est bidirectionnelle ; par exemple, le curseur de la plage de mouvement de l'ARM ne se contente pas d'afficher une valeur, il la définit également. Lorsque l'utilisateur fait glisser le curseur, la propriété associée est mise à jour, ce qui fait bouger l'ARM du robot. L'interface utilisateur devient une surface de commande, et pas seulement un écran.

Les convertisseurs jouent un rôle essentiel dans la liaison de données, puisqu'ils permettent de combler le fossé entre les types de données et les formats d'affichage. La valeur de la batterie est un nombre float compris entre 0 et 100 dans la source de données, mais vous souhaitez afficher « 75 % » et non « 75,0 ». Le modèle comprend des éléments de conversion qui enregistrent des fonctions de mise en forme. Vous faites appel à ces convertisseurs dans vos liaisons, et ceux-ci transforment les valeurs lors du passage des données à l'affichage.

La mini-carte

La mini-carte illustre le rendu personnalisé au sein de l'UI Toolkit. L'arrière-plan de la mini-carte est une texture de rendu provenant d'une caméra en vue aérienne. Les points de position du robot sont des éléments de l'interface utilisateur placés en fonction de coordonnées mondiales transformées dans l'espace de l'interface utilisateur. À chaque image, le code lit la position dans l'espace de chaque robot, calcule où celle-ci correspond sur l'élément de la mini-carte, puis met à jour la position du point – une technique simple mais efficace pour illustrer les relations spatiales.

À voir : Analyse approfondie de l'interface utilisateur

Configurer la navigation automatique et manuelle

Comment les robots savent-ils où ils peuvent se déplacer ? L'entrepôt regorge d'obstacles – rayonnages, palettes, autres robots – et chaque robot doit trouver des chemins pour les contourner. C'est le rôle du système de navigation IA de Unity.

Si vous ouvrez la scène de l'entrepôt dans l'éditeur, rendez-vous dans la barre d'outils supérieure et cliquez sur le bouton « Toggle Visibility » : le NavMesh apparaîtra alors dans la scène sous la forme d'une superposition bleue. Un NavMesh est un maillage généré par Unity afin d'estimer les zones praticables et les obstacles dans un environnement, dans le cadre de la recherche de chemin et de la navigation contrôlée par l'IA.

La solution la plus performante consiste à intégrer votre NavMesh à la scène au lieu de le générer à l'exécution. Pendant le processus de « baking », le système de navigation analyse votre scène et, en fonction des paramètres que vous avez définis, identifie toutes les zones dans lesquelles les agents (dans ce cas, les robots) peuvent se déplacer.

Dans le modèle, chaque robot connaît son itinéraire car il est équipé d'un composant NavMesh Agent. Il dispose également de quelques préréglages que vous pouvez modifier, par exemple la vitesse, les paramètres d'accélération, le rayon d'évitement et la hauteur.

Bien qu'une grande partie de la logique de déplacement soit gérée par le système NavMesh, on trouve également, dans Assets > Warehouse > Scripts, un script RandomAgentMovement qui permet de définir les destinations cibles. La scène comporte des destinations prédéfinies spécifiques. Lors de son exécution, ce script attribuera l'une de ces destinations à un robot, puis vérifiera en permanence la distance qui le sépare de celle-ci. Si le robot arrive à cette destination, il s'y arrête quelques secondes. Le script attribue ensuite une nouvelle destination ; grâce au NavMesh, le robot détermine automatiquement le chemin optimal vers sa destination et s'y engage.

Une difficulté peut se présenter dans une application où un nombre indéfini d'objets peut être contrôlé manuellement aux côtés d'agents autonomes, tels que des robots. Les robots doivent être capables de détecter les objets en mouvement, comme une porte qui s'ouvre et se ferme ou une caisse qui se déplace. Pour que les robots puissent prendre en compte ces mouvements, ceux-ci doivent être intégrés à la configuration du NavMesh.

Pour gérer cela dans Industry Fundamentals, un composant NavMeshObstacle est ajouté au système NavMesh. Cela indique au NavMesh de délimiter une zone spécifique autour d'un robot. À mesure que le robot se déplace, la zone se déplace avec lui, ce qui empêche les robots de traverser des obstacles tels que des étagères ou d'entrer en collision avec d'autres robots.

Si vous passez en mode manuel pour contrôler les robots, le composant NavMeshObstacle est attribué et activé, tandis que le composant NavMeshAgent est désactivé.

Le passage d'un mode à l'autre s'effectue via l'objet ScriptableObject du robot. La propriété OperationMode peut prendre la valeur « Auto » ou « Manual », et divers composants vérifient cette valeur pour déterminer la marche à suivre. L'interface utilisateur comporte des boutons permettant de basculer entre les modes, ce qui met à jour les données et déclenche une réaction des composants. Grâce à cette approche axée sur les données, l'ajout de nouveaux modes ou la modification de leur comportement ne nécessite pas de modifier plusieurs scripts.

À voir : Guide pratique sur NavMesh

Un système de caméra virtuelle avec Cinemachine

Le modèle « Industry Fundamentals » utilise le système de caméra virtuelle Cinemachine (que vous pouvez télécharger sous forme de package) de trois manières différentes :

• Pour créer la caméra qui suit le robot actif et assurer une transition fluide entre les différents robots lorsque vous sélectionnez différentes cartes
• Pour que la caméra reste braquée sur le robot pendant qu'il se déplace dans l'entrepôt et pour éviter que l'image ne passe à travers les objets
• Pour intégrer directement la vue 3D à l'interface utilisateur du tableau de bord

Le principe de base est simple : Votre scène contient un GameObject « Unity Camera », géré par un composant « Cinemachine Brain », ainsi que plusieurs caméras virtuelles qui définissent les plans possibles. Le composant Brain bascule entre les caméras virtuelles en fonction de leurs priorités. Seule la caméra virtuelle activée ayant la priorité la plus élevée détermine ce que vous voyez.

Les caméras dans les principes fondamentaux de l'industrie

Si vous ouvrez la scène de l'entrepôt, vous verrez quelques robots dispersés un peu partout, qui vous fourniront des éléments à utiliser avant d'ajouter votre propre robot. Vous devrez vous assurer que, lorsque vous ajoutez votre propre robot à la scène, une caméra virtuelle lui est également attribuée.

Dans la hiérarchie, recherchez le GameObject « Cinemachine Shots » qui fournit un plan par défaut.

Lorsque vous cliquez sur « Lecture », chaque robot disposera de sa propre caméra « suiveuse », ajoutée par un script au moment de l'exécution. Ce script récupère la liste du nombre de robots présents dans la scène, y compris les nouveaux ajoutés, et pour chacun d'entre eux, il crée un composant « Cinemachine Camera » ainsi qu'un composant « Third-Person Follow ». Le composant « Suivi à la troisième personne » vous permet de créer une caméra qui se place derrière l'objet en mouvement et qui suivra ensuite l'objet désigné comme cible de suivi.

Pour l'interface utilisateur du tableau de bord, Cinemachine est implémenté de deux manières différentes : Une caméra 3D pour afficher la caméra actuellement utilisée, et une autre pour la mini-carte. La mini-carte utilise une texture de rendu avec une caméra distincte qui effectue le rendu de la vue depuis le haut, puis transmet cette vue à la texture de rendu. La caméra 3D n'utilise pas de texture, mais affiche la vue de la caméra réelle de l'application en cours d'exécution, à travers une découpe rectangulaire dans l'interface utilisateur.

Cinemachine vous permet de créer des systèmes de caméras flexibles dans lesquels le « cerveau » de Cinemachine se charge de toute la logique de basculement entre ces différentes caméras, en créant des caméras virtuelles qui servent de repères de position pour la caméra principale réelle. Enfin, il propose des fonctionnalités supplémentaires, comme la caméra de suivi à la troisième personne, qui se charge d'une grande partie du travail fastidieux généralement associé au développement d'une application en temps réel.

À voir : Guide de Cinemachine

Optimisez l'éclairage grâce au pipeline de rendu universel

Le Universal Render Pipeline (URP) est la solution proposée par Unity pour un rendu évolutif. Il est conçu pour offrir un rendu graphique de haute qualité tout en fonctionnant efficacement sur tous les types d'appareils, des ordinateurs de bureau haut de gamme aux appareils mobiles en passant par les navigateurs Web. Dans le domaine industriel, cette flexibilité est essentielle. Vous pourriez avoir besoin que cette même application fonctionne à la fois comme écran interactif lors d'un salon professionnel, comme application web pour les clients à distance et comme application pour tablette destinée aux techniciens de terrain.

La configuration URP du modèle se trouve dans le dossier « Settings ». L'élément « Render Pipeline » permet de contrôler les paramètres généraux de rendu. Comprendre le rôle de ces paramètres vous aidera à effectuer des ajustements judicieux pour vos propres projets.

Rendu Forward+

Ce modèle utilise le rendu Forward+, qui gère efficacement plusieurs sources lumineuses tout en restant compatible avec une large gamme de matériel. Forward+ fonctionne en regroupant les lumières dans l'espace de l'écran ; ainsi, l'ajout de lumières supplémentaires à votre scène n'affecte pas les performances de la même manière que ce serait le cas avec un rendu direct traditionnel.

L'anticrénelage permet d'adoucir les bords irréguliers qui apparaissent à la jonction entre les éléments géométriques et l'arrière-plan. Le modèle utilise le MSAA à 4x pour le niveau de qualité élevé, à 2x pour le niveau moyen et pas du tout pour le niveau bas. Le MSAA est rapide sur les GPU modernes, mais consomme davantage de mémoire ; l'approche par niveaux vous permet donc d'adapter la configuration en fonction de l'appareil cible.

Utiliser des cascades d'ombres

Les ombres améliorent la qualité visuelle, mais leur traitement peut être très gourmand en ressources informatiques. Ce modèle utilise des ombres en cascade, qui produisent des ombres en haute résolution près de la caméra et des ombres en basse résolution au loin.

Un mélange de lumières intégrées et de sondes lumineuses

L'éclairage dans le modèle repose sur une approche hybride. Les éléments géométriques statiques, tels que le sol, les murs et les rayonnages de l'entrepôt, utilisent un éclairage précalculé. Les objets dynamiques, comme les robots, utilisent des lumières en temps réel et des sondes de lumière.

Les sondes de lumière sont des points invisibles dans votre scène qui permettent d'échantillonner l'éclairage précalculé. Lorsqu'un objet dynamique passe à proximité d'une sonde d'éclairage, il capte l'éclairage ambiant de cet emplacement. Le modèle intègre des capteurs de lumière répartis dans tout l'entrepôt, ce qui permet aux robots de s'intégrer harmonieusement à l'environnement plutôt que de paraître superposés à celui-ci.

Le système LightRig apporte une dimension supplémentaire. Chaque robot est équipé d'un ensemble de projecteurs qui s'allument lorsqu'il est sélectionné. Cela permet de mettre visuellement en avant le robot en action sans avoir recours à un éclairage global coûteux. Cette implémentation est simplement un composant qui active et désactive les lumières en fonction de l'état de sélection.

L'éclairage d'ambiance provient d'une image HDRI qui apporte cette lumière ambiante subtile qui comble les ombres et permet aux surfaces métalliques de refléter la lumière. Le modèle propose plusieurs options HDRI afin que vous puissiez voir comment différents environnements d'éclairage influencent l'ambiance de la scène.

Scripts C#

Examinons les scripts et les ScriptableObjects utilisés dans le modèle.

Comme indiqué dans les sections précédentes, toutes les informations relatives à un robot, telles que ses mouvements, sa structure et la manière dont il communique avec l'interface utilisateur, sont contenues dans un ScriptableObject. Si vous accédez à la vue Projet, puis à Ressources > Entrepôt > RobotData, vous trouverez le ScriptableObject de chaque robot. Ouvrez l'Inspecteur de l'un d'entre eux et vous y trouverez les informations relatives au robot, telles que son nom, son mode de fonctionnement actuel, son état actuel, la variante active, l'état de la batterie, son état de santé, sa température de fonctionnement, sa vitesse, etc. L'objet ScriptableObject n'effectue aucune action de lui-même ; dans ce contexte, il s'agit simplement d'un conteneur qui regroupe toutes les données spécifiques à ce modèle.

Il existe également un ScriptableObject contenant des données sur l'ensemble de la flotte de robots, notamment le niveau moyen de charge des batteries de tous les robots, le nombre de ceux qui sont en mouvement et le nombre de ceux qui se trouvent dans chaque catégorie d'état. Toutes ces informations sont transmises à l'interface utilisateur du tableau de bord.

Les scripts servent à relier toutes ces données aux robots eux-mêmes et à leur conférer des fonctionnalités, par exemple la capacité de se déplacer ou de passer d'une variante à l'autre. Dans le modèle, vous les trouverez dans le dossier « Scripts » de Warehouse. Il existe des scripts permettant de piloter les robots et de relier tous les ScriptableObjects à un modèle réel. Sélectionnez l'une de ces options et vous verrez qu'il existe des scripts « Robot », « Simulator » et « Variant ».

RobotManager

Le script RobotManager active toutes les données au démarrage. Ce script est un singleton ; il n'y en a donc qu'une seule instance dans toute la scène. Au démarrage, l'application détectera tous les robots présents dans la scène, puis les enregistrera dans une liste. Ce script contient deux événements essentiels : ActiveRobotChanged, qui se déclenche chaque fois qu'un utilisateur sélectionne un autre robot, et RobotListChanged, qui se déclenche lorsqu'un robot est ajouté ou supprimé de la liste.

Ce script constitue la colonne vertébrale du système de communication de l'ensemble du projet. En parcourant d'autres scripts, vous verrez que bon nombre d'entre eux s'abonnent à ces événements.

Le script « OverallDataUpdater » s'exécute à chaque image et demande à l'objet scriptable « OverallData » de parcourir les données de chaque robot, d'en additionner les valeurs et de mettre à jour le récapitulatif de la flotte. Ainsi, même si le fichier de données contient toutes les informations, c'est ce script qui permet de le faire fonctionner.

Chaque robot utilise le NavMesh pour déterminer les zones où il peut et ne peut pas se déplacer. Mais ils ont aussi besoin d'un objectif vers lequel tendre, et comme expliqué précédemment, chaque robot peut fonctionner en mode automatique ou manuel. Pour gérer tout cela, le modèle dispose d'un script RobotEditor, accessible via Ressources > Entrepôt > Scripts > Éditeur. Ce script ajoute automatiquement tout ce dont vous avez besoin à un préfabriqué de robot lorsque vous lui attribuez un ScriptableObject.

Le script RandomAgentMovement est actif lorsque les robots sont en mode automatique. Ce script comporte plusieurs cibles. Au démarrage du script, celui-ci en choisit un au hasard et envoie l'agent vers celui-ci. À chaque trame, il vérifie si l'agent est arrivé. Il examine la distance restante, vérifie si le tracé est toujours en cours de calcul et si l'agent a cessé de se déplacer. Une fois ces trois conditions remplies, il attend un laps de temps aléatoire (entre une et trois secondes), puis choisit une nouvelle cible et recommence tout le processus.

Comme vous le verrez dans la simulation, les robots se déplacent dans l'entrepôt et, à chaque destination, ils s'arrêtent un instant comme s'ils s'affairaient à quelque chose, puis font demi-tour et se dirigent vers la cible suivante.

Et, comme vous vous en souvenez peut-être, lorsque vous passez en mode manuel, Robotscript désactive le composant NavMesh Agent et active le composant NavMesh Obstacle avec la fonction « carving » activée. Un robot dont ce composant est activé se déplacera sur le NavMesh et créera un passage dans le NavMesh autour de lui. Lorsqu'un autre robot en mode automatique s'en approche, il ne pourra pas le traverser car il y a une ouverture dans le NavMesh ; il trouvera alors un nouveau chemin pour le contourner. Lorsque vous repassez en mode automatique, cela supprimera ce composant « Nav Mesh Obstacle » et réactivera le NavMeshAgent.

Le script RobotDataSimulator simule ce qui se passerait dans un environnement réel, comme l'épuisement des batteries lorsque les robots se déplacent, les pannes, etc. Ce script enregistre également les mises à jour dans le ScriptableObject, qui indique à son tour au tableau de bord de l'interface utilisateur les informations à afficher.

Enfin, pour chaque modèle, le script « Variant » vous permet de définir les différentes variantes et leur comportement. Lorsque vous cliquez sur le bouton permettant de basculer entre les variantes, ce script activera et désactivera celles qui sont concernées.

À voir : Architecture C# et ScriptableObjects

Optimisations des performances

Les applications industrielles doivent souvent fonctionner correctement sur divers équipements matériels, ce qui implique de réfléchir soigneusement à la manière d'optimiser l'expérience utilisateur. Voici quelques-unes des stratégies utilisées dans ce modèle.

• Gestion de la fréquence des mises à jour : Tout ne doit pas nécessairement se produire à chaque image. Le simulateur de télémétrie se met à jour à chaque image, car les utilisateurs s'attendent à un retour d'information instantané lorsqu'ils conduisent en mode manuel. Les statistiques globales sont mises à jour une fois par seconde, car les moyennes à l'échelle de la flotte ne varient pas de manière significative plus rapidement que cela. Le modèle permet de configurer cela, ce qui vous permet d'ajuster le compromis entre la réactivité et l'utilisation du processeur.
• Mise en cache des requêtes de l'interface utilisateur : La méthode Q de UI Toolkit permet de rechercher des éléments par nom ou par classe, ce qui est pratique mais a un certain coût. Appeler Q à chaque image pour rechercher le même élément est un gaspillage de cycles. Le modèle effectue une requête unique au démarrage, stocke les références dans des champs, puis utilise ces références mises en cache par la suite.
• Optimisation des requêtes NavMesh : Le calcul complet d'un chemin, qui consiste à déterminer le trajet complet entre A et B, est coûteux en ressources, mais la validation d'un seul point est moins gourmande en ressources. Le contrôleur manuel utilise NavMesh.SamplePosition plutôt que CalculatePath, car il lui suffit de savoir si le prochain pas est valide, et non de connaître l'itinéraire dans son intégralité.
• LODs : Le modèle du robot comporte plusieurs niveaux de détail, sélectionnés automatiquement en fonction de la taille de l'écran. En gros plan, vous verrez tous les détails, tandis qu'un robot situé plus loin présente une géométrie simplifiée qui reste toutefois lisible. Les seuils de niveau de détail (LOD) du modèle sont optimisés pour un environnement d'entrepôt ; vous devrez les ajuster en fonction des distances de visionnage habituelles de votre scène.
• Résolution de la texture de rendu : Cela permet de trouver un juste équilibre entre la qualité, la mémoire du GPU et le taux de remplissage. La caméra de sécurité et la mini-carte n'ont pas besoin d'une résolution maximale, elles s'affichent donc avec des textures plus petites. Cela réduit le nombre de pixels que le GPU doit remplir et la mémoire occupée par ces textures.
• Filtrage au niveau de la couche physique : Le modèle place les robots sur un calque « Bot » et configure les paramètres physiques de manière à ce que seules les couches concernées entrent en collision. Les robots entrent en collision avec le sol et entre eux, mais pas avec les cibles de raycast de l'interface utilisateur ni avec d'autres systèmes qui utilisent des colliders à des fins autres que physiques.
• Niveaux de qualité : Le modèle définit trois niveaux avec des paramètres de plus en plus restreints. Au moment de l'exécution, vous détectez les capacités de l'appareil ou définissez les paramètres utilisateur, puis vous appelez QualitySettings.SetQualityLevel pour effectuer le changement. Le pipeline de rendu URP prend en charge les remplacements par niveau, ce qui vous permet de réduire la résolution des ombres sur les appareils bas de gamme sans affecter les appareils haut de gamme.

Enfin, les outils de profilage d'Unity sont indispensables pour identifier les goulots d'étranglement. Effectuez un profilage sur le matériel cible, identifiez les points faibles et optimisez-les spécifiquement, plutôt que de tout optimiser prématurément.

L'écosystème Unity Industry

Unity Industry regroupe les produits et l'assistance nécessaires pour créer, gérer et faire évoluer des applications multiplateformes. Conçue pour les créateurs du secteur, elle couvre toutes les étapes, de l'intégration des données au déploiement.

Rejoignez les plus grandes entreprises des secteurs de l'industrie manufacturière, de l'automobile, de la distribution et bien d'autres encore, qui utilisent la technologie 3D en temps réel pour se démarquer de la concurrence, accélérer la mise sur le marché et optimiser leurs ressources. De la visualisation de produits aux simulations, Unity Industry permet de créer des expériences immersives.

Téléchargez le modèle « Principes fondamentaux du secteur »

Si vous êtes abonné à Unity Industry :

1. Ouvrez Unity Hub et effectuez la mise à jour vers Unity 6.4

2. Créez un nouveau projet, puis recherchez « Industry Fundamentals », ou rendez-vous dans la catégorie « Apprentissage » et sélectionnez le modèle qui s'y trouve.

Si vous ne disposez pas d'un abonnement Unity Industry :

1. Rendez-vous sur notre page d'essai gratuit et suivez les instructions pour bénéficier d'un essai gratuit.

2. Une fois votre période d'essai lancée, suivez les mêmes étapes que pour les abonnés Industry.