Simulation des perceptions

Article
03/21/2023

Voulez-vous créer un test automatisé pour votre application ? Voulez-vous que vos tests vont au-delà des tests unitaires au niveau des composants et que votre application s’exerce réellement de bout en bout ? La simulation de perception est ce que vous recherchez. La bibliothèque Perception Simulation envoie des données d’entrée humaines et mondiales à votre application afin que vous puissiez automatiser vos tests. Par exemple, vous pouvez simuler l’entrée d’un humain regardant vers une position spécifique et reproductible, puis utiliser un contrôleur de mouvement ou de mouvement.

La simulation de perception peut envoyer une entrée simulée comme celle-ci à un HoloLens physique, à l’émulateur HoloLens (première génération), à l’émulateur HoloLens 2 ou à un PC sur lequel Mixed Reality Portal est installé. La simulation de perception contourne les capteurs en direct sur un appareil Mixed Reality et envoie une entrée simulée aux applications qui s’exécutent sur l’appareil. Les applications reçoivent ces événements d’entrée via les mêmes API qu’elles utilisent toujours et ne peuvent pas faire la différence entre l’exécution avec des capteurs réels et la simulation de perception. La simulation de perception est la même technologie que celle utilisée par les émulateurs HoloLens pour envoyer des entrées simulées à la machine virtuelle HoloLens.

Pour commencer à utiliser la simulation dans votre code, commencez par créer un objet IPerceptionSimulationManager. À partir de cet objet, vous pouvez émettre des commandes pour contrôler les propriétés d’un « humain » simulé, y compris la position de la tête, la position de la main et les mouvements. Vous pouvez également activer et manipuler les contrôleurs de mouvement.

Configuration d’un projet Visual Studio pour la simulation de perception

Installez l’émulateur HoloLens sur votre PC de développement. L’émulateur inclut les bibliothèques que vous utilisez pour la simulation de perception.
Créez un projet de bureau Visual Studio C# (un projet console est parfait pour commencer).
Ajoutez les fichiers binaires suivants à votre projet en tant que références (Project-Add-Reference>>...). Vous pouvez les trouver dans %ProgramFiles(x86)%\Microsoft XDE\(version), par exemple %ProgramFiles(x86)%\Microsoft XDE\10.0.18362.0 pour l’émulateur HoloLens 2.

Notes

Bien que les fichiers binaires font partie de l’émulateur HoloLens 2, ils fonctionnent également pour Windows Mixed Reality sur le bureau.)

a. PerceptionSimulationManager.Interop.dll : wrapper C# managé pour la simulation de perception.
b. PerceptionSimulationRest.dll : bibliothèque pour la configuration d’un canal de communication de socket web vers HoloLens ou l’émulateur.
c. SimulationStream.Interop.dll : types partagés pour la simulation.
Ajouter l'PerceptionSimulationManager.dll binaire d’implémentation à votre projet

a. Commencez par l’ajouter en tant que binaire au projet (Project-Add-Existing>> Item...). Enregistrez-le en tant que lien afin qu’il ne le copie pas dans le dossier source de votre projet.

b. Assurez-vous ensuite qu’il est copié dans votre dossier de sortie lors de la build. Cela se trouve dans la feuille de propriétés pour le fichier binaire.
Définissez votre plateforme de solution active sur x64. (Utilisez la Configuration Manager pour créer une entrée de plateforme pour x64 si elle n’existe pas déjà.)

Création d’un objet IPerceptionSimulation Manager

Pour contrôler la simulation, vous allez émettre des mises à jour des objets récupérés à partir d’un objet IPerceptionSimulationManager. La première étape consiste à obtenir cet objet et à le connecter à votre appareil ou émulateur cible. Vous pouvez obtenir l’adresse IP de votre émulateur en cliquant sur le bouton Device Portal dans la barre d’outils.

Icône Ouvrir le portail d’appareil Ouvrir le portail d’appareil : ouvrez le portail d’appareil Windows pour le système d’exploitation HoloLens dans l’émulateur. Pour Windows Mixed Reality, il peut être récupéré dans l’application Paramètres sous « Mettre à jour & sécurité », puis « Pour les développeurs » dans la section « Se connecter à l’aide de : » sous « Activer device Portal ». Veillez à noter à la fois l’adresse IP et le port.

Tout d’abord, vous allez appeler RestSimulationStreamSink.Create pour obtenir un objet RestSimulationStreamSink. Il s’agit de l’appareil ou de l’émulateur cible que vous contrôlerez via une connexion HTTP. Vos commandes sont passées à et gérées par le portail d’appareil Windows en cours d’exécution sur l’appareil ou l’émulateur. Les quatre paramètres dont vous avez besoin pour créer un objet sont les suivants :

URI : adresse IP de l’appareil cible (par exemple, «https://123.123.123.123" ; ou «https://123.123.123.123:50080" ;)
Informations d’identification System.Net.NetworkCredential : nom d’utilisateur/mot de passe pour la connexion au portail d’appareil Windows sur l’appareil ou l’émulateur cible. Si vous vous connectez à l’émulateur via son adresse locale (par exemple, 168... *) sur le même PC, toutes les informations d’identification seront acceptées.
bool normal : true pour la priorité normale, false pour la priorité basse. Vous souhaitez généralement définir cette valeur sur true pour les scénarios de test, ce qui permet à votre test de prendre le contrôle. L’émulateur et la simulation Windows Mixed Reality utilisent des connexions de faible priorité. Si votre test utilise également une connexion basse priorité, la connexion la plus récente établie sera sous contrôle.
Jeton System.Threading.CancellationToken : jeton permettant d’annuler l’opération asynchrone.

Ensuite, vous allez créer IPerceptionSimulationManager. Il s’agit de l’objet que vous utilisez pour contrôler la simulation. Cette opération doit également être effectuée dans une méthode asynchrone.

Contrôler l’humain simulé

Un IPerceptionSimulationManager a une propriété Human qui renvoie un objet ISimulatedHuman. Pour contrôler l’humain simulé, effectuez des opérations sur cet objet. Par exemple :

manager.Human.Move(new Vector3(0.1f, 0.0f, 0.0f))

Exemple d’application console C# de base

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.PerceptionSimulation;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Task.Run(async () =>
            {
                RestSimulationStreamSink sink = null;
                CancellationToken token = new System.Threading.CancellationToken();

                try
                {
                    sink = await RestSimulationStreamSink.Create(
                        // use the IP address for your device/emulator
                        new Uri("https://169.254.227.115"),
                        // no credentials are needed for the emulator
                        new System.Net.NetworkCredential("", ""),
                        // normal priorty
                        true,
                        // cancel token
                        token);

                    IPerceptionSimulationManager manager = PerceptionSimulationManager.CreatePerceptionSimulationManager(sink);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                }

                // Always close the sink to return control to the previous application.
                if (sink != null)
                {
                    await sink.Close(token);
                }
            });

            // If main exits, the process exits.  
            Console.WriteLine("Press any key to exit...");
            Console.ReadLine();
        }
    }
}

