Perception Simulation (Wahrnehmungssimulation)

Möchten Sie einen automatisierten Test für Ihre App erstellen? Möchten Sie, dass Ihre Tests über komponentenbasierte Komponententests hinausgehen und Ihre App wirklich end-to-end trainieren? Wahrnehmungssimulation ist das, wonach Sie suchen. Die Bibliothek Wahrnehmungssimulation sendet Eingabedaten von Menschen und der Welt an Ihre App, damit Sie Ihre Tests automatisieren können. Sie können beispielsweise die Eingabe eines Menschen simulieren, der auf eine bestimmte, wiederholbare Position schaut, und dann einen Gesten- oder Bewegungscontroller verwenden.

Die Wahrnehmungssimulation kann simulierte Eingaben wie diese an eine physische HoloLens, den HoloLens-Emulator (erste Generation), den HoloLens 2-Emulator oder einen PC senden, auf dem Mixed Reality Portal installiert ist. Die Wahrnehmungssimulation umgeht die Livesensoren auf einem Mixed Reality Gerät und sendet simulierte Eingaben an Anwendungen, die auf dem Gerät ausgeführt werden. Anwendungen empfangen diese Eingabeereignisse über dieselben APIs, die sie immer verwenden, und können den Unterschied zwischen der Ausführung mit realen Sensoren und der Wahrnehmungssimulation nicht erkennen. Die Wahrnehmungssimulation ist die gleiche Technologie, die auch von den HoloLens-Emulatoren verwendet wird, um simulierte Eingaben an den virtuellen HoloLens-Computer zu senden.

Um die Simulation im Code zu verwenden, erstellen Sie zunächst ein IPerceptionSimulationManager-Objekt. Von diesem Objekt aus können Sie Befehle ausgeben, um die Eigenschaften eines simulierten "Menschen" zu steuern, einschließlich Kopfposition, Handposition und Gesten. Sie können auch Bewegungscontroller aktivieren und bearbeiten.

Einrichten eines Visual Studio-Projekts für die Wahrnehmungssimulation

1. Installieren Sie den HoloLens-Emulator auf Ihrem Entwicklungs-PC. Der Emulator enthält die Bibliotheken, die Sie für die Wahrnehmungssimulation verwenden.

2. Erstellen Sie ein neues Visual Studio C#-Desktopprojekt (ein Konsolenprojekt eignet sich hervorragend für die ersten Schritte).

3. Fügen Sie ihrem Projekt die folgenden Binärdateien als Verweise hinzu (Project-Add-Reference>>...). Sie finden sie in %ProgramFiles(x86)%\Microsoft XDE\(version), z. B. %ProgramFiles(x86)%\Microsoft XDE\10.0.18362.0 für den HoloLens 2 Emulator.

   Hinweis

   Obwohl die Binärdateien Teil des HoloLens 2-Emulators sind, funktionieren sie auch für Windows Mixed Reality auf dem Desktop.)

   a. PerceptionSimulationManager.Interop.dll : Verwalteter C#-Wrapper für Wahrnehmungssimulation.
   b. PerceptionSimulationRest.dll : Bibliothek zum Einrichten eines Websocket-Kommunikationskanals für die HoloLens oder den Emulator.
   c. SimulationStream.Interop.dll: Freigegebene Typen für die Simulation.

4. Hinzufügen der binären PerceptionSimulationManager.dll der Implementierung zu Ihrem Projekt

   a. Fügen Sie es zunächst als Binärdatei zum Projekt hinzu (Project-Add-Existing>> Item...). Speichern Sie sie als Link, damit sie nicht in Ihren Projektquellordner kopiert wird.
   

   b. Stellen Sie dann sicher, dass sie beim Build in Ihren Ausgabeordner kopiert wird. Dies befindet sich im Eigenschaftenblatt für die Binärdatei.
   

5. Legen Sie Ihre aktive Lösungsplattform auf x64 fest. (Verwenden Sie die Configuration Manager, um einen Plattformeintrag für x64 zu erstellen, falls noch kein Eintrag vorhanden ist.)

Erstellen eines IPerceptionSimulation Manager-Objekts

Zum Steuern der Simulation geben Sie Updates für Objekte aus, die aus einem IPerceptionSimulationManager-Objekt abgerufen wurden. Der erste Schritt besteht darin, dieses Objekt abzurufen und mit Ihrem Zielgerät oder Emulator zu verbinden. Sie können die IP-Adresse Ihres Emulators abrufen, indem Sie auf der Symbolleiste auf die Schaltfläche Geräteportal klicken.

