Développement d'un jeu avec Unity* et la Caméra 3D Intel® RealSense™

Les jeux possèdent des fonctionnalités que les développeurs de jeux doivent implémenter : les objets du jeu doivent se conformer aux lois de la physique et entrer en collision avec les autres objets du jeu ; un objet du jeu doit déclencher des événements tels que lire un son et compter le score ; et il doit répondre aux entrées effectuées par l'utilisateur avec l'aide d'un joystick, de la souris, et du clavier. Très souvent, les développeurs doivent implémenter à nouveau ces fonctionnalités pour chacune des plateformes ciblées, ce qui peut prendre un temps considérable. Pour faciliter les choses, les développeurs peuvent choisir un moteur de jeu qui inclut des fonctions permettant de réaliser des tâches communes, libérant plus de temps pour se concentrer sur les aspects plus créatifs de leur jeu.

Le moteur de jeu multiplateforme Unity* 3D d'Unity Technologies est une solution intéressante. Ses plateformes cibles sont les ordinateurs, les consoles de jeu, les appareils mobiles, et les navigateurs web. Unity 3D prend également en charge plusieurs langages de programmation tels que le C++, C#, les Script Unity (similaires à JavaScript*), et Boo.

Cet article conviendra à la fois aux débutants et aux experts. Pour ceux qui n'ont jamais travaillé avec Unity auparavant, il y a une courte introduction dans la première partie de l'article. Ensuite, j'explique comment utiliser le suivi de la main avec le SDK Intel® RealSense™ pour développer un petit jeu en C# avec la Caméra 3D Intel RealSense. Pour participer, vous aurez besoin : de Visual Studio et Unity installés sur votre PC, du SDK Intel RealSense, et de la caméra 3D Intel RealSense.

Vous pouvez télécharger Unity gratuitement. Unity fonctionne sur les systèmes d'exploitation Microsoft Windows* et Apple Mac* OS X*. Après l'installation d'Unity, vous devez suivre la procédure d'enregistrement gratuit.

Le code proposé dans cet article se calque sur le langage de programmation C#. L'environnement de développement multiplateforme qu'Unity propose par défaut est MonoDevelop. Si vous développez en .NET, vous serez heureux de constater qu'Unity et Microsoft Visual Studio fonctionnent parfaitement de concert. La première étape est de connecter Unity avec Visual Studio. Pour faire cela, vous devez sélectionner Edit -> Preferences… depuis le menu déroulant. Une boîte de dialogue 'Unity Preferences' s'ouvre alors. Choisissez External Tools sur le côté gauche (Illustration 1). Pour accéder à l'éditeur de script externe, cliquez sur MonoDevelop dans la liste déroulante et trouvez le fichier .exe de Visual Studio en utilisant le bouton Browse…. Si vous avez installé Visual Studio en utilisant les paramètres par défaut, l'emplacement du programme devrait être :

C:\Program Files (x86)\Microsoft Visual Studio 12.0\Common7\IDE\devenv.exe.

Ce sont toutes les étapes nécessaires pour que la connexion fonctionne.

C'est maintenant le bon moment pour configurer certaines fonctionnalités de l'environnement d'Unity. L'écran principal se compose de différentes fenêtres. Pour trouver l'arrangement idéal pour votre utilisation, vous pouvez soit choisir manuellement les paramètres, soit utiliser les paramètres par défaut. Choisissons le paramètre populaire Tall depuis le menu déroulant ‘Layout' en haut à droite.

La première grande fenêtre de scène, accessible par l'onglet ‘Scene' (Illustration 3), est utilisée pour positionner et pour concevoir le monde de votre jeu. La fenêtre standard sert à visualiser le contenu en 3D. Les objets qui composent le jeu peuvent être facilement positionnés avec des glisser-déposer. Vous pouvez voir l'onglet de jeu (‘game') juste au-dessus de l'écran principal. L'onglet de jeu affiche une prévisualisation du rendu du jeu, tel qu'il sera affiché sur la plateforme désirée.