Exemple d’application console C# étendu

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.PerceptionSimulation;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            RestSimulationStreamSink sink = null;
            CancellationToken token = new System.Threading.CancellationToken();

            Task.Run(async () =>
            {
                try
                {
                    sink = await RestSimulationStreamSink.Create(
                        // use the IP address for your device/emulator
                        new Uri("https://169.254.227.115"),
                        // no credentials are needed for the emulator
                        new System.Net.NetworkCredential("", ""),
                        // normal priorty
                        true,
                        // cancel token
                        token);

                    IPerceptionSimulationManager manager = PerceptionSimulationManager.CreatePerceptionSimulationManager(sink);

                    // Now, we'll simulate a sequence of actions.
                    // Sleeps in-between each action give time to the system
                    // to be able to properly react.
                    // This is just an example. A proper automated test should verify
                    // that the app has behaved correctly
                    // before proceeding to the next step, instead of using Sleeps.

                    // Activate the right hand
                    manager.Human.RightHand.Activated = true;

                    // Simulate Bloom gesture, which should cause Shell to disappear
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.Home);
                    Thread.Sleep(2000);

                    // Simulate Bloom gesture again... this time, Shell should reappear
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.Home);
                    Thread.Sleep(2000);

                    // Simulate a Head rotation down around the X axis
                    // This should cause gaze to aim about the center of the screen
                    manager.Human.Head.Rotate(new Rotation3(0.04f, 0.0f, 0.0f));
                    Thread.Sleep(300);

                    // Simulate a finger press & release
                    // Should cause a tap on the center tile, thus launching it
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.FingerPressed);
                    Thread.Sleep(300);
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.FingerReleased);
                    Thread.Sleep(2000);

                    // Simulate a second finger press & release
                    // Should activate the app that was launched when the center tile was clicked
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.FingerPressed);
                    Thread.Sleep(300);
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.FingerReleased);
                    Thread.Sleep(5000);

                    // Simulate a Head rotation towards the upper right corner
                    manager.Human.Head.Rotate(new Rotation3(-0.14f, 0.17f, 0.0f));
                    Thread.Sleep(300);

                    // Simulate a third finger press & release
                    // Should press the Remove button on the app
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.FingerPressed);
                    Thread.Sleep(300);
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.FingerReleased);
                    Thread.Sleep(2000);

                    // Simulate Bloom gesture again... bringing the Shell back once more
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.Home);
                    Thread.Sleep(2000);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                }
            });

            // If main exits, the process exits.  
            Console.WriteLine("Press any key to exit...");
            Console.ReadLine();

            // Always close the sink to return control to the previous application.
            if (sink != null)
            {
                sink.Close(token);
            }
        }
    }
}

Remarque sur les contrôleurs 6-DOF

Avant d’appeler des propriétés sur des méthodes sur un contrôleur 6-DOF simulé, vous devez activer le contrôleur. Si vous ne le faites pas, vous obtiendrez une exception. À compter du Mise à jour de mai 2019 de Windows 10, les contrôleurs 6 DOF simulés peuvent être installés et activés en définissant la propriété Status sur l’objet ISimulatedSixDofController sur SimulatedSixDofControllerStatus.Active. Dans les Mise à jour d'octobre 2018 de Windows 10 et versions antérieures, vous devez installer séparément un contrôleur 6 DOF simulé en appelant d’abord l’outil PerceptionSimulationDevice situé dans le dossier \Windows\System32. L’utilisation de cet outil est la suivante :

    PerceptionSimulationDevice.exe <action> 6dof <instance>

Par exemple

    PerceptionSimulationDevice.exe i 6dof 1

Les actions prises en charge sont les suivantes :

i = installer
q = requête
r = remove

Les instances prises en charge sont les suivantes :

1 = le contrôleur 6 DOF gauche
2 = le contrôleur 6-DOF droit

Le code de sortie du processus indique la réussite (valeur de retour zéro) ou l’échec (valeur de retour différente de zéro). Lorsque vous utilisez l’action « q » pour demander si un contrôleur est installé, la valeur de retour est zéro (0) si le contrôleur n’est pas déjà installé ou une (1) si le contrôleur est installé.

Lorsque vous supprimez un contrôleur sur le Mise à jour d'octobre 2018 de Windows 10 ou une version antérieure, définissez son status sur Désactivé via l’API, puis appelez l’outil PerceptionSimulationDevice.

Cet outil doit être exécuté en tant qu’administrateur.

Référence d’API

Microsoft.PerceptionSimulation.SimulatedDeviceType

Décrit un type d’appareil simulé

public enum SimulatedDeviceType
{
    Reference = 0
}

Microsoft.PerceptionSimulation.SimulatedDeviceType.Reference

Appareil de référence fictif, valeur par défaut de PerceptionSimulationManager