Geräteportal öffnen: Öffnen Sie das Windows-Geräteportal für das HoloLens-Betriebssystem im Emulator. Für Windows Mixed Reality kann dies in der Einstellungen-App unter "Aktualisieren & Sicherheit" und dann unter "Für Entwickler" im Abschnitt "Verbinden über:" unter "Geräteportal aktivieren" abgerufen werden. Notieren Sie sich sowohl die IP-Adresse als auch den Port.

Zunächst rufen Sie RestSimulationStreamSink.Create auf, um ein RestSimulationStreamSink-Objekt abzurufen. Dies ist das Zielgerät oder der Emulator, den Sie über eine HTTP-Verbindung steuern. Ihre Befehle werden an das Windows-Geräteportal übergeben und verarbeitet, das auf dem Gerät oder Emulator ausgeführt wird. Die vier Parameter, die Sie zum Erstellen eines Objekts benötigen, sind:

• Uri uri : IP-Adresse des Zielgeräts (z. B. "https://123.123.123.123" oder "https://123.123.123.123:50080")
• System.Net.NetworkCredential-Anmeldeinformationen: Benutzername/Kennwort zum Herstellen einer Verbindung mit dem Windows-Geräteportal auf dem Zielgerät oder Emulator. Wenn Sie über die lokale Adresse (z. B. 168..) eine Verbindung mit dem Emulator herstellen. *) Auf demselben PC werden alle Anmeldeinformationen akzeptiert.
• bool normal : True für die normale Priorität, false für niedrige Priorität. In der Regel möchten Sie dies für Testszenarien auf true festlegen, sodass Ihr Test die Kontrolle übernehmen kann. Der Emulator und Windows Mixed Reality Simulation verwenden Verbindungen mit niedriger Priorität. Wenn ihr Test auch eine Verbindung mit niedriger Priorität verwendet, wird die zuletzt hergestellte Verbindung gesteuert.
• System.Threading.CancellationToken-Token: Token zum Abbrechen des asynchronen Vorgangs.

Zweitens erstellen Sie den IPerceptionSimulationManager. Dies ist das Objekt, das Sie zum Steuern der Simulation verwenden. Dies muss auch in einer asynchronen Methode erfolgen.

Steuern des simulierten Menschen

Ein IPerceptionSimulationManager verfügt über eine Human-Eigenschaft, die ein ISimulatedHuman-Objekt zurückgibt. Um den simulierten Menschen zu steuern, führen Sie Vorgänge für dieses Objekt aus. Beispiel:

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

Einfache c#-Beispielkonsolenanwendung

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();
        }
    }
}

Erweiterte C#-Beispielkonsolenanwendung

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);
            }
        }
    }
}

Hinweis zu 6-DOF-Controllern

Vor dem Aufrufen von Eigenschaften für Methoden auf einem simulierten 6-DOF-Controller müssen Sie den Controller aktivieren. Wenn dies nicht geschieht, führt dies zu einer Ausnahme. Ab dem Windows 10 May 2019 Update können simulierte 6-DOF-Controller installiert und aktiviert werden, indem die Status-Eigenschaft für das ISimulatedSixDofController-Objekt auf SimulatedSixDofControllerStatus.Active festgelegt wird. In der Windows 10 October 2018 Update und früher müssen Sie zuerst einen simulierten 6-DOF-Controller separat installieren, indem Sie das Tool PerceptionSimulationDevice im Ordner \Windows\System32 aufrufen. Dieses Tool wird wie folgt verwendet:

    PerceptionSimulationDevice.exe <action> 6dof <instance>

Beispiel:

    PerceptionSimulationDevice.exe i 6dof 1

Unterstützte Aktionen sind:

• i = install
• q = query
• r = remove

Unterstützte Instanzen sind:

• 1 = der linke 6-DOF-Controller
• 2 = der richtige 6-DOF-Controller

Der Exitcode des Prozesses weist auf Erfolg (null Rückgabewert) oder Fehler (ein Rückgabewert ungleich null) hin. Wenn Sie die Aktion "q" verwenden, um abzufragen, ob ein Controller installiert ist, ist der Rückgabewert null (0), wenn der Controller noch nicht installiert ist, oder ein (1), wenn der Controller installiert ist.

Wenn Sie einen Controller auf dem Windows 10 October 2018 Update oder früher entfernen, legen Sie dessen status zuerst über die API auf Aus fest, und rufen Sie dann das Tool PerceptionSimulationDevice auf.

Dieses Tool muss als Administrator ausgeführt werden.

API-Referenz

Microsoft.PerceptionSimulation.SimulatedDeviceType

