Xamarin a annoncé depuis peu la compatibilité du moteur de jeu UrhoSharp afin de créer des applications Hololens. C'est une alternative intéressante aux applications DirectX native, UWP 2D ou encore à Unity3D.

Les bases

Afin de créer une application pour Hololens avec UrhoSharp, nous devons créer un nouveau projet UWP et ajouter le package NuGet UrhoSharp.Hololens. Une fois fait, supprimez les fichiers App.xaml/App.xaml.cs et MainView/MainView.cs car le point d'entrée sera un peu différent et nous n'utiliserons pas de XAML du tout.

Créez une classe nommée Program qui sera notre nouveau point d'entrée :

using System;
using Windows.ApplicationModel.Core;

namespace UrhoTest
{
    internal class Program
    {
        [MTAThread]
        private static void Main()
        {
            var exclusiveViewApplicationSource = new AppViewSource();
            CoreApplication.Run(exclusiveViewApplicationSource);
        }
    }
}

Cette classe a un seul but : définir la source de rendu (view source) qui sera utilisée par l'application afin d'afficher quelque chose à l'écran. La prochaine étape est, bien évidemment, la création de cette source (qui utilisera l'interface IFrameworkViewSource) avec l'aide de notre ami UrhoSharp.

using Windows.ApplicationModel.Core;
using Urho.HoloLens;

namespace UrhoTest
{
    internal class AppViewSource : IFrameworkViewSource
    {
        public IFrameworkView CreateView()
        {
            return UrhoAppView.Create<MyApplication>(null);
        }
    }
}

La méthode générique statique UrhoAppView.Create<T> nous permet de créer un "jeu". Le terme "jeu" est ici employé car il est nécessaire de comprendre que l'application créée utilisera toutes les caractéristiques d'un jeu-vidéo (boucle de jeu, camera, ...). UrhoSharp contient une classe nommée HoloApplication qui gère la majorité de ces caractéristiques pour nous et nous permet de surcharger certaines méthodes afin de modeler son jeu à sa convenance (Start, Stop, OnUpdate, OnGestureTapped, ...).

using Urho.Holographics;

namespace UrhoTest
{
    public class MyApplication : HoloApplication
    {
        public MyApplication(string pak, bool emulator)
            : base(pak, emulator) { }
    }
}

Vous pouvez dès à présent lancer votre application sur votre Hololens ou via l'émulateur pour ne voir... strictement rien !

Montre moi des choses

Une balle, rien qu'une balle

Comme Unity3D ou d'autres moteurs de jeu, vous devez ajouter des objets à une scène pour qu'ils soient visibles à l'écran. Concrètement, une scène est une hiérarchie d'objets (nommé Node dans UrhoSharp) qui peuvent avoir différents composants permettant de définir leur rendu à l'écran, leurs propriétés physiques, leur zone de collision, etc.

On va commencer simple en affichant uniquement une jolie balle bleue. Dans la méthode Start, donc au lancement de l'application, nous allons créer un object vide (Node) à la scène qui servira à définir notre balle. Notre noeud aura lui-aussi un enfant afin de définir son aspect à l'écran (ici, une simple sphère).

private Node _ballNode;
private Node _ballModelNode;

protected override void Start()
{
    base.Start();

    CreateBall();
}

private void CreateBall()
{
    // Create a new node on the scene
    _ballNode = Scene.CreateChild();
    _ballNode.Position = new Vector3(0, 0, 3);
    _ballNode.Scale = new Vector3(0.1f, 0.1f, 0.1f);

    // Add the model
    _ballModelNode = _ballNode.CreateChild();
    var sphere = _ballModelNode.CreateComponent<Sphere>();
    sphere.Color = Color.Blue;
}

 Il ne faut pas utiliser la méthode Setup pour définir votre scène. La méthode Start est là pour ça !

La hiérarchie de la scène se compose alors comme ceci :

Scène

- Balle

- Modèle

T'as pas 100 balles ?

Dans cet exemple, nous allons utiliser la méthode OnUpdate et la propriété timeStep pour afficher une nouvelle balle toutes les secondes. La propriété timeStep représente le temps passé entre la frame précédente et la frame courante.

private float _spawnTimer = 1;
private float _spawnDeltaTime;

protected override void OnUpdate(float timeStep)
{
    base.OnUpdate(timeStep);

    _spawnDeltaTime += timeStep;
    if (_spawnDeltaTime >= _spawnTimer)
    {
        _spawnDeltaTime = 0;

        var randomPosition = new Vector3(Randoms.Next(-0.3f, 0.3f), Randoms.Next(-0.3f, 0.3f), Randoms.Next(2, 5));
        CreateBall(randomPosition);
    }
}

private void CreateBall(Vector3 position)
{
    // Create a new node on the scene
    var ballNode = Scene.CreateChild();
    ballNode.Position = position;
    ballNode.Scale = new Vector3(0.1f, 0.1f, 0.1f);

    // Add the model
    var ballModelNode = ballNode.CreateChild();
    var sphere = ballModelNode.CreateComponent<Sphere>();
    sphere.Color = Color.Blue;
}

La hiérarchie de cette scène se compose comme ceci :

Scène

- Balle (1)

- Modèle

- Balle (2)

- Modèle

- Balle (3)

- Modèle

- ...

Dans le prochain article, nous parlerons plus en détail du moteur physique.