La fenêtre de hiérarchie (‘hierarchy' — Illustration 5) contient les objets de contenu utilisables, par exemple, les objets de jeu, les vues de caméra, les objets de lumière, les éléments d'interface, et l'audio. Les nouveaux objets de contenus sont créés dans le menu en dessous de ‘GameObject' ou directement dans la fenêtre avec ‘Create'.

Lorsqu'un objet de contenu est sélectionné dans la fenêtre hiérarchie, la fenêtre d'inspection (« Inspector ») s'ouvre, et affiche ses propriétés (Illustration 6). Il est possible d'étendre les fonctions en ajoutant des composants qui sont disponibles sur le bouton 'add component'. Un composant possible peut être, par exemple, un corps rigide, qui donne sa gravité à un objet de jeu.

Les fichiers de projets tels que les scènes de jeux, les objets de jeux (GameObjects), les sons, les images, et les scripts sont structurés dans la fenêtre de projet (‘project' — Illustration 7). Lorsque vous sélectionnez un fichier, la fenêtre d'inspection affiche les propriétés le concernant et des informations de prévisualisation. Les fichiers de script appliqués peuvent être directement ouverts dans leur propre environnement de développement en faisant un double-clic sur le nom du fichier.

Au début des années 1970, le fondateur d'Atari, Nolan Bushnell, a publié son célèbre jeu « Pong. » Le principe du jeu est simple, et similaire à celui du tennis de table : une balle fait des allers-retours sur l'écran. Chaque joueur contrôle une raquette verticale. Si un joueur échoue à renvoyer la balle, l'adversaire reçoit un point. Les étapes suivantes montrent comment développer un jeu de ping-pong avec Unity.

En faisant File -> New Project, créez un nouveau projet appelé PingPongUnity.

Tout d'abord, pour ajouter les raquettes, cliquez sur Create -> 3D Object -> Cube dans la fenêtre Hierarchy. Pour changer les propriétés de la forme et de la position des raquettes, vous devez sélectionner le cube généré et changer ses propriétés dans la fenêtre Inspector. Nous allons changer le nom en Raquette1 et personnaliser la forme dans la section ‘Transform'. Les valeurs d'échelle à entrer dans ‘Scale' sont : X : 0.5, Y : 3, Z : 1. Réglez la Position à : X : -9, Y : 1, Z : 0. La première raquette est prête. Faites un clic droit sur la raquette dans la fenêtre de hiérarchie et puis cliquez sur ‘Duplicate' dans le menu contextuel. Cela crée une copie identique de la raquette. Vous n'avez plus qu'à renommer la copie en Raquette2. Puis changez la valeur X de la Position pour 9.

Pour que les raquettes aient un comportement correct d'un point de vue de la physique, nous devons ajouter un composant ‘RigidBody' en cliquant sur le bouton “Add Components” pour chacune des raquettes. Cela nous permet de déplacer les raquettes avec le code, afin de permettre aux raquettes d'entrer en collision avec la balle. Si la balle entre en collision avec une raquette dans l'état actuel des choses, elle sortirait du champ. Ce n'est pas le comportement que nous souhaitons. Pour éviter cela, nous devons régler les propriétés de contraintes de chaque RigidBody ajouté. Les raquettes sont uniquement autorisées à se déplacer vers le haut et vers le bas, donc nous devons sélectionner x, y et z pour bloquer ces rotations (ligne ‘Freeze Rotation') et seulement x pour la ligne ‘Freeze Position'.

Pour réaliser notre ping-pong, nous allons avoir besoin de deux murs, un au-dessus et un en dessous, afin que les balles rebondissent dessus et restent dans la zone de jeu. Pour cela, nous allons à nouveau utiliser un objet cube. Cliquez encore sur Create -> 3D Object -> Cube dans la fenêtre Hierarchy. Son nom sera MurDessous. La forme du mur est ici un peu plus grande et prendra les valeurs scale suivantes : X : 23, Y : 1, Z : 1. La position sera : X : 0, Y : -5, Z : 0.

Pour générer le deuxième mur, il vous suffit de dupliquer de nouveau le mur actuel et de le renommer en MurDessus. Ensuite, changez simplement sa Position Y pour 7.

Le dernier objet du jeu - mais non le moindre - est, bien sûr, la balle. Unity nous propose déjà la forme que nous souhaitons. Il suffit de cliquer sur Create -> 3D Object -> Sphere dans la fenêtre Hierarchy. Changez son nom pour Balle et réglez la Position sur X : 0, Y : 1, Z : 0. Pour ajouter les propriétés physiques adéquates, vous devez ajouter le composant RigidBody en utilisant ‘Add Components' et en désélectionnant la propriété "Use gravity”.

L'affichage de la scène et la fenêtre du jeu rendu ne sont toujours pas parfaits pour notre jeu. Nous allons devoir changer les paramètres de la caméra. Dans la fenêtre Hierarchy, sélectionnez la caméra principale, Main Camera. Ensuite, changez la vue 3D actuelle pour passer à une vue en 2D. Cela est possible dans la section Projection des propriétés de la caméra. Remplacer le paramètre sélectionné Perspective (3D) pour Orthographic (2D). Ainsi, nous avons une perspective avant. Changez également la nouvelle propriété Size et donnez-lui une valeur de 10.

Si la représentation de la fenêtre de scène n'est toujours pas idéale, vous pouvez faire tourner la vue en cliquant sur les axes de coordonnées.

À présent, la caméra est pourvue des paramètres parfaits. Les objets du jeu sont encore un peu sombres. Pour ajouter de la lumière, passez à la fenêtre Hierarchy et ajoutez un éclairage en cliquant sur Create -> Light ->Directional Light. Vous pouvez constater les changements dans la fenêtre Game.

Le terrain est prêt, mais il manque un peu d'action. Si vous lancez le jeu, la balle tombe sur le sol et c'est tout. Nous avons besoin de quelques lignes de code C# pour donner un mouvement à la balle. Pour cela, nous créons un fichier de script C# que nous allons appeler “Ball” en cliquant sur le bouton Create dans la fenêtre Project. Ensuite, nous allons créer un lien entre le fichier de script et l'objet du jeu. Cela peut être réalisé en faisant un glisser-déposer du fichier de script sur l'objet du jeu dans la fenêtre Hierarchy ou dans la fenêtre Scene. Si vous sélectionnez l'objet balle, les propriétés du script sont affichées dans la fenêtre Inspector.

Double-cliquer sur le fichier C# démarre automatiquement l'environnement de développement que vous avez réglé, c'est-à-dire MonoDevelop ou Microsoft Visual Studio. La classe C# ainsi générée commence avec une structure standard. Cela inclut la classe de base MonoBehavior, qui est une interface avec l'API de Unity. La méthode “Start” est utilisée pour l'initialisation et la préparation. Les frameworks de jeu fonctionnent avec plusieurs images par seconde, comme lorsque vous regardez la télévision ou un flip-book. Une image générée est aussi appelée ‘frame'. La méthode “Update” est appelée à chaque fois qu'une telle image va être dessinée. Cette répétition est ce que nous appelons une boucle de jeu, qui signifie que d'autres objets de jeu peuvent agir indépendamment des actions du joueur.

Dans notre jeu, nous voulons déterminer la direction que va emprunter la balle, une fois le jeu lancé. La méthode “Start” semble être parfaite pour cela. Vous pouvez trouver le code requis dans l'Extrait de code 1.

using UnityEngine;

public class Ball : MonoBehaviour
{
   private float _x;
   private float _y;

   // Use this for initialization
   void Start ()
   {
      _x = GetRandomPositionValue();
      _y = GetRandomPositionValue();
       GetComponent<Rigidbody>().velocity = new Vector3(Random.Range(5,10) * _x, Random.Range(5,10) * _y, 0);
       
       Debug.Log("x: " + _x);
       Debug.Log("y: " + _y);
   }

   private float GetRandomPositionValue()
   {
       if (Random.Range(0, 2) == 0)
       {
           return -1;
       }
       return 1;
   }

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

La véritable magie de l'objet de jeu est cachée dans la section des composants. Il existe un composant pour toute logique de jeu imaginable. Le code C# contenu dans l'Extrait de code 1 accède au composant Rigidbody de l'objet de jeu actuel en utilisant la méthode GetComponent. Le composant Rigidbody étend l'objet de jeu avec la fonction de gravité. En assignant la propriété de vélocité, une nouvelle instance Vector3 est assignée. Cela définit la direction aléatoire de la gravité appliquée.

Tester à nouveau le jeu montre que la balle part aléatoirement dans une direction différente. Mais si la balle entre en collision contre un mur, elle glisse le long de l'écran, ce qui ne correspond pas au comportement que nous attendons. Elle devrait ressembler davantage à une balle en caoutchouc qui rebondirait sur les murs.

Pour obtenir ce comportement, ajouter un élément de physique des matériaux convient. Nous créerons donc un ‘Physic Material' en cliquant sur le bouton Create dans la fenêtre Project. Nous changerons son nom en Rebondissement. Il y a quelques ajustements des propriétés nécessaires pour obtenir le comportement de rebondissement requis. Dans la fenêtre Inspector, les propriétés Dynamic Friction et Static Friction auront la valeur 0. La valeur de Bounciness sera de 1. La valeur de Friction Combine nécessite d'être réglée sur minimum, et Bounce Combine, sur maximum.

Pour que tous les objets du jeu utilisent l'élément Physic Material que nous avons généré, vous devez régler les paramètres de physique générale. Pour faire cela, cliquez sur le menu Edit -> Project Settings -> Physics. L'élément Physic Material Rebondissement est à glisser-déposer dans la propriété Default material. La propriété Bounce Threshold doit être réglée à 0.1. Si vous lancez le jeu à présent, la balle se comporte comme une balle en caoutchouc.

Le jeu est bientôt terminé. Les objets du jeu sont là où ils doivent être et la balle est en mouvement. La seule chose qui manque à présent est la logique pour contrôler les raquettes. Pour cela, il n'y a rien de mieux que d'utiliser un périphérique innovant, c'est-à-dire notre caméra 3D, qui a été popularisée avec la Microsoft Xbox* équipée de Kinect*. Certaines des tablettes et des Ultrabook™ les plus récents sont équipés de caméras 3D. Si vous n'en avez pas déjà un, ces appareils sont tout à fait abordables. Pour le développement, vous aurez besoin de télécharger gratuitement le SDK Intel RealSense. Après l'installation vous pourrez trouver quelques exemples Unity dans le répertoire du SDK Intel RealSense.

Unity 3D prend en charge les modules tiers, et un module a été créé pour le SDK Intel RealSense. Pour inclure le SDK Intel RealSense il est nécessaire d'ajouter les fichiers DLL du SDK DLL au projet. Dans Unity, sélectionnez Assets ->Import package -> custom package… Puis choisissez le fichier RSUnityToolkit.unitypackage, qui est dans C:\Program files (x 86) \Intel\RSSDK\framework\Unity. Une boîte de dialogue telle que celle montrée sur l'Illustration 17 s'ouvrira. Tous les fichiers sont sélectionnés par défaut. Cliquez sur None pour effacer la sélection et sélectionnez uniquement le répertoire des modules (plug-ins). Si vous développez sur un ordinateur 64 bits, vous devrez tout de même remplacer les fichiers DLL importés manuellement. Vous les trouverez dans le répertoire suivant : C:\Program Files (x86)\Intel\RSSDK\bin\x64

Après l'intégration, il est temps de commencer le développement de la logique de la raquette. Nous aurons besoin d'un autre fichier C#, qui peut être généré en cliquant sur le bouton Create dans la fenêtre Project. Le nom du fichier sera Paddle. Seule une instance générale doit être générée durant le jeu pour répondre aux deux raquettes. Cela est très important parce que la Caméra 3D Intel RealSense ne peut se connecter qu'avec une instance, et pas avec des instances multiples. Pour cette raison, nous allons connecter le nouveau fichier avec un glisser-déposer dans l'objet de jeu main camera dans la fenêtre Hierarchy.

public class Paddles : MonoBehaviour
{
   public GameObject Paddle1;
   public GameObject Paddle2;
  ..

Pour créer une connexion permanente avec la caméra, le SDK Intel RealSense propose une classe nommée PXCMSenseManager. La fonction start ne sera appelée qu'une fois depuis le moteur Unity, donc c'est idéal pour la préparation générale d'une instance. C'est pourquoi nous initialisons la classe PXCMSenseManager dans la fonction start. Pour ce faire, nous allons commencer par lui attribuer un module QueryHand, qui nous permet de lire les gestes de la main. Pour reconnaître le visage et la voix, un module séparé est nécessaire. L'instance de la caméra est déclarée en dehors de la fonction start en tant que champ _pxcmSenseManager. Ce code est dans l'Extrait de code 3.

public class Paddles : MonoBehaviour
{
   public GameObject Paddle1;
   public GameObject Paddle2;

   private PXCMSenseManager _pxcmSenseManager;
   private PXCMHandModule _pxcmHandModule;

   // Use this for initialization
   private void Start()
   {
       _pxcmSenseManager = PXCMSenseManager.CreateInstance();

       if (_pxcmSenseManager == null)
       {
           Debug.LogError("SenseManager Initialization Failed");
       }
       else
       {
           pxcmStatus pxcmResult = _pxcmSenseManager.EnableHand();
           if (pxcmResult != pxcmStatus.PXCM_STATUS_NO_ERROR)
           {
               Debug.LogError("EnableHand: " + pxcmResult);
           }
           else
           {
               _pxcmHandModule = _pxcmSenseManager.QueryHand();
               _pxcmSenseManager.Init();

               PXCMHandConfiguration configuration = _pxcmHandModule.CreateActiveConfiguration();
               configuration.EnableAllGestures();
               configuration.ApplyChanges();
               configuration.Dispose();
           }
       }
   }
...

Une requête directe d'actualisation de la caméra a lieu dans la fonction de mise à jour (boucle de jeu) pour que nous puissions déterminer si la caméra voit une main ou pas. La main gauche est utilisée pour la raquette gauche et la main droite pour la raquette droite. Il faut donc assigner les valeurs calculées à la raquette correspondante. Puisque la logique est très similaire, nous créons une fonction privée appelée MoveBall pour cela.

Si le joueur quitte ou redémarre le jeu, l'instance directe avec la caméra doit être déconnectée. La fonction OnDisable, qui sera appelée automatiquement par le moteur Unity, est parfaite pour cela.

 // Update is called once per frame
   private void Update()
   {
       if (_pxcmSenseManager == null)
       {
           return;
       }

       _pxcmSenseManager.AcquireFrame(false, 0);

       _pxcmHandModule = _pxcmSenseManager.QueryHand();
       PXCMHandData handData = _pxcmHandModule.CreateOutput();
       handData.Update();

       MoveBall(handData, PXCMHandData.AccessOrderType.ACCESS_ORDER_LEFT_HANDS, Paddle1);
       MoveBall(handData, PXCMHandData.AccessOrderType.ACCESS_ORDER_RIGHT_HANDS, Paddle2);

       _pxcmSenseManager.ReleaseFrame();
   }

   private void MoveBall(PXCMHandData handData, PXCMHandData.AccessOrderType accessOrderType, GameObject gameObject)
   {
       PXCMHandData.IHand pxcmHandData;
       if (handData.QueryHandData(accessOrderType, 0, out pxcmHandData) == 
           pxcmStatus.PXCM_STATUS_NO_ERROR)
       {
           PXCMHandData.JointData jointData;
           if (pxcmHandData.QueryTrackedJoint(PXCMHandData.JointType.JOINT_CENTER, out jointData) ==
               pxcmStatus.PXCM_STATUS_NO_ERROR)
           {
               gameObject.GetComponent<Rigidbody>().velocity = new Vector3(-9, jointData.positionWorld.y*100f, 0);
           }
       }
   }

   private void OnDisable()
   {
       _pxcmHandModule.Dispose();
       _pxcmSenseManager.Dispose();
   }
}

Les objets du jeu sont générés, la logique est codée, et maintenant il est temps de tester le jeu. Si une main est reconnue dans un champ de 1 à 5 mètres de la caméra, les raquettes bougeront. Si la balle touche l'une des raquettes, elle bougera et se déplacera dans la direction opposée. Si la balle quitte le champ sans avoir touché une raquette, le joueur désespéré ne peut rien faire. Dans ce cas, le jeu devrait redémarrer automatiquement si la balle quitte le terrain de jeu.

Seules quelques lignes de code sont nécessaires pour implémenter cette logique dans le fichier Ball.cs. La fonction Update devrait vérifier si la balle est toujours dans le champ de vision. Si la balle est hors de vue, la fonction Application.LoadLevel redémarre le jeu, comme dans l'Extrait de code 5.

private bool _loaded;

// Update is called once per frame
void Update () 
{
   if (GetComponent<Renderer>().isVisible)
   {
       _loaded = true;
   }

   if (!GetComponent<Renderer>().isVisible && _loaded)
   {
       Application.LoadLevel(Application.loadedLevel);
   }
}

La première version du jeu est prête et bien sûr, nous aimerions la partager avec d'autres personnes. L'élément de menu File | Build Settings (Ctrl + Shift + B) ouvre la boîte de dialogue de Build. Vous pouvez choisir quelles seront les plateformes prises en charge par votre jeu depuis l'énorme choix disponible dans la liste Platform. Nous choisirons Windows et réglerons l'architecture sur x86_64. Cliquez simplement sur Build pour démarrer le compilateur et générer un fichier .exe pour Windows. Pour jouer au jeu, vous devez avoir une caméra 3D Intel RealSense avec le pilote préinstallé.

Je vous ai montré comment créer un jeu amusant, mais il peut encore être un peu amélioré. Montrez-moi ce dont vous êtes capable ! Mettez en place un système de meilleur score, des sons, et des effets spéciaux sympa. Envoyez une vidéo sur YouTube*, et envoyez-moi un e-mail pour que je puisse voir ce que vous avez créé. J'ai hâte de voir vos idées de création. Et maintenant, je vous souhaite de vous amuser au mieux avec votre premier jeu Unity et la caméra 3D Intel RealSense.

Gregor Biswanger (Microsoft MVP, Intel Black Belt, et Innovateur Logiciel Intel) est le fondateur de CleverSocial tout en étant professeur, consultant, formateur, auteur et conférencier indépendant. Il conseille les grandes et moyennes entreprises, organisations et agences sur les architectures logicielles, les méthodes agiles, XAML, le développement d'applications pour le web et hybrides, les solutions de cloud, le marketing de contenu, et le marketing sur les réseaux sociaux.

Il a publié plusieurs vidéos de formation à propos de ces sujets sur video2brain et Microsoft. Il est également auteur indépendant et écrit en ligne pour heise Developer ainsi que des articles pour des revues spécialisées. Il a écrit le livre “cross-platform development” pour entwickler.press.

Vous pourrez rencontrer Gregor à l'occasion de ses nombreux voyages, assistant ou intervenant à des conférences internationales. En plus de cela, Intel lui a demandé d'être consultant en technologies pour la Zone Développeur Intel® . Il dirige le INdotNET (Groupe de Développeurs Ingolstaedter .NET). Vous pouvez trouver ses informations de contact i ci.

Pour plus d'informations sur le développement de jeux, rendez-vous sur la  Zone des Développeurs Intel.

Retrouvez également des astuces, conseils et retours d'expériences sur le http://network.bemyapp.com/trk/D9CA8528A2BA779D48B5B6108F7DBB8C forum Intel.

• Unity Ressource Center
• Intel GameDev Tools
• Intel GPA
• Intel INDE