Microsoft.PerceptionSimulation.HeadTrackerMode

Décrit un mode de suivi de la tête

public enum HeadTrackerMode
{
    Default = 0,
    Orientation = 1,
    Position = 2
}

Microsoft.PerceptionSimulation.HeadTrackerMode.Default

Suivi de la tête par défaut. Cela signifie que le système peut sélectionner le meilleur mode de suivi de la tête en fonction des conditions d’exécution.

Microsoft.PerceptionSimulation.HeadTrackerMode.Orientation

Orientation uniquement suivi de la tête. Cela signifie que la position suivie peut ne pas être fiable et que certaines fonctionnalités dépendantes de la position de la tête peuvent ne pas être disponibles.

Microsoft.PerceptionSimulation.HeadTrackerMode.Position

Suivi de la tête positionnelle. Cela signifie que la position et l’orientation de la tête suivies sont toutes deux fiables

Microsoft.PerceptionSimulation.SimulatedGesture

Décrit un mouvement simulé

public enum SimulatedGesture
{
    None = 0,
    FingerPressed = 1,
    FingerReleased = 2,
    Home = 4,
    Max = Home
}

Microsoft.PerceptionSimulation.SimulatedGesture.None

Valeur sentinelle utilisée pour indiquer aucun mouvement.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerPressed

Un geste appuyé par le doigt.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerReleased

Un geste de relâchement du doigt.

Microsoft.PerceptionSimulation.SimulatedGesture.Home

Mouvement accueil/système.

Microsoft.PerceptionSimulation.SimulatedGesture.Max

Mouvement valide maximal.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus

États possibles d’un contrôleur 6 DOF simulé.

public enum SimulatedSixDofControllerStatus
{
    Off = 0,
    Active = 1,
    TrackingLost = 2,
}

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Off

Le contrôleur 6-DOF est désactivé.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Active

Le contrôleur 6-DOF est activé et suivi.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.TrackingLost

Le contrôleur 6 DOF est activé, mais ne peut pas être suivi.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton

Boutons pris en charge sur un contrôleur 6 DOF simulé.

public enum SimulatedSixDofControllerButton
{
    None = 0,
    Home = 1,
    Menu = 2,
    Grip = 4,
    TouchpadPress = 8,
    Select = 16,
    TouchpadTouch = 32,
    Thumbstick = 64,
    Max = Thumbstick
}

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.None

Valeur sentinelle utilisée pour indiquer aucun bouton.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Home

Le bouton Accueil est enfoncé.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Menu

Le bouton Menu est enfoncé.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Grip

Le bouton Grip est enfoncé.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadPress

Le Pavé tactile est enfoncé.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Select

Le bouton Sélectionner est enfoncé.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadTouch

Le TouchPad est tactile.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Thumbstick

La touche est enfoncée.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Max

Bouton valide maximal.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState

État d’étalonnage des yeux simulés

public enum SimulatedGesture
{
    Unavailable = 0,
    Ready = 1,
    Configuring = 2,
    UserCalibrationNeeded = 3
}

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Indisponible

L’étalonnage des yeux n’est pas disponible.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Ready

Les yeux ont été étalonnés. Il s’agit de la valeur par défaut.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Configuring

Les yeux sont calibrés.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.UserCalibrationNeededed

Les yeux doivent être étalonnés.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy

Précision de suivi d’un joint de la main.

public enum SimulatedHandJointTrackingAccuracy
{
    Unavailable = 0,
    Approximate = 1,
    Visible = 2
}

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Indisponible

Le joint n’est pas suivi.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Approximate

La position conjointe est déduite.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Visible

Le joint est entièrement suivi.

Microsoft.PerceptionSimulation.SimulatedHandPose

Précision de suivi d’un joint de la main.

public enum SimulatedHandPose
{
    Closed = 0,
    Open = 1,
    Point = 2,
    Pinch = 3,
    Max = Pinch
}

Microsoft.PerceptionSimulation.SimulatedHandPose.Closed

Les articulations des doigts de la main sont configurées pour refléter une pose fermée.

Microsoft.PerceptionSimulation.SimulatedHandPose.Open

Les articulations des doigts de la main sont configurées pour refléter une pose ouverte.

Microsoft.PerceptionSimulation.SimulatedHandPose.Point

Les articulations des doigts de la main sont configurées pour refléter une pose pointante.

Microsoft.PerceptionSimulation.SimulatedHandPose.Pinch

Les articulations des doigts de la main sont configurées pour refléter une pose de pincement.

Microsoft.PerceptionSimulation.SimulatedHandPose.Max

Valeur valide maximale pour SimulatedHandPose.

Microsoft.PerceptionSimulation.PlaybackState

Décrit l’état d’une lecture.

public enum PlaybackState
{
    Stopped = 0,
    Playing = 1,
    Paused = 2,
    End = 3,
}

Microsoft.PerceptionSimulation.PlaybackState.Stopped

L’enregistrement est actuellement arrêté et prêt pour la lecture.

Microsoft.PerceptionSimulation.PlaybackState.Playing

L’enregistrement est en cours de lecture.

Microsoft.PerceptionSimulation.PlaybackState.Paused

L’enregistrement est actuellement suspendu.

Microsoft.PerceptionSimulation.PlaybackState.End

L’enregistrement a atteint la fin.

Microsoft.PerceptionSimulation.Vector3

Décrit un vecteur à trois composants, qui peut décrire un point ou un vecteur dans un espace 3D.

public struct Vector3
{
    public float X;
    public float Y;
    public float Z;
    public Vector3(float x, float y, float z);
}

Microsoft.PerceptionSimulation.Vector3.X

Composant X du vecteur.

Microsoft.PerceptionSimulation.Vector3.Y

Composant Y du vecteur.

Microsoft.PerceptionSimulation.Vector3.Z

Composant Z du vecteur.