Beschreibt einen simulierten Gerätetyp

public enum SimulatedDeviceType
{
    Reference = 0
}

Microsoft.PerceptionSimulation.SimulatedDeviceType.Reference

Ein fiktives Referenzgerät, die Standardeinstellung für PerceptionSimulationManager

Microsoft.PerceptionSimulation.HeadTrackerMode

Beschreibt einen Head Tracker-Modus

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

Microsoft.PerceptionSimulation.HeadTrackerMode.Default

Standardkopfnachverfolgung. Dies bedeutet, dass das System den besten Head Tracking-Modus basierend auf den Laufzeitbedingungen auswählen kann.

Microsoft.PerceptionSimulation.HeadTrackerMode.Orientation

Nur Ausrichtung Head Tracking. Dies bedeutet, dass die nachverfolgte Position möglicherweise nicht zuverlässig ist und einige Funktionen, die von der Kopfposition abhängig sind, möglicherweise nicht verfügbar sind.

Microsoft.PerceptionSimulation.HeadTrackerMode.Position

Positionskopfnachverfolgung. Dies bedeutet, dass die Position und Ausrichtung des nachverfolgten Kopfs zuverlässig sind.

Microsoft.PerceptionSimulation.SimulatedGesture

Beschreibt eine simulierte Geste.

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

Microsoft.PerceptionSimulation.SimulatedGesture.None

Ein Sentinelwert, der verwendet wird, um keine Gesten anzugeben.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerPressed

Eine gedrückte Fingergeste.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerReleased

Eine losgelassene Fingerbewegung.

Microsoft.PerceptionSimulation.SimulatedGesture.Home

Die Start-/Systemgeste.

Microsoft.PerceptionSimulation.SimulatedGesture.Max

Die maximal gültige Geste.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus

Die möglichen Zustände eines simulierten 6-DOF-Controllers.

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

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Off

Der 6-DOF-Controller ist ausgeschaltet.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Active

Der 6-DOF-Controller wird aktiviert und nachverfolgt.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.TrackingLost

Der 6-DOF-Controller ist aktiviert, kann aber nicht nachverfolgt werden.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton

Die unterstützten Schaltflächen auf einem simulierten 6-DOF-Controller.

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

Ein Sentinelwert, der verwendet wird, um keine Schaltflächen anzugeben.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Home

Die Schaltfläche Start wird gedrückt.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Menu

Die Schaltfläche Menü wird gedrückt.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Grip

Die Taste "Grip" wird gedrückt.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadPress

Das TouchPad wird gedrückt.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Select

Die Schaltfläche Auswählen wird gedrückt.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadTouch

Das TouchPad wird berührt.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Thumbstick

Der Fingerabdruckstick wird gedrückt.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Max

Die maximal gültige Schaltfläche.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState

Der Kalibrierungszustand der simulierten Augen

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

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Nicht verfügbar

Die Augenkalibrierung ist nicht verfügbar.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Ready

Die Augen wurden kalibriert. Dies ist der Standardwert.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Configuring

Die Augen werden kalibriert.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.UserCalibrationNeeded

Die Augen müssen kalibriert werden.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy

Die Nachverfolgungsgenauigkeit eines Handgelenks.

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

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Nicht verfügbar

Das Gelenk wird nicht nachverfolgt.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Approximate

Die gemeinsame Position wird abgeleitet.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Visible

Das Gelenk wird vollständig nachverfolgt.

Microsoft.PerceptionSimulation.SimulatedHandPose

Die Nachverfolgungsgenauigkeit eines Handgelenks.

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

Microsoft.PerceptionSimulation.SimulatedHandPose.Closed

Die Fingergelenke der Hand sind so konfiguriert, dass sie eine geschlossene Pose widerspiegeln.

Microsoft.PerceptionSimulation.SimulatedHandPose.Open

Die Fingergelenke der Hand sind so konfiguriert, dass sie eine offene Pose widerspiegeln.

Microsoft.PerceptionSimulation.SimulatedHandPose.Point

Die Fingergelenke der Hand sind so konfiguriert, dass sie eine zeigende Pose widerspiegeln.

Microsoft.PerceptionSimulation.SimulatedHandPose.Pinch

Die Fingergelenke der Hand sind so konfiguriert, dass sie eine zusammendrückende Pose widerspiegeln.

Microsoft.PerceptionSimulation.SimulatedHandPose.Max

Der maximal gültige Wert für SimulatedHandPose.

Microsoft.PerceptionSimulation.PlaybackState

Beschreibt den Zustand einer Wiedergabe.

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

Microsoft.PerceptionSimulation.PlaybackState.Stopped

