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 du composant et exercez-vous vraiment votre application 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 de pouvoir automatiser vos tests. Par exemple, vous pouvez simuler l’entrée d’un humain à une position spécifique et reproductible, puis utiliser un mouvement ou un contrôleur 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 le portail de réalité mixte est installé. Perception Simulation contourne les capteurs en direct sur un appareil de réalité mixte et envoie une entrée simulée aux applications s’exécutant 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 indiquer la différence entre l’exécution avec des capteurs réels et la simulation de perception. Perception Simulation est la même technologie que celle utilisée par les émulateurs HoloLens pour envoyer une entrée simulée à 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 des 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 fonctionne parfaitement 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.

Remarque

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 sur HoloLens ou l’émulateur.
c. SimulationStream.Interop.dll : types partagés pour la simulation.
Ajouter le PerceptionSimulationManager.dll binaire d’implémentation à votre projet

a. Tout d’abord, ajoutez-le en tant que binaire au projet (élément Project-Add-Existing>>...). Enregistrez-le sous forme de lien afin qu’il ne le copie pas dans votre dossier source de projet.

b. Vérifiez ensuite qu’elle est copiée dans votre dossier de sortie sur la build. Il s’agit de la feuille de propriétés pour le fichier binaire.
Définissez votre plateforme de solution active sur x64. (Utilisez Configuration Manager pour créer une entrée de plateforme pour x64 si celle-ci 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 Portail d’appareil dans la barre d’outils

Icône Ouvrir le portail d’appareil Ouvrez Device Portal : ouvrez le portail d’appareil Windows pour le système d’exploitation HoloLens dans l’émulateur. Pour Windows Mixed Reality, vous pouvez le récupérer dans l’application Paramètres sous « Mettre à jour et sécurité », puis « Pour les développeurs » dans la section « Se connecter à l’aide de : » sous « Activer le portail d’appareil ». 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 sur une connexion http. Vos commandes sont transmises et gérées par le portail d’appareil Windows s’exécutant sur l’appareil ou l’émulateur. Les quatre paramètres que vous devez 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 de faible priorité, la connexion la plus récente établie est en contrôle.
Jeton System.Threading.CancellationToken : jeton pour 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 retourne 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 étendu d’application console C#

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 6DOF

Avant d’appeler des propriétés sur des méthodes sur un contrôleur 6 DOF simulé, vous devez activer le contrôleur. Cela entraîne une exception. À compter de la Mise à jour de mai 2019 de Windows 10, les contrôleurs 6DOF simulés peuvent être installés et activés en définissant la propriété Status sur l’objet ISimulatedSixDofController sur SimulatedSixDofControllerStatus.Active. Dans la mise à jour d’octobre 2018 de Windows 10 et les versions antérieures, vous devez d’abord installer un contrôleur 6DOF simulé en appelant 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 = supprimer

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 (une valeur de retour zéro) ou une défaillance (valeur de retour différente de zéro). Lorsque vous utilisez l’action « q » pour interroger si un contrôleur est installé, la valeur de retour est égale à zéro (0) si le contrôleur n’est pas déjà installé ou un (1) si le contrôleur est installé.

Lors de la suppression d’un contrôleur sur la mise à jour d’octobre 2018 windows 2018 ou une version antérieure, définissez d’abord son état 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

Un appareil de référence fictif, valeur par défaut pour PerceptionSimulationManager

Microsoft.PerceptionSimulation.HeadTrackerMode

Décrit un mode de suivi principal

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 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 à la fois 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 doigt appuyé sur le mouvement.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerReleased

Un doigt libéré.

Microsoft.PerceptionSimulation.SimulatedGesture.Home

Mouvement d’accueil/système.

Microsoft.PerceptionSimulation.SimulatedGesture.Max

Mouvement valide maximal.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus

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

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

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Off

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

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Active

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

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.TrackingLost

Le contrôleur 6DOF 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 Poignée 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 Pavé tactile est tactile.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Thumbstick

Le bâton de pouce est enfoncé.

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 étalonnés.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.UserCalibrationNeed

Les yeux doivent être étalonnés.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy

Précision de suivi d’une jointure 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 commune est déduite.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Visible

Le joint est entièrement suivi.

Microsoft.PerceptionSimulation.SimulatedHandPose

Précision de suivi d’une jointure de la main.

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

Microsoft.PerceptionSimulation.SimulatedHandPose.Closed

Les articulations du doigt 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 du doigt de la main sont configurées pour refléter une pose pointante.

Microsoft.PerceptionSimulation.SimulatedHandPose.Pinch

Les articulations du doigt 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,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, à droite autour de l’axe Y.

Microsoft.PerceptionSimulation.Rotation3.Roll

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

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

Construisez une nouvelle rotation3.

Paramètres

pitch : composant pitch 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 du joint.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Rotation

Rotation de l’articulation.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.TrackingAccuracy

Précision du suivi de l’articulation.

Microsoft.PerceptionSimulation.Frustum

Décrit un frustum d’affichage, comme 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 horizontal de vue du frustum, en radians (inférieur à PI).

Microsoft.PerceptionSimulation.Frustum.AspectRatio

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

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 oculaires gauche et droite 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’homme 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éinitialise la simulation à son état par défaut.

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 principal à partir de l’appareil simulé.

Microsoft.PerceptionSimulation.ISimulatedDevice.HandTracker

Récupérez le suivi des mains à partir de l’appareil simulé.

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

Définissez les propriétés de l’appareil simulé pour qu’il corresponde 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 sur 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 activement 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 principal 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 main simulé, par rapport au centre de la tête.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Pitch

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

Microsoft.PerceptionSimulation.ISimulatedHandTracker.FrustumIgnored

Récupérez et définissez si le frustum du suivi de la main simulé est ignoré. Lorsqu’elles sont ignorées, les deux mains sont toujours visibles. Quand les mains ne sont pas ignorées (par défaut) sont visibles uniquement 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 frustum utilisées pour déterminer si les mains sont visibles par le dispositif de suivi de main simulé.

Microsoft.PerceptionSimulation.ISimulatedHum

Interface de niveau supérieur pour contrôler 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.ISimulatedHum.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.ISimulatedHum.Direction

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

Microsoft.PerceptionSimulation.ISimulatedHum.Height

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

Microsoft.PerceptionSimulation.ISimulatedHum.LeftHand

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

Microsoft.PerceptionSimulation.ISimulated Human.RightHand

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

Microsoft.PerceptionSimulation.ISimulated Human.Head

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

Microsoft.PerceptionSimulation.ISimulatedHum.Move(Microsoft.PerceptionSimulation.Vector3)

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

Paramètres

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

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

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

Paramètres

radians - Quantité à faire pivoter autour de l’axe Y.

Microsoft.PerceptionSimulation.ISimulatedHum2

Des propriétés supplémentaires sont disponibles en faisant passer iSimulatedHuman à ISimulatedHum2

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

Microsoft.PerceptionSimulation.ISimulatedHum2.LeftController

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

Microsoft.PerceptionSimulation.ISimulatedHum2.RightController

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

Microsoft.PerceptionSimulation.ISimulatedHand

Interface décrivant une main de l’humain 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’homme, 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 simulatedDevice (autrement dit, si elle est en position d’être détectée par le HandTracker).

Microsoft.PerceptionSimulation.ISimulatedHand.EnsureVisible

Déplacez la main de telle sorte qu’elle soit visible à l’élément 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

traduction : montant à traduire la main simulée.

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

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

Paramètres

mouvement : mouvement à effectuer.

Microsoft.PerceptionSimulation.ISimulatedHand2

Des propriétés supplémentaires sont disponibles en cas de conversion d’un ISimulatedHand vers 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 en regardant le long de l’axe.

Microsoft.PerceptionSimulation.ISimulatedHand3

Des propriétés supplémentaires sont disponibles en cas de conversion d’un ISimulatedHand vers 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

Obtenez la configuration de jointure pour la jointure spécifiée.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetJointConfiguration

Définissez la configuration de jointure pour 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’entraîne pas de jointures reflétant immédiatement leurs configurations de jointures 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 en regardant 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)