Microsoft.PerceptionSimulation.Vector3.#ctor(System.Single,System.Single,System.Single)

Construisez un nouveau Vector3.

Paramètres

x : composant x du vecteur.
y : composant y du vecteur.
z : composant z du vecteur.

Microsoft.PerceptionSimulation.Rotation3

Décrit une rotation de trois composants.

public struct Rotation3
{
    public float Pitch;
    public float Yaw;
    public float Roll;
    public Rotation3(float pitch, float yaw, float roll);
}

Microsoft.PerceptionSimulation.Rotation3.Pitch

Composant Pitch de la rotation, vers le bas autour de l’axe X.

Microsoft.PerceptionSimulation.Rotation3.Yaw

Composant Yaw de la rotation, juste autour de l’axe Y.

Microsoft.PerceptionSimulation.Rotation3.Roll

Composant Roll de la rotation, juste autour de l’axe Z.

Microsoft.PerceptionSimulation.Rotation3.#ctor(System.Single,System.Single,System.Single)

Construisez une nouvelle rotation3.

Paramètres

pitch : composant de tangage de la rotation.
yaw : composant de lacet de la rotation.
roll : composant roll de la rotation.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration

Décrit la configuration d’un joint sur une main simulée.

public struct SimulatedHandJointConfiguration
{
    public Vector3 Position;
    public Rotation3 Rotation;
    public SimulatedHandJointTrackingAccuracy TrackingAccuracy;
}

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Position

Position de l’articulation.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Rotation

Rotation de l’articulation.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.TrackingAccuracy

Précision de suivi de l’articulation.

Microsoft.PerceptionSimulation.Frustum

Décrit un frustum de vue, tel qu’il est généralement utilisé par une caméra.

public struct Frustum
{
    float Near;
    float Far;
    float FieldOfView;
    float AspectRatio;
}

Microsoft.PerceptionSimulation.Frustum.Near

Distance minimale contenue dans le frustum.

Microsoft.PerceptionSimulation.Frustum.Far

Distance maximale contenue dans le frustum.

Microsoft.PerceptionSimulation.Frustum.FieldOfView

Champ de vue horizontal du frustum, en radians (inférieur à PI).

Microsoft.PerceptionSimulation.Frustum.AspectRatio

Rapport entre le champ de vue horizontal et le champ de vue vertical.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration

Décrit la configuration de l’affichage du casque simulé.

public struct SimulatedDisplayConfiguration
{
    public Vector3 LeftEyePosition;
    public Rotation3 LeftEyeRotation;
    public Vector3 RightEyePosition;
    public Rotation3 RightEyeRotation;
    public float Ipd;
    public bool ApplyEyeTransforms;
    public bool ApplyIpd;
}

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.LeftEyePosition

Transformation du centre de la tête à l’œil gauche à des fins de rendu stéréo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.LeftEyeRotation

Rotation de l’œil gauche à des fins de rendu stéréo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyePosition

Transformation du centre de la tête à l’œil droit à des fins de rendu stéréo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyeRotation

Rotation de l’œil droit à des fins de rendu stéréo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.Ipd

Valeur Ipd signalée par le système à des fins de rendu stéréo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyEyeTransforms

Indique si les valeurs fournies pour les transformations de l’œil gauche et de l’œil droit doivent être considérées comme valides et appliquées au système en cours d’exécution.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyIpd

Indique si la valeur fournie pour Ipd doit être considérée comme valide et appliquée au système en cours d’exécution.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager

Racine pour générer les paquets utilisés pour contrôler un appareil.

public interface IPerceptionSimulationManager
{   
    ISimulatedDevice Device { get; }
    ISimulatedHuman Human { get; }
    void Reset();
}

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Device

Récupérez l’objet d’appareil simulé qui interprète l’humain simulé et le monde simulé.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Human

Récupérez l’objet qui contrôle l’humain simulé.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Reset

Rétablit l’état par défaut de la simulation.

Microsoft.PerceptionSimulation.ISimulatedDevice

Interface décrivant l’appareil, qui interprète le monde simulé et l’humain simulé

public interface ISimulatedDevice
{
    ISimulatedHeadTracker HeadTracker { get; }
    ISimulatedHandTracker HandTracker { get; }
    void SetSimulatedDeviceType(SimulatedDeviceType type);
}

Microsoft.PerceptionSimulation.ISimulatedDevice.HeadTracker

Récupérez le suivi de tête à partir de l’appareil simulé.

Microsoft.PerceptionSimulation.ISimulatedDevice.HandTracker

Récupérez le dispositif hand tracker à partir de l’appareil simulé.

Microsoft.PerceptionSimulation.ISimulatedDevice.SetSimulatedDeviceType(Microsoft.PerceptionSimulation.SimulatedDeviceType)

Définissez les propriétés de l’appareil simulé pour qu’elles correspondent au type d’appareil fourni.

Paramètres

type : nouveau type d’appareil simulé

Microsoft.PerceptionSimulation.ISimulatedDevice2

Des propriétés supplémentaires sont disponibles en cas de conversion de ISimulatedDevice en ISimulatedDevice2

public interface ISimulatedDevice2
{
    bool IsUserPresent { [return: MarshalAs(UnmanagedType.Bool)] get; [param: MarshalAs(UnmanagedType.Bool)] set; }
    SimulatedDisplayConfiguration DisplayConfiguration { get; set; }

};

Microsoft.PerceptionSimulation.ISimulatedDevice2.IsUserPresent

Récupérez ou définissez si l’humain simulé porte ou non le casque.

Microsoft.PerceptionSimulation.ISimulatedDevice2.DisplayConfiguration

Récupérez ou définissez les propriétés de l’affichage simulé.

Microsoft.PerceptionSimulation.ISimulatedHeadTracker

Interface décrivant la partie de l’appareil simulé qui suit la tête de l’humain simulé.

public interface ISimulatedHeadTracker
{
    HeadTrackerMode HeadTrackerMode { get; set; }
};