Die Aufzeichnung ist derzeit beendet und bereit für die Wiedergabe.

Microsoft.PerceptionSimulation.PlaybackState.Playing

Die Aufzeichnung wird derzeit wiedergegeben.

Microsoft.PerceptionSimulation.PlaybackState.Paused

Die Aufzeichnung ist derzeit angehalten.

Microsoft.PerceptionSimulation.PlaybackState.End

Die Aufzeichnung hat das Ende erreicht.

Microsoft.PerceptionSimulation.Vector3

Beschreibt einen Vektor mit drei Komponenten, der einen Punkt oder einen Vektor im 3D-Raum beschreiben kann.

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

Microsoft.PerceptionSimulation.Vector3.X

Die X-Komponente des Vektors.

Microsoft.PerceptionSimulation.Vector3.Y

Die Y-Komponente des Vektors.

Microsoft.PerceptionSimulation.Vector3.Z

Die Z-Komponente des Vektors.

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

Erstellen Sie einen neuen Vector3.

Parameter

• x: Die x-Komponente des Vektors.
• y: Die y-Komponente des Vektors.
• z: Die z-Komponente des Vektors.

Microsoft.PerceptionSimulation.Rotation3

Beschreibt eine Drehung mit drei Komponenten.

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

Microsoft.PerceptionSimulation.Rotation3.Pitch

Die Pitch-Komponente der Drehung um die X-Achse nach unten.

Microsoft.PerceptionSimulation.Rotation3.Yaw

Die Gier-Komponente der Drehung, direkt um die Y-Achse.

Microsoft.PerceptionSimulation.Rotation3.Roll

Die Rolle-Komponente der Drehung, direkt um die Z-Achse.

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

Erstellen Sie eine neue Drehung3.

Parameter

• Pitch: Die Tonhöhenkomponente der Drehung.
• yaw: Die Gierkomponente der Drehung.
• roll: Die Rolle-Komponente der Drehung.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration

Beschreibt die Konfiguration eines Gelenks auf einer simulierten Hand.

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

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Position

Die Position des Gelenks.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Rotation

Die Drehung des Gelenks.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.TrackingAccuracy

Die Nachverfolgungsgenauigkeit des Gelenks.

Microsoft.PerceptionSimulation.Frustum

Beschreibt ein Ansichts frustum, wie es in der Regel von einer Kamera verwendet wird.

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

Microsoft.PerceptionSimulation.Frustum.Near

Der Mindestabstand, der im Frustum enthalten ist.

Microsoft.PerceptionSimulation.Frustum.Far

Der maximale Abstand, der im Frustum enthalten ist.

Microsoft.PerceptionSimulation.Frustum.FieldOfView

Das horizontale Sichtfeld des Frustums im Bogenmaß (kleiner als PI).

Microsoft.PerceptionSimulation.Frustum.AspectRatio

Das Verhältnis zwischen horizontalem Sichtfeld und vertikalem Sichtfeld.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration

Beschreibt die Konfiguration der Anzeige des simulierten Headsets.

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

Die Transformation von der Kopfmitte zum linken Auge für Stereorenderingzwecke.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.LeftEyeRotation

Die Drehung des linken Auges zum Zwecke des Stereorenderings.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyePosition

Die Transformation von der Kopfmitte auf das rechte Auge für Stereorendering.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyeRotation

Die Drehung des rechten Auges zum Zwecke des Stereorenderings.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.Ipd

Der ipd-Wert, der vom System für Stereorenderings gemeldet wird.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyEyeTransforms

Gibt an, ob die für Transformationen des linken und rechten Auges bereitgestellten Werte als gültig betrachtet und auf das ausgeführte System angewendet werden sollen.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyIpd

Gibt an, ob der für Ipd bereitgestellte Wert als gültig betrachtet und auf das ausgeführte System angewendet werden soll.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager

Stamm zum Generieren der Pakete, die zum Steuern eines Geräts verwendet werden.

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

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Device

Rufen Sie das simulierte Geräteobjekt ab, das den simulierten Menschen und die simulierte Welt interpretiert.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Human

Rufen Sie das Objekt ab, das den simulierten Menschen steuert.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Reset

Setzt die Simulation auf den Standardzustand zurück.

Microsoft.PerceptionSimulation.ISimulatedDevice

Schnittstelle, die das Gerät beschreibt, das die simulierte Welt und den simulierten Menschen interpretiert

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

Microsoft.PerceptionSimulation.ISimulatedDevice.HeadTracker

Rufen Sie den Head Tracker vom simulierten Gerät ab.