Faire pivoter la tête simulée par rapport à sa rotation actuelle. Les radians positifs pivotent dans le sens des aiguilles d’une montre en regardant 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 sur 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’homme simulé.

Microsoft.PerceptionSimulation.ISimulatedSixDofController

Interface décrivant un contrôleur 6DOF 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. L’état du contrôleur doit être défini sur une valeur autre que Désactivé avant que les appels à déplacer, faire pivoter ou appuyer sur les 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

traduction : quantité à traduire le contrôleur simulé.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.PressButton(SimulatedSixDofControllerButton)

Appuyez sur un bouton sur le contrôleur simulé. Elle est détectée uniquement par le système si le contrôleur est activé.

Paramètres

bouton - Bouton à appuyer.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.ReleaseButton(SimulatedSixDofControllerButton)

Relâchez un bouton sur le contrôleur simulé. Elle est détectée uniquement par le système si le contrôleur est activé.

Paramètres

bouton - 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

Des propriétés et méthodes supplémentaires sont disponibles en castant 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 du stick simulé sur le contrôleur simulé.

Paramètres

x - Position horizontale du bâton.
y - Position verticale du bâton.

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

Définissez la position du stick simulé sur le contrôleur simulé.

Paramètres

x - Position horizontale du bâton.
y - Position verticale du bâton.

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’humain 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 en regardant le long de l’axe.

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

Faire pivoter les yeux simulés par rapport à sa rotation actuelle. Les radians positifs pivotent dans le sens des aiguilles d’une montre en regardant 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. Si vous jouez déjà, cet appel est ignoré.

Microsoft.PerceptionSimulation.ISimulationRecording.Pause

Suspend 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 (en intervalles de 100 nanosecondes à partir du début) et s’interrompt à cet emplacement. Si le temps dépasse la fin de l’enregistrement, il est suspendu au dernier frame.

Paramètres

cycles - Heure à laquelle rechercher.

Microsoft.PerceptionSimulation.ISimulationRecording.Stop

Arrête la lecture et réinitialise 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é quand 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 Perception Simulation.

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

récepteur : 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

chemin d’accès : 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

chemin d’accès : chemin d’accès du fichier à charger.
factory : fabrique utilisée par l’enregistrement pour la création d’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

chemin d’accès : chemin d’accès du fichier à charger.
factory : fabrique utilisée par l’enregistrement pour la création d’un ISimulationStreamSink si nécessaire.
rappel : rappel, qui reçoit les mises à jour qui reclassent l’état 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 à partir 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 tapé en interne et versionné.

Paramètres

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

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory

Objet qui crée ISimulationStreamSink.

public interface ISimulationStreamSinkFactory
{
    ISimulationStreamSink CreateSimulationStreamSink();
}

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory.CreateSimulationStreamSink()

Crée une instance unique d’ISimulationStreamSink.

Valeur retournée

Récepteur créé.

Partager via

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 étendu d’application console C#

Remarque sur les contrôleurs 6DOF

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.ISimulatedHum

Microsoft.PerceptionSimulation.ISimulatedHum2

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