Microsoft.PerceptionSimulation.ISimulatedHeadTracker.HeadTrackerMode

Récupère et définit le mode de suivi de la tête actuel.

Microsoft.PerceptionSimulation.ISimulatedHandTracker

Interface décrivant la partie de l’appareil simulé qui suit les mains de l’humain simulé

public interface ISimulatedHandTracker
{
    Vector3 WorldPosition { get; }
    Vector3 Position { get; set; }
    float Pitch { get; set; }
    bool FrustumIgnored { [return: MarshalAs(UnmanagedType.Bool)] get; [param: MarshalAs(UnmanagedType.Bool)] set; }
    Frustum Frustum { get; set; }
}

Microsoft.PerceptionSimulation.ISimulatedHandTracker.WorldPosition

Récupérez la position du nœud par rapport au monde, en mètres.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Position

Récupérez et définissez la position du dispositif de suivi de la main simulée, par rapport au centre de la tête.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Pitch

Récupérez et définissez le tangage vers le bas du dispositif de suivi de la main simulé.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.FrustumIgnored

Récupérez et définissez si le frustum du dispositif de suivi de la main simulé est ignoré. Lorsqu’elles sont ignorées, les deux mains sont toujours visibles. Lorsqu’elles ne sont pas ignorées (valeur par défaut), les mains ne sont visibles que lorsqu’elles se trouvent dans le frustum du dispositif de suivi de la main.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Frustum

Récupérez et définissez les propriétés de frustum utilisées pour déterminer si les mains sont visibles par le suivi de la main simulée.

Microsoft.PerceptionSimulation.ISimulatedHuman

Interface de niveau supérieur pour le contrôle de l’humain simulé.

public interface ISimulatedHuman 
{
    Vector3 WorldPosition { get; set; }
    float Direction { get; set; }
    float Height { get; set; }
    ISimulatedHand LeftHand { get; }
    ISimulatedHand RightHand { get; }
    ISimulatedHead Head { get; }s
    void Move(Vector3 translation);
    void Rotate(float radians);
}

Microsoft.PerceptionSimulation.ISimulatedHuman.WorldPosition

Récupérez et définissez la position du nœud par rapport au monde, en mètres. La position correspond à un point au centre des pieds de l’homme.

Microsoft.PerceptionSimulation.ISimulatedHuman.Direction

Récupérez et définissez la direction des visages humains simulés dans le monde. 0 radians fait face vers le bas de l’axe Z négatif. Les radians positifs pivotent dans le sens des aiguilles d’une montre autour de l’axe Y.

Microsoft.PerceptionSimulation.ISimulatedHuman.Height

Récupérez et définissez la hauteur de l’humain simulé, en mètres.

Microsoft.PerceptionSimulation.ISimulatedHuman.LeftHand

Récupérez la main gauche de l’humain simulé.

Microsoft.PerceptionSimulation.ISimulatedHuman.RightHand

Récupérez la main droite de l’humain simulé.

Microsoft.PerceptionSimulation.ISimulatedHuman.Head

Récupérez la tête de l’humain simulé.

Microsoft.PerceptionSimulation.ISimulatedHuman.Move(Microsoft.PerceptionSimulation.Vector3)

Déplacez l’homme simulé par rapport à sa position actuelle, en mètres.

Paramètres

translation : traduction à déplacer, par rapport à la position actuelle.

Microsoft.PerceptionSimulation.ISimulatedHuman.Rotate(System.Single)

Faire pivoter l’homme simulé par rapport à sa direction actuelle, dans le sens des aiguilles d’une montre autour de l’axe Y

Paramètres

radians : quantité à faire pivoter autour de l’axe Y.

Microsoft.PerceptionSimulation.ISimulatedHuman2

Des propriétés supplémentaires sont disponibles en cas de conversion de ISimulatedHuman en ISimulatedHuman2

public interface ISimulatedHuman2
{
    /* New members in addition to those available on ISimulatedHuman */
    ISimulatedSixDofController LeftController { get; }
    ISimulatedSixDofController RightController { get; }
}

Microsoft.PerceptionSimulation.ISimulatedHuman2.LeftController

Récupérez le contrôleur 6-DOF gauche.

Microsoft.PerceptionSimulation.ISimulatedHuman2.RightController

Récupérez le contrôleur 6-DOF approprié.

Microsoft.PerceptionSimulation.ISimulatedHand

Interface décrivant une main de l’homme simulé

public interface ISimulatedHand
{
    Vector3 WorldPosition { get; }
    Vector3 Position { get; set; }
    bool Activated { [return: MarshalAs(UnmanagedType.Bool)] get; [param: MarshalAs(UnmanagedType.Bool)] set; }
    bool Visible { [return: MarshalAs(UnmanagedType.Bool)] get; }
    void EnsureVisible();
    void Move(Vector3 translation);
    void PerformGesture(SimulatedGesture gesture);
}

Microsoft.PerceptionSimulation.ISimulatedHand.WorldPosition

Récupérez la position du nœud par rapport au monde, en mètres.

Microsoft.PerceptionSimulation.ISimulatedHand.Position

Récupérez et définissez la position de la main simulée par rapport à l’humain, en mètres.

Microsoft.PerceptionSimulation.ISimulatedHand.Activated

Récupérez et définissez si la main est actuellement activée.

Microsoft.PerceptionSimulation.ISimulatedHand.Visible

Récupérez si la main est actuellement visible par l’appareil SimulatedDevice (c’est-à-dire si elle est en position d’être détectée par le HandTracker).

Microsoft.PerceptionSimulation.ISimulatedHand.EnsureVisible

Déplacez la main de sorte qu’elle soit visible par l’appareil SimulatedDevice.

Microsoft.PerceptionSimulation.ISimulatedHand.Move(Microsoft.PerceptionSimulation.Vector3)

Déplacez la position de la main simulée par rapport à sa position actuelle, en mètres.