Microsoft.PerceptionSimulation.ISimulatedDevice.HandTracker

Rufen Sie den Handtracker aus dem simulierten Gerät ab.

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

Legen Sie die Eigenschaften des simulierten Geräts so fest, dass sie dem angegebenen Gerätetyp entsprechen.

Parameter

• type: Der neue Typ des simulierten Geräts

Microsoft.PerceptionSimulation.ISimulatedDevice2

Zusätzliche Eigenschaften sind verfügbar, indem Sie ISimulatedDevice in ISimulatedDevice2 umwandeln.

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

};

Microsoft.PerceptionSimulation.ISimulatedDevice2.IsUserPresent

Rufen Sie ab, oder legen Sie fest, ob der simulierte Mensch das Headset aktiv trägt oder nicht.

Microsoft.PerceptionSimulation.ISimulatedDevice2.DisplayConfiguration

Rufen Sie die Eigenschaften der simulierten Anzeige ab, oder legen Sie sie fest.

Microsoft.PerceptionSimulation.ISimulatedHeadTracker

Schnittstelle, die den Teil des simulierten Geräts beschreibt, das den Kopf des simulierten Menschen verfolgt.

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

Microsoft.PerceptionSimulation.ISimulatedHeadTracker.HeadTrackerMode

Ruft den aktuellen Headtrackermodus ab und legt den modus fest.

Microsoft.PerceptionSimulation.ISimulatedHandTracker

Schnittstelle, die den Teil des simulierten Geräts beschreibt, das die Hände des simulierten Menschen nachverfolgt

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

Rufen Sie die Position des Knotens in Bezug auf die Welt in Metern ab.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Position

Rufen Sie die Position des simulierten Handtrackers relativ zur Kopfmitte ab, und legen Sie sie fest.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Pitch

Rufen Sie den simulierten Handtracker ab, und legen Sie sie nach unten fest.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.FrustumIgnored

Rufen Sie ab, und legen Sie fest, ob das Frustum des simulierten Handtrackers ignoriert wird. Wenn sie ignoriert werden, sind beide Hände immer sichtbar. Wenn sie nicht ignoriert werden (die Standardhand), sind hände nur sichtbar, wenn sie sich innerhalb des Frustums des Handtracker befinden.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Frustum

Rufen Sie die frustum-Eigenschaften ab, die verwendet werden, um zu bestimmen, ob Hände für den simulierten Handtracker sichtbar sind.

Microsoft.PerceptionSimulation.ISimulatedHuman

Schnittstelle auf oberster Ebene zum Steuern des simulierten Menschen.

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

Rufen Sie die Position des Knotens mit Bezug zur Welt in Metern ab, und legen Sie sie fest. Die Position entspricht einem Punkt in der Mitte der Füße des Menschen.

Microsoft.PerceptionSimulation.ISimulatedHuman.Direction

Rufen Sie die Richtung der simulierten menschlichen Gesichter in der Welt ab, und legen Sie sie fest. 0 Bogenmaß nach unten auf der negativen Z-Achse. Positive Bogenmaße drehen sich im Uhrzeigersinn um die Y-Achse.

Microsoft.PerceptionSimulation.ISimulatedHuman.Height

Rufen Sie die Höhe des simulierten Menschen in Metern ab, und legen Sie sie fest.

Microsoft.PerceptionSimulation.ISimulatedHuman.LeftHand

Rufen Sie die linke Hand des simulierten Menschen ab.

Microsoft.PerceptionSimulation.ISimulatedHuman.RightHand

Rufen Sie die rechte Hand des simulierten Menschen ab.

Microsoft.PerceptionSimulation.ISimulatedHuman.Head

Rufen Sie den Kopf des simulierten Menschen ab.

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

Bewegen Sie den simulierten Menschen relativ zu seiner aktuellen Position in Metern.

Parameter

• translation: Die zu verschiebende Übersetzung relativ zur aktuellen Position.

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

Drehen Sie den simulierten Menschen relativ zu seiner aktuellen Richtung, im Uhrzeigersinn um die Y-Achse

Parameter

• Bogenmaße: Der Betrag, der um die Y-Achse gedreht werden soll.

Microsoft.PerceptionSimulation.ISimulatedHuman2

Zusätzliche Eigenschaften sind verfügbar, indem Sie ISimulatedHuman in ISimulatedHuman2 umwandeln.

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

Microsoft.PerceptionSimulation.ISimulatedHuman2.LeftController

Rufen Sie den linken 6-DOF-Controller ab.

Microsoft.PerceptionSimulation.ISimulatedHuman2.RightController