Paramètres

translation : montant à traduire la main simulée.

Microsoft.PerceptionSimulation.ISimulatedHand.PerformGesture(Microsoft.PerceptionSimulation.SimulatedGesture)

Effectuez un mouvement à l’aide de la main simulée. Elle ne sera détectée par le système que si la main est activée.

Paramètres

gesture : le mouvement à effectuer.

Microsoft.PerceptionSimulation.ISimulatedHand2

Des propriétés supplémentaires sont disponibles en cas de conversion d’un ISimulatedHand en ISimulatedHand2.

public interface ISimulatedHand2
{
    /* New members in addition to those available on ISimulatedHand */
    Rotation3 Orientation { get; set; }
}

Microsoft.PerceptionSimulation.ISimulatedHand2.Orientation

Récupérez ou définissez la rotation de la main simulée. Les radians positifs pivotent dans le sens des aiguilles d’une montre lorsque vous regardez le long de l’axe.

Microsoft.PerceptionSimulation.ISimulatedHand3

Des propriétés supplémentaires sont disponibles en cas de conversion d’un ISimulatedHand en ISimulatedHand3

public interface ISimulatedHand3
{
    /* New members in addition to those available on ISimulatedHand and ISimulatedHand2 */
    GetJointConfiguration(SimulatedHandJoint joint, out SimulatedHandJointConfiguration jointConfiguration);
    SetJointConfiguration(SimulatedHandJoint joint, SimulatedHandJointConfiguration jointConfiguration);
    SetHandPose(SimulatedHandPose pose, bool animate);
}

Microsoft.PerceptionSimulation.ISimulatedHand3.GetJointConfiguration

Obtient la configuration de la jointure spécifiée.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetJointConfiguration

Définissez la configuration de la jointure spécifiée.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetHandPose

Définissez la main sur une pose connue avec un indicateur facultatif à animer. Remarque : l’animation n’a pas pour effet que les articulations reflètent immédiatement leurs configurations de jointure finales.

Microsoft.PerceptionSimulation.ISimulatedHead

Interface décrivant la tête de l’humain simulé.

public interface ISimulatedHead
{
    Vector3 WorldPosition { get; }
    Rotation3 Rotation { get; set; }
    float Diameter { get; set; }
    void Rotate(Rotation3 rotation);
}

Microsoft.PerceptionSimulation.ISimulatedHead.WorldPosition

Récupérez la position du nœud par rapport au monde, en mètres.

Microsoft.PerceptionSimulation.ISimulatedHead.Rotation

Récupérez la rotation de la tête simulée. Les radians positifs pivotent dans le sens des aiguilles d’une montre lorsque vous regardez le long de l’axe.

Microsoft.PerceptionSimulation.ISimulatedHead.Diameter

Récupérez le diamètre de la tête simulée. Cette valeur est utilisée pour déterminer le centre de la tête (point de rotation).

Microsoft.PerceptionSimulation.ISimulatedHead.Rotate(Microsoft.PerceptionSimulation.Rotation3)

Faites pivoter la tête simulée par rapport à sa rotation actuelle. Les radians positifs pivotent dans le sens des aiguilles d’une montre lorsque vous regardez le long de l’axe.

Paramètres

rotation : quantité à faire pivoter.

Microsoft.PerceptionSimulation.ISimulatedHead2

Des propriétés supplémentaires sont disponibles en cas de conversion d’un ISimulatedHead en ISimulatedHead2

public interface ISimulatedHead2
{
    /* New members in addition to those available on ISimulatedHead */
    ISimulatedEyes Eyes { get; }
}

Microsoft.PerceptionSimulation.ISimulatedHead2.Eyes

Récupérez les yeux de l’humain simulé.

Microsoft.PerceptionSimulation.ISimulatedSixDofController

Interface décrivant un contrôleur 6-DOF associé à l’humain simulé.

public interface ISimulatedSixDofController
{
    Vector3 WorldPosition { get; }
    SimulatedSixDofControllerStatus Status { get; set; }
    Vector3 Position { get; }
    Rotation3 Orientation { get; set; }
    void Move(Vector3 translation);
    void PressButton(SimulatedSixDofControllerButton button);
    void ReleaseButton(SimulatedSixDofControllerButton button);
    void GetTouchpadPosition(out float x, out float y);
    void SetTouchpadPosition(float x, float y);
}

Microsoft.PerceptionSimulation.ISimulatedSixDofController.WorldPosition

Récupérez la position du nœud par rapport au monde, en mètres.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Status

Récupérez ou définissez l’état actuel du contrôleur. La status du contrôleur doit être définie sur une valeur autre que Off pour que les appels à déplacer, faire pivoter ou appuyer sur des boutons réussissent.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Position

Récupérez ou définissez la position du contrôleur simulé par rapport à l’humain, en mètres.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Orientation

Récupérez ou définissez l’orientation du contrôleur simulé.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Move(Microsoft.PerceptionSimulation.Vector3)

Déplacez la position du contrôleur simulé par rapport à sa position actuelle, en mètres.

Paramètres

translation : montant à traduire le contrôleur simulé.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.PressButton(SimulatedSixDofControllerButton)

Appuyez sur un bouton sur le contrôleur simulé. Il ne sera détecté par le système que si le contrôleur est activé.

Paramètres

button : bouton sur lequel appuyer.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.ReleaseButton(SimulatedSixDofControllerButton)

Relâchez un bouton sur le contrôleur simulé. Il ne sera détecté par le système que si le contrôleur est activé.

Paramètres

button : bouton à libérer.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.GetTouchpadPosition(out float, out float)

Obtenez la position d’un doigt simulé sur le pavé tactile du contrôleur simulé.

Paramètres

x : position horizontale du doigt.
y : position verticale du doigt.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.SetTouchpadPosition(float, float)

Définissez la position d’un doigt simulé sur le pavé tactile du contrôleur simulé.

Paramètres

x : position horizontale du doigt.
y : position verticale du doigt.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2

D’autres propriétés et méthodes sont disponibles en cas de conversion d’un ISimulatedSixDofController en ISimulatedSixDofController2

public interface ISimulatedSixDofController2
{
    /* New members in addition to those available on ISimulatedSixDofController */
    void GetThumbstickPosition(out float x, out float y);
    void SetThumbstickPosition(float x, float y);
    float BatteryLevel { get; set; }
}

Microsoft.PerceptionSimulation.ISimulatedSixDofController2.GetThumbstickPosition(out float, out float)

Obtenez la position de la manette simulée sur le contrôleur simulé.

Paramètres

x : position horizontale de la manette.
y : position verticale de la manette.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2.SetThumbstickPosition(float, float)

Définissez la position de la manette simulée sur le contrôleur simulé.

Paramètres

x : position horizontale de la manette.
y : position verticale de la manette.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2.BatteryLevel

Récupérez ou définissez le niveau de batterie du contrôleur simulé. La valeur doit être supérieure à 0,0 et inférieure ou égale à 100,0.

Microsoft.PerceptionSimulation.ISimulatedEyes

Interface décrivant les yeux de l’homme simulé.

public interface ISimulatedEyes
{
    Rotation3 Rotation { get; set; }
    void Rotate(Rotation3 rotation);
    SimulatedEyesCalibrationState CalibrationState { get; set; }
    Vector3 WorldPosition { get; }
}

Microsoft.PerceptionSimulation.ISimulatedEyes.Rotation

Récupérez la rotation des yeux simulés. Les radians positifs pivotent dans le sens des aiguilles d’une montre lorsque vous regardez le long de l’axe.

Microsoft.PerceptionSimulation.ISimulatedEyes.Rotate(Microsoft.PerceptionSimulation.Rotation3)

Faites pivoter les yeux simulés par rapport à leur rotation actuelle. Les radians positifs pivotent dans le sens des aiguilles d’une montre lorsque vous regardez le long de l’axe.

Paramètres

rotation : quantité à faire pivoter.

Microsoft.PerceptionSimulation.ISimulatedEyes.CalibrationState

Récupère ou définit l’état d’étalonnage des yeux simulés.

Microsoft.PerceptionSimulation.ISimulatedEyes.WorldPosition

Récupérez la position du nœud par rapport au monde, en mètres.

Microsoft.PerceptionSimulation.ISimulationRecording

Interface permettant d’interagir avec un seul enregistrement chargé pour la lecture.

public interface ISimulationRecording
{
    StreamDataTypes DataTypes { get; }
    PlaybackState State { get; }
    void Play();
    void Pause();
    void Seek(UInt64 ticks);
    void Stop();
};

Microsoft.PerceptionSimulation.ISimulationRecording.DataTypes

Récupère la liste des types de données dans l’enregistrement.

Microsoft.PerceptionSimulation.ISimulationRecording.State

Récupère l’état actuel de l’enregistrement.

Microsoft.PerceptionSimulation.ISimulationRecording.Play

Démarrez la lecture. Si l’enregistrement est suspendu, la lecture reprend à partir de l’emplacement suspendu ; si elle est arrêtée, la lecture démarre au début. S’il est déjà en cours de lecture, cet appel est ignoré.

Microsoft.PerceptionSimulation.ISimulationRecording.Pause

Interrompt la lecture à son emplacement actuel. Si l’enregistrement est arrêté, l’appel est ignoré.

Microsoft.PerceptionSimulation.ISimulationRecording.Seek(System.UInt64)

Recherche l’enregistrement à l’heure spécifiée (par intervalles de 100 nanosecondes à partir du début) et s’interrompt à cet emplacement. Si le temps est au-delà de la fin de l’enregistrement, il est suspendu à la dernière image.

Paramètres

ticks : heure à laquelle rechercher.

Microsoft.PerceptionSimulation.ISimulationRecording.Stop

Arrête la lecture et rétablit la position au début.

Microsoft.PerceptionSimulation.ISimulationRecordingCallback

Interface permettant de recevoir des modifications d’état pendant la lecture.

public interface ISimulationRecordingCallback
{
    void PlaybackStateChanged(PlaybackState newState);
};

Microsoft.PerceptionSimulation.ISimulationRecordingCallback.PlaybackStateChanged(Microsoft.PerceptionSimulation.PlaybackState)

Appelé lorsque l’état de lecture d’un ISimulationRecording a changé.

Paramètres

newState : nouvel état de l’enregistrement.

Microsoft.PerceptionSimulation.PerceptionSimulationManager

Objet racine pour la création d’objets de simulation de perception.