Rufen Sie den richtigen 6-DOF-Controller ab.

Microsoft.PerceptionSimulation.ISimulatedHand

Schnittstelle, die eine Hand des simulierten Menschen beschreibt

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

Rufen Sie die Position des Knotens in Bezug auf die Welt in Metern ab.

Microsoft.PerceptionSimulation.ISimulatedHand.Position

Rufen Sie die Position der simulierten Hand relativ zum Menschen in Metern ab, und legen Sie sie fest.

Microsoft.PerceptionSimulation.ISimulatedHand.Activated

Rufen Sie ab, und legen Sie fest, ob die Hand gerade aktiviert ist.

Microsoft.PerceptionSimulation.ISimulatedHand.Visible

Rufen Sie ab, ob die Hand derzeit für das SimulatedDevice sichtbar ist (d. a. ob sie sich in einer Position befindet, die vom HandTracker erkannt werden soll).

Microsoft.PerceptionSimulation.ISimulatedHand.EnsureVisible

Bewegen Sie die Hand so, dass sie für das SimulatedDevice sichtbar ist.

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

Verschieben Sie die Position der simulierten Hand relativ zur aktuellen Position in Metern.

Parameter

• Übersetzung: Der Betrag, der die simulierte Hand übersetzt werden soll.

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

Führen Sie eine Geste mit der simulierten Hand aus. Sie wird vom System nur erkannt, wenn die Hand aktiviert ist.

Parameter

• geste: Die auszuführende Geste.

Microsoft.PerceptionSimulation.ISimulatedHand2

Zusätzliche Eigenschaften sind verfügbar, indem Sie eine ISimulatedHand in ISimulatedHand2 umwandeln.

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

Microsoft.PerceptionSimulation.ISimulatedHand2.Orientation

Rufen Sie die Drehung der simulierten Hand ab, oder legen Sie sie fest. Positive Bogenmaße drehen sich im Uhrzeigersinn, wenn sie entlang der Achse betrachtet werden.

Microsoft.PerceptionSimulation.ISimulatedHand3

Zusätzliche Eigenschaften sind verfügbar, indem Sie eine ISimulatedHand in ISimulatedHand3 umwandeln.

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

Rufen Sie die Gelenkkonfiguration für den angegebenen Joint ab.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetJointConfiguration

Legen Sie die Gelenkkonfiguration für den angegebenen Gelenk fest.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetHandPose

Legen Sie die Hand auf eine bekannte Pose mit einem optionalen Flag zum Animieren fest. Hinweis: Das Animieren führt nicht dazu, dass Gelenke ihre endgültigen Gelenkkonfigurationen sofort widerspiegeln.

Microsoft.PerceptionSimulation.ISimulatedHead

Schnittstelle, die den Kopf des simulierten Menschen beschreibt.

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

Microsoft.PerceptionSimulation.ISimulatedHead.WorldPosition

Rufen Sie die Position des Knotens in Bezug auf die Welt in Metern ab.

Microsoft.PerceptionSimulation.ISimulatedHead.Rotation

Rufen Sie die Drehung des simulierten Kopfs ab. Positive Bogenmaße drehen sich im Uhrzeigersinn, wenn sie entlang der Achse betrachtet werden.

Microsoft.PerceptionSimulation.ISimulatedHead.Diameter

Rufen Sie den Durchmesser des simulierten Kopfes ab. Dieser Wert wird verwendet, um den Mittelpunkt des Kopfes (Drehpunkt) zu bestimmen.

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

Drehen Sie den simulierten Kopf relativ zur aktuellen Drehung. Positive Bogenmaße drehen sich im Uhrzeigersinn, wenn sie entlang der Achse betrachtet werden.

Parameter

• Drehung: Die zu drehende Menge.

Microsoft.PerceptionSimulation.ISimulatedHead2

Zusätzliche Eigenschaften sind verfügbar, indem Sie einen ISimulatedHead in ISimulatedHead2 umwandeln.

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

Microsoft.PerceptionSimulation.ISimulatedHead2.Eyes

Rufen Sie die Augen des simulierten Menschen ab.

Microsoft.PerceptionSimulation.ISimulatedSixDofController

Schnittstelle, die einen 6-DOF-Controller beschreibt, der dem simulierten Menschen zugeordnet ist.

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

Rufen Sie die Position des Knotens in Bezug auf die Welt in Metern ab.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Status

Rufen Sie den aktuellen Status des Controllers ab, oder legen Sie den aktuellen Status fest. Der Controller status muss auf einen anderen Wert als Aus festgelegt werden, bevor Aufrufe zum Verschieben, Drehen oder Drücken von Schaltflächen erfolgreich sind.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Position

Rufen Sie die Position des simulierten Controllers relativ zum Menschen in Metern ab, oder legen Sie sie fest.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Orientation

Rufen Sie die Ausrichtung des simulierten Controllers ab, oder legen Sie sie fest.

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

Verschieben Sie die Position des simulierten Controllers relativ zur aktuellen Position in Metern.

Parameter

• Translation: Der Betrag, der für die Übersetzung des simulierten Controllers verwendet werden soll.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.PressButton(SimulatedSixDofControllerButton)

Drücken Sie eine Schaltfläche auf dem simulierten Controller. Sie wird vom System nur erkannt, wenn der Controller aktiviert ist.

Parameter

• -Schaltfläche: Die Schaltfläche, die gedrückt werden soll.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.ReleaseButton(SimulatedSixDofControllerButton)

Lassen Sie eine Schaltfläche auf dem simulierten Controller los. Sie wird vom System nur erkannt, wenn der Controller aktiviert ist.

Parameter

• button: Die Schaltfläche, die losgelöst werden soll.

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

Rufen Sie die Position eines simulierten Fingers auf dem Touchpad des simulierten Controllers ab.

Parameter

• x: Die horizontale Position des Fingers.
• y: Die vertikale Position des Fingers.

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

Legen Sie die Position eines simulierten Fingers auf dem Touchpad des simulierten Controllers fest.

Parameter

• x: Die horizontale Position des Fingers.
• y: Die vertikale Position des Fingers.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2

Zusätzliche Eigenschaften und Methoden sind verfügbar, indem Sie einen ISimulatedSixDofController in ISimulatedSixDofController2 umwandeln.

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)

Ruft die Position des simulierten Fingerabdrucksticks auf dem simulierten Controller ab.

Parameter

• x: Die horizontale Position des Fingerabdrucks.
• y: Die vertikale Position des Fingerabdrucks.

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

Legen Sie die Position des simulierten Fingerabdrucksticks auf dem simulierten Controller fest.

Parameter

• x: Die horizontale Position des Fingerabdrucks.
• y: Die vertikale Position des Fingerabdrucks.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2.BatteryLevel

Rufen Sie den Akkustand des simulierten Controllers ab, oder legen Sie sie fest. Der Wert muss größer als 0,0 und kleiner oder gleich 100,0 sein.

Microsoft.PerceptionSimulation.ISimulatedEyes

Schnittstelle, die die Augen des simulierten Menschen beschreibt.

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

Microsoft.PerceptionSimulation.ISimulatedEyes.Rotation

Ruft die Drehung der simulierten Augen ab. Positive Bogenmaße drehen sich im Uhrzeigersinn, wenn sie entlang der Achse betrachtet werden.

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

Drehen Sie die simulierten Augen relativ zur aktuellen Drehung. Positive Bogenmaße drehen sich im Uhrzeigersinn, wenn sie entlang der Achse betrachtet werden.

Parameter

• Rotation: Der zu drehende Betrag.

Microsoft.PerceptionSimulation.ISimulatedEyes.CalibrationState

Ruft den Kalibrierungszustand der simulierten Augen ab oder legt diese fest.

Microsoft.PerceptionSimulation.ISimulatedEyes.WorldPosition

Rufen Sie die Position des Knotens in Bezug auf die Welt in Metern ab.

Microsoft.PerceptionSimulation.ISimulationRecording

Schnittstelle für die Interaktion mit einer einzelnen Aufzeichnung, die für die Wiedergabe geladen wird.

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

Microsoft.PerceptionSimulation.ISimulationRecording.DataTypes

Ruft die Liste der Datentypen in der Aufzeichnung ab.

Microsoft.PerceptionSimulation.ISimulationRecording.State

Ruft den aktuellen Zustand der Aufzeichnung ab.

Microsoft.PerceptionSimulation.ISimulationRecording.Play

Starten Sie die Wiedergabe. Wenn die Aufzeichnung angehalten wird, wird die Wiedergabe vom angehaltenen Speicherort fortgesetzt. Wenn der Vorgang beendet wird, beginnt die Wiedergabe am Anfang. Wenn bereits wiedergegeben wird, wird dieser Aufruf ignoriert.

Microsoft.PerceptionSimulation.ISimulationRecording.Pause

Hält die Wiedergabe an der aktuellen Position an. Wenn die Aufzeichnung beendet wird, wird der Aufruf ignoriert.

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