public static class PerceptionSimulationManager
{
    public static IPerceptionSimulationManager CreatePerceptionSimulationManager(ISimulationStreamSink sink);
    public static ISimulationStreamSink CreatePerceptionSimulationRecording(string path);
    public static ISimulationRecording LoadPerceptionSimulationRecording(string path, ISimulationStreamSinkFactory factory);
    public static ISimulationRecording LoadPerceptionSimulationRecording(string path, ISimulationStreamSinkFactory factory, ISimulationRecordingCallback callback);

Microsoft.PerceptionSimulation.PerceptionSimulationManager.CreatePerceptionSimulationManager(Microsoft.PerceptionSimulation.ISimulationStreamSink)

Créez sur l’objet pour générer des paquets simulés et les remettre au récepteur fourni.

Paramètres

sink : récepteur qui recevra tous les paquets générés.

Valeur retournée

Gestionnaire créé.

Microsoft.PerceptionSimulation.PerceptionSimulationManager.CreatePerceptionSimulationRecording(System.String)

Créez un récepteur qui stocke tous les paquets reçus dans un fichier au chemin d’accès spécifié.

Paramètres

path : chemin d’accès du fichier à créer.

Valeur retournée

Récepteur créé.

Microsoft.PerceptionSimulation.PerceptionSimulationManager.LoadPerceptionSimulationRecording(System.String,Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory)

Chargez un enregistrement à partir du fichier spécifié.

Paramètres

path : chemin d’accès du fichier à charger.
factory : fabrique utilisée par l’enregistrement pour créer un ISimulationStreamSink si nécessaire.

Valeur retournée

Enregistrement chargé.

Microsoft.PerceptionSimulation.PerceptionSimulationManager.LoadPerceptionSimulationRecording(System.String,Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory,Microsoft.PerceptionSimulation.ISimulationRecordingCallback)

Chargez un enregistrement à partir du fichier spécifié.

Paramètres

path : chemin d’accès du fichier à charger.
factory : fabrique utilisée par l’enregistrement pour créer un ISimulationStreamSink si nécessaire.
rappel : rappel qui reçoit des mises à jour qui reclassent les status de l’enregistrement.

Valeur retournée

Enregistrement chargé.

Microsoft.PerceptionSimulation.StreamDataTypes

Décrit les différents types de données de flux.

public enum StreamDataTypes
{
    None = 0x00,
    Head = 0x01,
    Hands = 0x02,
    SpatialMapping = 0x08,
    Calibration = 0x10,
    Environment = 0x20,
    SixDofControllers = 0x40,
    Eyes = 0x80,
    DisplayConfiguration = 0x100
    All = None | Head | Hands | SpatialMapping | Calibration | Environment | SixDofControllers | Eyes | DisplayConfiguration
}

Microsoft.PerceptionSimulation.StreamDataTypes.None

Valeur sentinelle utilisée pour indiquer aucun type de données de flux.

Microsoft.PerceptionSimulation.StreamDataTypes.Head

Flux de données pour la position et l’orientation de la tête.

Microsoft.PerceptionSimulation.StreamDataTypes.Hands

Flux de données pour la position et les mouvements des mains.

Microsoft.PerceptionSimulation.StreamDataTypes.SpatialMapping

Flux de données pour le mappage spatial de l’environnement.

Microsoft.PerceptionSimulation.StreamDataTypes.Calibration

Flux de données pour l’étalonnage de l’appareil. Les paquets d’étalonnage sont acceptés uniquement par un système en mode distant.

Microsoft.PerceptionSimulation.StreamDataTypes.Environment

Flux de données pour l’environnement de l’appareil.

Microsoft.PerceptionSimulation.StreamDataTypes.SixDofControllers

Flux de données pour les contrôleurs de mouvement.

Microsoft.PerceptionSimulation.StreamDataTypes.Eyes

Flux de données avec les yeux de l’humain simulé.

Microsoft.PerceptionSimulation.StreamDataTypes.DisplayConfiguration

Flux de données avec la configuration d’affichage de l’appareil.

Microsoft.PerceptionSimulation.StreamDataTypes.All

Valeur sentinelle utilisée pour indiquer tous les types de données enregistrés.

Microsoft.PerceptionSimulation.ISimulationStreamSink

Objet qui reçoit des paquets de données d’un flux de simulation.

public interface ISimulationStreamSink
{
    void OnPacketReceived(uint length, byte[] packet);
}

Microsoft.PerceptionSimulation.ISimulationStreamSink.OnPacketReceived(uint length, byte[] packet)

Reçoit un paquet unique, qui est typé en interne et versionné.

Paramètres

length : longueur du paquet.
packet : données du paquet.

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory

Objet qui crée ISimulationStreamSink.

public interface ISimulationStreamSinkFactory
{
    ISimulationStreamSink CreateSimulationStreamSink();
}

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory.CreateSimulationStreamSink()

Crée une seule instance de ISimulationStreamSink.

Valeur retournée

Récepteur créé.

Simulation des perceptions

Configuration d’un projet Visual Studio pour la simulation de perception

Création d’un objet IPerceptionSimulation Manager

Contrôler l’humain simulé

Exemple d’application console C# de base

Exemple d’application console C# étendu

Remarque sur les contrôleurs 6-DOF

Référence d’API

Microsoft.PerceptionSimulation.SimulatedDeviceType

Microsoft.PerceptionSimulation.HeadTrackerMode

Microsoft.PerceptionSimulation.SimulatedGesture

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy

Microsoft.PerceptionSimulation.SimulatedHandPose

Microsoft.PerceptionSimulation.PlaybackState

Microsoft.PerceptionSimulation.Vector3

Microsoft.PerceptionSimulation.Rotation3

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration

Microsoft.PerceptionSimulation.Frustum

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration

Microsoft.PerceptionSimulation.IPerceptionSimulationManager

Microsoft.PerceptionSimulation.ISimulatedDevice

Microsoft.PerceptionSimulation.ISimulatedDevice2

Microsoft.PerceptionSimulation.ISimulatedHeadTracker

Microsoft.PerceptionSimulation.ISimulatedHandTracker

Microsoft.PerceptionSimulation.ISimulatedHuman

Microsoft.PerceptionSimulation.ISimulatedHuman2

Microsoft.PerceptionSimulation.ISimulatedHand

Microsoft.PerceptionSimulation.ISimulatedHand2

Microsoft.PerceptionSimulation.ISimulatedHand3

Microsoft.PerceptionSimulation.ISimulatedHead

Microsoft.PerceptionSimulation.ISimulatedHead2

Microsoft.PerceptionSimulation.ISimulatedSixDofController

Microsoft.PerceptionSimulation.ISimulatedSixDofController2

Microsoft.PerceptionSimulation.ISimulatedEyes

Microsoft.PerceptionSimulation.ISimulationRecording

Microsoft.PerceptionSimulation.ISimulationRecordingCallback

Microsoft.PerceptionSimulation.PerceptionSimulationManager

Microsoft.PerceptionSimulation.StreamDataTypes

Microsoft.PerceptionSimulation.ISimulationStreamSink

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory

Ressources supplémentaires