Sucht die Aufzeichnung bis zur angegebenen Zeit (von Anfang an in Intervallen von 100 Nanosekunden) und hält an dieser Stelle an. Wenn die Zeit nach dem Ende der Aufzeichnung liegt, wird sie am letzten Frame angehalten.

Parameter

• ticks : Die Zeit, zu der gesucht werden soll.

Microsoft.PerceptionSimulation.ISimulationRecording.Stop

Beendet die Wiedergabe und setzt die Position auf den Anfang zurück.

Microsoft.PerceptionSimulation.ISimulationRecordingCallback

Schnittstelle zum Empfangen von Zustandsänderungen während der Wiedergabe.

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

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

Wird aufgerufen, wenn sich der Wiedergabezustand eines ISimulationRecording geändert hat.

Parameter

• newState: Der neue Zustand der Aufzeichnung.

Microsoft.PerceptionSimulation.PerceptionSimulationManager

Stammobjekt zum Erstellen von Perception Simulation-Objekten.

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)

Erstellen Sie im -Objekt, um simulierte Pakete zu generieren und an die bereitgestellte Senke zu übermitteln.

Parameter

• Senke: Die Senke, die alle generierten Pakete empfängt.

Rückgabewert

Der erstellte Manager.

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

Erstellen Sie eine Senke, die alle empfangenen Pakete in einer Datei unter dem angegebenen Pfad speichert.

Parameter

• path: Der Pfad der zu erstellenden Datei.

Rückgabewert

Die erstellte Senke.

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

Laden Sie eine Aufzeichnung aus der angegebenen Datei.

Parameter

• path: Der Pfad der zu ladenden Datei.
• factory: Eine Factory, die bei Bedarf von der Aufzeichnung zum Erstellen eines ISimulationStreamSink verwendet wird.

Rückgabewert

Die geladene Aufzeichnung.

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

Laden Sie eine Aufzeichnung aus der angegebenen Datei.

Parameter

• path: Der Pfad der zu ladenden Datei.
• factory: Eine Factory, die bei Bedarf von der Aufzeichnung zum Erstellen eines ISimulationStreamSink verwendet wird.
• Rückruf: Ein Rückruf, der Aktualisierungen empfängt, die die status der Aufzeichnung umstufen.

Rückgabewert

Die geladene Aufzeichnung.

Microsoft.PerceptionSimulation.StreamDataTypes

Beschreibt die verschiedenen Arten von Datenstromdaten.

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

Ein Sentinelwert, der verwendet wird, um keine Streamdatentypen anzugeben.

Microsoft.PerceptionSimulation.StreamDataTypes.Head

Datenstrom für die Position und Ausrichtung des Kopfes.

Microsoft.PerceptionSimulation.StreamDataTypes.Hands

Datenstrom für die Position und Gesten der Hände.

Microsoft.PerceptionSimulation.StreamDataTypes.SpatialMapping

Datenstrom für die räumliche Zuordnung der Umgebung.

Microsoft.PerceptionSimulation.StreamDataTypes.Calibration

Datenstrom für die Kalibrierung des Geräts. Kalibrierungspakete werden nur von einem System im Remotemodus akzeptiert.

Microsoft.PerceptionSimulation.StreamDataTypes.Environment

Datenstrom für die Umgebung des Geräts.

Microsoft.PerceptionSimulation.StreamDataTypes.SixDofControllers

Datenstrom für Motion-Controller.

Microsoft.PerceptionSimulation.StreamDataTypes.Eyes

Datenstrom mit den Augen des simulierten Menschen.

Microsoft.PerceptionSimulation.StreamDataTypes.DisplayConfiguration

Datenstrom mit der Anzeigekonfiguration des Geräts.

Microsoft.PerceptionSimulation.StreamDataTypes.All

Ein Sentinelwert, der verwendet wird, um alle aufgezeichneten Datentypen anzugeben.

Microsoft.PerceptionSimulation.ISimulationStreamSink

Ein Objekt, das Datenpakete aus einem Simulationsdatenstrom empfängt.

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

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

Empfängt ein einzelnes Paket, das intern typisiert und versioniert ist.

Parameter

• length: Die Länge des Pakets.
• packet: Die Daten des Pakets.

Microsoft.PerceptionSimulation.ISimulationStreamsinkFactory

Ein -Objekt, das ISimulationStreamSink erstellt.

public interface ISimulationStreamSinkFactory
{
    ISimulationStreamSink CreateSimulationStreamSink();
}

Microsoft.PerceptionSimulation.ISimulationStreamsinkFactory.CreateSimulationStreamSink()

Erstellt eine einzelne instance von ISimulationStreamSink.

Rückgabewert

Die erstellte Senke.