Perceptiesimulatie

Wilt u een geautomatiseerde test voor uw app bouwen? Wilt u dat uw tests verder gaan dan eenheidstests op onderdeelniveau en uw app echt end-to-end trainen? Perception Simulation is wat u zoekt. De Perception Simulation-bibliotheek verzendt menselijke en wereldinvoergegevens naar uw app, zodat u uw tests kunt automatiseren. U kunt bijvoorbeeld de invoer simuleren van een mens die een specifieke, herhaalbare positie zoekt en vervolgens een beweging of bewegingscontroller gebruikt.

Perception Simulation kan gesimuleerde invoer zoals deze verzenden naar een fysieke HoloLens, de HoloLens-emulator (eerste generatie), de HoloLens 2 Emulator of een pc waarop Mixed Reality Portal is geïnstalleerd. Perception Simulation omzeilt de livesensoren op een Mixed Reality-apparaat en verzendt gesimuleerde invoer naar toepassingen die op het apparaat worden uitgevoerd. Toepassingen ontvangen deze invoer gebeurtenissen via dezelfde API's die ze altijd gebruiken en kunnen het verschil tussen het uitvoeren met echte sensoren versus Perception Simulation niet zien. Perception Simulation is dezelfde technologie die wordt gebruikt door de HoloLens-emulators om gesimuleerde invoer naar de virtuele HoloLens-machine te verzenden.

Als u simulatie in uw code wilt gaan gebruiken, begint u met het maken van een IPerceptionSimulationManager-object. Vanuit dat object kunt u opdrachten geven om eigenschappen van een gesimuleerde 'mens' te beheren, waaronder hoofdpositie, handpositie en bewegingen. U kunt ook bewegingscontrollers inschakelen en bewerken.

Een Visual Studio-project instellen voor perceptionsimulatie

1. Installeer de HoloLens-emulator op uw ontwikkel-pc. De emulator bevat de bibliotheken die u gebruikt voor Perception Simulation.

2. Maak een nieuw Visual Studio C#-bureaubladproject (een consoleproject werkt uitstekend om aan de slag te gaan).

3. Voeg de volgende binaire bestanden toe aan uw project als verwijzingen (Project-Add-Reference>>...). U vindt ze in %ProgramFiles(x86)%\Microsoft XDE\(versie), zoals %ProgramFiles(x86)%\Microsoft XDE\10.0.18362.0 voor de HoloLens 2 Emulator.

   Notitie

   Hoewel de binaire bestanden deel uitmaken van de HoloLens 2 Emulator, werken ze ook voor Windows Mixed Reality op het bureaublad.)

   a. PerceptionSimulationManager.Interop.dll - Beheerde C#-wrapper voor Perception Simulation.
   b. PerceptionSimulationRest.dll - Bibliotheek voor het instellen van een websocketcommunicatiekanaal voor de HoloLens of emulator.
   c. SimulationStream.Interop.dll - Gedeelde typen voor simulatie.

4. Voeg de binaire implementatie-PerceptionSimulationManager.dll toe aan uw project

   a. Voeg deze eerst toe als een binair bestand aan het project (Project-Add-Existing>> Item...). Sla deze op als een koppeling, zodat deze niet naar de projectbronmap wordt gekopieerd.
   

   b. Zorg er vervolgens voor dat deze wordt gekopieerd naar de uitvoermap in de build. Dit staat in het eigenschappenvenster voor het binaire bestand.
   

5. Stel uw actieve oplossingsplatform in op x64. (Gebruik Configuration Manager om een platformvermelding voor x64 te maken als deze nog niet bestaat.)

Een IPerceptionSimulation Manager-object maken

Als u simulatie wilt beheren, geeft u updates uit aan objecten die zijn opgehaald uit een IPerceptionSimulationManager-object. De eerste stap is het ophalen van dat object en het verbinden met uw doelapparaat of emulator. U kunt het IP-adres van uw emulator ophalen door op de knop Apparaatportal op de werkbalk te klikken

Open de apparaatportal: open de Windows-apparaatportal voor het HoloLens-besturingssysteem in de emulator. Voor Windows Mixed Reality kan dit worden opgehaald in de app Instellingen onder 'Update en beveiliging', en vervolgens 'Voor ontwikkelaars' in de sectie Verbinding maken met behulp van:onder 'Apparaatportal inschakelen'. Noteer zowel het IP-adres als de poort.

Eerst roept u RestSimulationStreamSink.Create aan om een RestSimulationStreamSink-object op te halen. Dit is het doelapparaat of de emulator die u wilt beheren over een HTTP-verbinding. Uw opdrachten worden doorgegeven aan en verwerkt door de Windows-apparaatportal die wordt uitgevoerd op het apparaat of de emulator. De vier parameters die u nodig hebt om een object te maken, zijn:

• Uri-URI - IP-adres van het doelapparaat (bijvoorbeeld "https://123.123.123.123" of "https://123.123.123.123:50080")
• System.Net.NetworkCredential-referenties : gebruikersnaam/wachtwoord voor het maken van verbinding met de Windows-apparaatportal op het doelapparaat of de emulator. Als u verbinding maakt met de emulator via het lokale adres (bijvoorbeeld 168.. *) op dezelfde pc worden alle referenties geaccepteerd.
• bool normaal - Waar voor normale prioriteit, onwaar voor lage prioriteit. Over het algemeen wilt u dit instellen op waar voor testscenario's, waardoor uw test de controle kan overnemen. De emulator en Windows Mixed Reality-simulatie maken gebruik van verbindingen met lage prioriteit. Als uw test ook gebruikmaakt van een verbinding met lage prioriteit, is de laatst tot stand gebrachte verbinding in controle.
• System.Threading.CancellationTokentoken - Token om de asynchrone bewerking te annuleren.

Ten tweede maakt u de IPerceptionSimulationManager. Dit is het object dat u gebruikt om simulatie te beheren. Dit moet ook worden gedaan in een asynchrone methode.

De gesimuleerde mens beheren

Een IPerceptionSimulationManager heeft een eigenschap Human die een ISimulated Human-object retourneert. Als u de gesimuleerde mens wilt beheren, voert u bewerkingen uit op dit object. Voorbeeld:

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

Basic Sample C#-consoletoepassing

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

Uitgebreide C#-voorbeeldconsoletoepassing

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

Opmerking over 6 DOF-controllers

Voordat u eigenschappen aanroept voor methoden op een gesimuleerde 6-DOF-controller, moet u de controller activeren. Als u dit niet doet, resulteert dit in een uitzondering. Vanaf de Update van Windows 10 mei 2019 kunnen gesimuleerde 6-DOF-controllers worden geïnstalleerd en geactiveerd door de eigenschap Status in te stellen op het object ISimulatedSixDofController op SimulatedSixDofControllerStatus.Active. In de Update van Windows 10 oktober 2018 en eerder moet u eerst een gesimuleerde 6-DOF-controller installeren door het hulpprogramma PerceptionSimulationDevice in de map \Windows\System32 aan te roepen. Het gebruik van dit hulpprogramma is als volgt:

    PerceptionSimulationDevice.exe <action> 6dof <instance>

Bijvoorbeeld

    PerceptionSimulationDevice.exe i 6dof 1

Ondersteunde acties zijn:

• i = installeren
• q = query
• r = verwijderen

Ondersteunde exemplaren zijn:

• 1 = de linker 6-DOF-controller
• 2 = de rechter 6-DOF-controller

De afsluitcode van het proces geeft aan dat het proces is geslaagd (een nul retourwaarde) of een fout (een niet-nul retourwaarde). Wanneer u de actie 'q' gebruikt om een query uit te voeren of een controller is geïnstalleerd, is de retourwaarde nul (0) als de controller nog niet is geïnstalleerd of één (1) als de controller is geïnstalleerd.

Wanneer u een controller verwijdert op de Update van Windows 10 oktober 2018 of eerder, stelt u eerst de status Uit in via de API en roept u vervolgens het hulpprogramma PerceptionSimulationDevice aan.

Dit hulpprogramma moet worden uitgevoerd als administrator.

API-verwijzing

Microsoft.PerceptionSimulation.SimulatedDeviceType

Beschrijft een gesimuleerd apparaattype

public enum SimulatedDeviceType
{
    Reference = 0
}

Microsoft.PerceptionSimulation.SimulatedDeviceType.Reference

Een fictief referentieapparaat, de standaardwaarde voor PerceptionSimulationManager

Microsoft.PerceptionSimulation.HeadTrackerMode

Beschrijft een head tracker-modus

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

Microsoft.PerceptionSimulation.HeadTrackerMode.Default

Standaard hoofdtracking. Dit betekent dat het systeem de beste modus voor het volgen van hoofden kan selecteren op basis van runtimevoorwaarden.

Microsoft.PerceptionSimulation.HeadTrackerMode.Orientation

Alleen richting hoofdtracering. Dit betekent dat de bijgehouden positie mogelijk niet betrouwbaar is en dat bepaalde functionaliteit die afhankelijk is van de hoofdpositie mogelijk niet beschikbaar is.

Microsoft.PerceptionSimulation.HeadTrackerMode.Position

Positionele hoofdtracering. Dit betekent dat de getraceerde koppositie en stand beide betrouwbaar zijn

Microsoft.PerceptionSimulation.SimulatedGesture

Beschrijft een gesimuleerde beweging

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

Microsoft.PerceptionSimulation.SimulatedGesture.None

Een sentinel-waarde die wordt gebruikt om geen gebaren aan te geven.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerPressed

Een vinger ingedrukt gebaar.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerReleased

Een vinger vrijgegeven gebaar.

Microsoft.PerceptionSimulation.SimulatedGesture.Home

Het thuis-/systeembeweging.

Microsoft.PerceptionSimulation.SimulatedGesture.Max

Het maximale geldige gebaar.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus

De mogelijke statussen van een gesimuleerde 6-DOF-controller.

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

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Off

De 6-DOF-controller is uitgeschakeld.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Active

De 6-DOF-controller is ingeschakeld en bijgehouden.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.TrackingLost

De 6-DOF-controller is ingeschakeld, maar kan niet worden bijgehouden.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton

De ondersteunde knoppen op een gesimuleerde 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

Een sentinel-waarde die wordt gebruikt om geen knoppen aan te geven.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Home

De knop Start wordt ingedrukt.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Menu

De menuknop wordt ingedrukt.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Grip

De gripknop wordt ingedrukt.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadPress

De TouchPad wordt ingedrukt.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Select

De knop Selecteren wordt ingedrukt.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadTouch

De TouchPad wordt aangeraakt.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Thumbstick

De duimstick wordt ingedrukt.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Max

De maximaal geldige knop.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState

De kalibratiestatus van de gesimuleerde ogen

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

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Unavailable

De kalibratie van de ogen is niet beschikbaar.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Ready

De ogen zijn gekalibreerd. Dit is de standaardwaarde.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Configuring

De ogen worden gekalibreerd.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.UserCalibrationNeeded

De ogen moeten gekalibreerd worden.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy

De nauwkeurigheid van het bijhouden van een gewricht van de hand.

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

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Unavailable

Het gewricht wordt niet bijgehouden.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Approximate

Het gemeenschappelijk standpunt wordt afgeleid.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Visible

Het gewricht is volledig bijgehouden.

Microsoft.PerceptionSimulation.SimulatedHandPose

De nauwkeurigheid van het bijhouden van een gewricht van de hand.

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

Microsoft.PerceptionSimulation.SimulatedHandPose.Closed

De vingerverbindingen van de hand zijn geconfigureerd om een gesloten houding weer te geven.

Microsoft.PerceptionSimulation.SimulatedHandPose.Open

De vingerverbindingen van de hand zijn geconfigureerd om een open pose weer te geven.

Microsoft.PerceptionSimulation.SimulatedHandPose.Point

De vingerverbindingen van de hand zijn geconfigureerd om een aanwijspositie weer te geven.

Microsoft.PerceptionSimulation.SimulatedHandPose.Pinch

De vingerverbindingen van de hand zijn geconfigureerd om een knijppositie weer te geven.

Microsoft.PerceptionSimulation.SimulatedHandPose.Max

De maximaal geldige waarde voor SimulatedHandPose.

Microsoft.PerceptionSimulation.PlaybackState

Beschrijft de status van het afspelen.

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

Microsoft.PerceptionSimulation.PlaybackState.Stopped

De opname is momenteel gestopt en kan worden afgespeeld.

Microsoft.PerceptionSimulation.PlaybackState.Playing

De opname wordt momenteel afgespeeld.

Microsoft.PerceptionSimulation.PlaybackState.Onderbroken

De opname is momenteel onderbroken.

Microsoft.PerceptionSimulation.PlaybackState.End

De opname heeft het einde bereikt.

Microsoft.PerceptionSimulation.Vector3

Beschrijft een vector van drie onderdelen, die een punt of een vector in de 3D-ruimte kan beschrijven.

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

Microsoft.PerceptionSimulation.Vector3.X

Het X-onderdeel van de vector.

Microsoft.PerceptionSimulation.Vector3.Y

Het Y-onderdeel van de vector.

Microsoft.PerceptionSimulation.Vector3.Z

Het Z-onderdeel van de vector.

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

Maak een nieuwe Vector3.

Parameters

• x - Het x-onderdeel van de vector.
• y - Het y-onderdeel van de vector.
• z - Het z-onderdeel van de vector.

Microsoft.PerceptionSimulation.Rotation3

Beschrijft een draaiing van drie onderdelen.

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

Microsoft.PerceptionSimulation.Rotation3.Pitch

Het pitch-onderdeel van de draaiing, omlaag rond de X-as.

Microsoft.PerceptionSimulation.Rotation3.Yaw

Het Yaw-onderdeel van de draaiing, direct rond de Y-as.

Microsoft.PerceptionSimulation.Rotation3.Roll

Het onderdeel Roll van de draaiing, direct rond de Z-as.

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

Maak een nieuwe rotatie3.

Parameters

• pitch - Het pitchonderdeel van de draaiing.
• yaw - Het yaw-onderdeel van de draaiing.
• roll - Het roll-onderdeel van de rotatie.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration

Beschrijft de configuratie van een joint op een gesimuleerde hand.

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

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Position

De positie van het gewricht.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Rotation

De draaiing van het gewricht.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.TrackingAccuracy

De nauwkeurigheid van het bijhouden van het gewricht.

Microsoft.PerceptionSimulation.Frustum

Beschrijft een weergave frustum, zoals meestal wordt gebruikt door een camera.

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

Microsoft.PerceptionSimulation.Frustum.near

De minimale afstand die zich in het frustum bevindt.

Microsoft.PerceptionSimulation.Frustum.Far

De maximale afstand die zich in het frustum bevindt.

Microsoft.PerceptionSimulation.Frustum.FieldOfView

Het horizontale weergaveveld van het frustum, in radialen (kleiner dan PI).

Microsoft.PerceptionSimulation.Frustum.AspectRatio

De verhouding van het horizontale weergaveveld tot het verticale weergaveveld.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration

Beschrijft de configuratie van de weergave van de gesimuleerde headset.

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

De transformatie van het midden van het hoofd naar het linkeroog voor stereorendering.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.LeftEyeRotation

De draaiing van het linkeroog voor stereorendering.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyePosition

De transformatie van het midden van het hoofd naar het juiste oog voor stereorendering.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyeRotation

De draaiing van het rechteroog voor stereorendering.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.Ipd

De Ipd-waarde die door het systeem wordt gerapporteerd voor stereorendering.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyEyeTransforms

Of de waarden die zijn opgegeven voor transformaties van het linker- en rechteroog, als geldig moeten worden beschouwd en toegepast op het actieve systeem.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyIpd

Of de opgegeven waarde voor Ipd moet worden beschouwd als geldig en toegepast op het actieve systeem.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager

Hoofdmap voor het genereren van de pakketten die worden gebruikt om een apparaat te beheren.

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

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Device

Haal het gesimuleerde apparaatobject op dat de gesimuleerde mens en de gesimuleerde wereld interpreteert.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Human

Haal het object op dat de gesimuleerde mens beheert.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Reset

Hiermee stelt u de simulatie opnieuw in op de standaardstatus.

Microsoft.PerceptionSimulation.ISimulatedDevice

Interface die het apparaat beschrijft, waarmee de gesimuleerde wereld en de gesimuleerde mens worden geïnterpreteerd

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

Microsoft.PerceptionSimulation.ISimulatedDevice.HeadTracker

Haal de Head Tracker op van het gesimuleerde apparaat.

Microsoft.PerceptionSimulation.ISimulatedDevice.HandTracker

Haal de handtracker op van het gesimuleerde apparaat.

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

Stel de eigenschappen van het gesimuleerde apparaat in zodat deze overeenkomen met het opgegeven apparaattype.

Parameters

• type - Het nieuwe type gesimuleerd apparaat

Microsoft.PerceptionSimulation.ISimulatedDevice2

Er zijn extra eigenschappen beschikbaar door de ISimulatedDevice naar ISimulatedDevice2 te casten

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

};

Microsoft.PerceptionSimulation.ISimulatedDevice2.IsUserPresent

Haal op of stel in of de gesimuleerde mens actief de headset draagt.

Microsoft.PerceptionSimulation.ISimulatedDevice2.DisplayConfiguration

De eigenschappen van de gesimuleerde weergave ophalen of instellen.

Microsoft.PerceptionSimulation.ISimulatedHeadTracker

Interface die het gedeelte van het gesimuleerde apparaat beschrijft waarmee het hoofd van de gesimuleerde mens wordt bijgehouden.

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

Microsoft.PerceptionSimulation.ISimulatedHeadTracker.HeadTrackerMode

Haalt de huidige headtrackermodus op en stelt deze in.

Microsoft.PerceptionSimulation.ISimulatedHandTracker

Interface die het gedeelte van het gesimuleerde apparaat beschrijft waarmee de handen van de gesimuleerde mens worden bijgehouden

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

Haal de positie van het knooppunt op met betrekking tot de wereld, in meters.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Position

Haal de positie van de gesimuleerde handtracker op en stel deze in ten opzichte van het midden van het hoofd.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Pitch

Haal de neerwaartse pitch van de gesimuleerde handtracker op en stel deze in.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.FrustumIgnored

Ophalen en instellen of het frustum van de gesimuleerde handtracker wordt genegeerd. Wanneer ze worden genegeerd, zijn beide handen altijd zichtbaar. Wanneer niet genegeerde handen (de standaard) zijn alleen zichtbaar wanneer ze zich binnen het frustum van de handtracker bevinden.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Frustum

Haal de frustumeigenschappen op die worden gebruikt om te bepalen of de handen zichtbaar zijn voor de gesimuleerde handtracker.

Microsoft.PerceptionSimulation.ISimulated Human

Interface op het hoogste niveau voor het beheren van de gesimuleerde mens.

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.ISimulated Human.WorldPosition

De positie van het knooppunt ophalen en instellen met betrekking tot de wereld, in meters. De positie komt overeen met een punt in het midden van de voeten van de mens.

Microsoft.PerceptionSimulation.ISimulated Human.Direction

Haal de gesimuleerde menselijke gezichten ter wereld op en stel deze in. 0 radialen gezichten omlaag op de negatieve Z-as. Positieve radialen draaien rechtsom over de Y-as.

Microsoft.PerceptionSimulation.ISimulated Human.Height

Haal de hoogte van de gesimuleerde mens op en stel deze in meters in.

Microsoft.PerceptionSimulation.ISimulated Human.LeftHand

Haal de linkerhand van de gesimuleerde mens op.

Microsoft.PerceptionSimulation.ISimulated Human.RightHand

Haal de rechterhand van de gesimuleerde mens op.

Microsoft.PerceptionSimulation.ISimulated Human.Head

Haal het hoofd van de gesimuleerde mens op.

Microsoft.PerceptionSimulation.ISimulated Human.Move(Microsoft.PerceptionSimulation.Vector3)

Verplaats de gesimuleerde mens ten opzichte van de huidige positie in meters.

Parameters

• vertaling: de vertaling die moet worden verplaatst, ten opzichte van de huidige positie.

Microsoft.PerceptionSimulation.ISimulated Human.Rotate(System.Single)

Draai de gesimuleerde mens ten opzichte van de huidige richting, met de klok mee over de Y-as

Parameters

• radialen : de hoeveelheid die moet worden gedraaid rond de Y-as.

Microsoft.PerceptionSimulation.ISimulated Human2

Er zijn extra eigenschappen beschikbaar door de ISimulated Human2 te casten naar ISimulated Human2

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

Microsoft.PerceptionSimulation.ISimulated Human2.LeftController

Haal de linker 6-DOF-controller op.

Microsoft.PerceptionSimulation.ISimulated Human2.RightController

Haal de juiste 6-DOF-controller op.

Microsoft.PerceptionSimulation.ISimulatedHand

Interface die een hand van de gesimuleerde mens beschrijft

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

Haal de positie van het knooppunt op met betrekking tot de wereld, in meters.

Microsoft.PerceptionSimulation.ISimulatedHand.Position

Haal de positie van de gesimuleerde hand op en stel deze in ten opzichte van de mens in meters.

Microsoft.PerceptionSimulation.ISimulatedHand.Activated

Ophalen en instellen of de hand momenteel is geactiveerd.

Microsoft.PerceptionSimulation.ISimulatedHand.Visible

Haal op of de hand momenteel zichtbaar is voor de SimulatedDevice (dat wil gezegd, of deze zich in een positie bevindt om te worden gedetecteerd door de HandTracker).

Microsoft.PerceptionSimulation.ISimulatedHand.EnsureVisible

Verplaats de hand zodanig dat deze zichtbaar is voor simulatedDevice.

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

Verplaats de positie van de gesimuleerde hand ten opzichte van de huidige positie in meters.

Parameters

• vertaling: het bedrag dat moet worden omgezet in de gesimuleerde hand.

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

Voer een gebaar uit met behulp van de gesimuleerde hand. Deze wordt alleen door het systeem gedetecteerd als de hand is ingeschakeld.

Parameters

• beweging : de beweging die moet worden uitgevoerd.

Microsoft.PerceptionSimulation.ISimulatedHand2

Er zijn extra eigenschappen beschikbaar door een ISimulatedHand naar ISimulatedHand2 te casten.

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

Microsoft.PerceptionSimulation.ISimulatedHand2.Orientation

Haal de draaiing van de gesimuleerde hand op of stel deze in. Positieve radialen draaien met de klok mee wanneer ze langs de as kijken.

Microsoft.PerceptionSimulation.ISimulatedHand3

Aanvullende eigenschappen zijn beschikbaar door een ISimulatedHand naar ISimulatedHand3 te casten

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

Haal de gezamenlijke configuratie voor de opgegeven joint op.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetJointConfiguration

Stel de gezamenlijke configuratie voor de opgegeven joint in.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetHandPose

Stel de hand in op een bekende pose met een optionele vlag om animatie toe te voegen. Opmerking: animaties resulteren niet onmiddellijk in gewrichten die hun uiteindelijke gezamenlijke configuraties weerspiegelen.

Microsoft.PerceptionSimulation.ISimulatedHead

Interface die het hoofd van de gesimuleerde mens beschrijft.

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

Microsoft.PerceptionSimulation.ISimulatedHead.WorldPosition

Haal de positie van het knooppunt op met betrekking tot de wereld, in meters.

Microsoft.PerceptionSimulation.ISimulatedHead.Rotation

Haal de draaiing van het gesimuleerde hoofd op. Positieve radialen draaien met de klok mee wanneer ze langs de as kijken.

Microsoft.PerceptionSimulation.ISimulatedHead.Diameter

Haal de diameter van het gesimuleerde hoofd op. Deze waarde wordt gebruikt om het midden van het hoofd (draaipunt) te bepalen.

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

Draai het gesimuleerde hoofd ten opzichte van de huidige draaiing. Positieve radialen draaien met de klok mee wanneer ze langs de as kijken.

Parameters

• rotatie : de hoeveelheid die moet worden gedraaid.

Microsoft.PerceptionSimulation.ISimulatedHead2

Aanvullende eigenschappen zijn beschikbaar door een ISimulatedHead naar ISimulatedHead2 te casten

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

Microsoft.PerceptionSimulation.ISimulatedHead2.Eyes

Haal de ogen van de gesimuleerde mens op.

Microsoft.PerceptionSimulation.ISimulatedSixDofController

Interface die een 6-DOF-controller beschrijft die is gekoppeld aan de gesimuleerde mens.

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

Haal de positie van het knooppunt op met betrekking tot de wereld, in meters.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Status

De huidige status van de controller ophalen of instellen. De controllerstatus moet worden ingesteld op een andere waarde dan Uit voordat aanroepen om knoppen te verplaatsen, draaien of erop drukken slaagt.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Position

Haal de positie van de gesimuleerde controller op of stel deze in ten opzichte van de mens in meters.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Orientation

De afdrukstand van de gesimuleerde controller ophalen of instellen.

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

Verplaats de positie van de gesimuleerde controller ten opzichte van de huidige positie in meters.

Parameters

• vertaling: het bedrag dat moet worden omgezet in de gesimuleerde controller.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.PressButton(SimulatedSixDofControllerButton)

Druk op een knop op de gesimuleerde controller. Deze wordt alleen gedetecteerd door het systeem als de controller is ingeschakeld.

Parameters

• knop - De knop om op te drukken.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.ReleaseButton(SimulatedSixDofControllerButton)

Laat een knop los op de gesimuleerde controller. Deze wordt alleen gedetecteerd door het systeem als de controller is ingeschakeld.

Parameters

• knop : de knop die u wilt vrijgeven.

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

Haal de positie van een gesimuleerde vinger op de touchpad van de gesimuleerde controller.

Parameters

• x - De horizontale positie van de vinger.
• y - De verticale positie van de vinger.

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

Stel de positie van een gesimuleerde vinger in op de touchpad van de gesimuleerde controller.

Parameters

• x - De horizontale positie van de vinger.
• y - De verticale positie van de vinger.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2

Aanvullende eigenschappen en methoden zijn beschikbaar door een ISimulatedSixDofController te casten naar 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)

Haal de positie van de gesimuleerde duimstick op de gesimuleerde controller op.

Parameters

• x - De horizontale positie van de duimstick.
• y - De verticale positie van de duimstick.

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

Stel de positie van de gesimuleerde duimstick in op de gesimuleerde controller.

Parameters

• x - De horizontale positie van de duimstick.
• y - De verticale positie van de duimstick.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2.BatteryLevel

Haal het batterijniveau van de gesimuleerde controller op of stel deze in. De waarde moet groter zijn dan 0,0 en kleiner dan of gelijk aan 100,0.

Microsoft.PerceptionSimulation.ISimulatedEyes

Interface die de ogen van de gesimuleerde mens beschrijft.

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

Microsoft.PerceptionSimulation.ISimulatedEyes.Rotation

Haal de draaiing van de gesimuleerde ogen op. Positieve radialen draaien met de klok mee wanneer ze langs de as kijken.

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

Draai de gesimuleerde ogen ten opzichte van de huidige draaiing. Positieve radialen draaien met de klok mee wanneer ze langs de as kijken.

Parameters

• rotatie : de hoeveelheid die moet worden gedraaid.

Microsoft.PerceptionSimulation.ISimulatedEyes.CalibrationState

Haalt de kalibratiestatus van de gesimuleerde ogen op of stelt deze in.

Microsoft.PerceptionSimulation.ISimulatedEyes.WorldPosition

Haal de positie van het knooppunt op met betrekking tot de wereld, in meters.

Microsoft.PerceptionSimulation.ISimulationRecording

Interface voor interactie met één opname die is geladen voor afspelen.

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

Microsoft.PerceptionSimulation.ISimulationRecording.DataTypes

Haalt de lijst met gegevenstypen op in de opname.

Microsoft.PerceptionSimulation.ISimulationRecording.State

Haalt de huidige status van de opname op.

Microsoft.PerceptionSimulation.ISimulationRecording.Play

Start het afspelen. Als de opname is onderbroken, wordt het afspelen hervat vanaf de onderbroken locatie; als het afspelen is gestopt, begint het afspelen aan het begin. Als deze oproep al wordt afgespeeld, wordt deze aanroep genegeerd.

Microsoft.PerceptionSimulation.ISimulationRecording.Pause

Hiermee wordt het afspelen onderbroken op de huidige locatie. Als de opname is gestopt, wordt het gesprek genegeerd.

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

Zoekt de opname naar de opgegeven tijd (in intervallen van 100 nanoseconden vanaf het begin) en pauzeert op die locatie. Als de tijd buiten het einde van de opname valt, wordt deze onderbroken in het laatste frame.

Parameters

• tikken - de tijd waarop moet worden gezocht.

Microsoft.PerceptionSimulation.ISimulationRecording.Stop

Hiermee wordt het afspelen gestopt en wordt de positie opnieuw ingesteld op het begin.

Microsoft.PerceptionSimulation.ISimulationRecordingCallback

Interface voor het ontvangen van statuswijzigingen tijdens het afspelen.

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

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

Wordt aangeroepen wanneer de afspeelstatus van een ISimulationRecording is gewijzigd.

Parameters

• newState - De nieuwe status van de opname.

Microsoft.PerceptionSimulation.PerceptionSimulationManager

Hoofdobject voor het maken van Perception Simulation-objecten.

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)

Maak een object voor het genereren van gesimuleerde pakketten en het leveren ervan aan de opgegeven sink.

Parameters

• sink: de sink die alle gegenereerde pakketten ontvangt.

Retourwaarde

De gemaakte manager.

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

Maak een sink, waarin alle ontvangen pakketten in een bestand op het opgegeven pad worden opgeslagen.

Parameters

• pad : het pad van het bestand dat moet worden gemaakt.

Retourwaarde

De gemaakte sink.

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

Laad een opname uit het opgegeven bestand.

Parameters

• pad : het pad van het bestand dat moet worden geladen.
• factory : een fabriek die door de opname wordt gebruikt voor het maken van een ISimulationStreamSink wanneer dat nodig is.

Retourwaarde

De geladen opname.

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

Laad een opname uit het opgegeven bestand.

Parameters

• pad : het pad van het bestand dat moet worden geladen.
• factory : een fabriek die door de opname wordt gebruikt voor het maken van een ISimulationStreamSink wanneer dat nodig is.
• callback: een callback, die updates ontvangt die de status van de opname hergraden.

Retourwaarde

De geladen opname.

Microsoft.PerceptionSimulation.StreamDataTypes

Beschrijft de verschillende typen stroomgegevens.

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

Een sentinel-waarde die wordt gebruikt om geen stroomgegevenstypen aan te geven.

Microsoft.PerceptionSimulation.StreamDataTypes.Head

Gegevensstroom voor de positie en stand van het hoofd.

Microsoft.PerceptionSimulation.StreamDataTypes.Hands

Gegevensstroom voor de positie en bewegingen van handen.

Microsoft.PerceptionSimulation.StreamDataTypes.SpatialMapping

Gegevensstroom voor ruimtelijke toewijzing van de omgeving.

Microsoft.PerceptionSimulation.StreamDataTypes.Kalibratie

Gegevensstroom voor kalibratie van het apparaat. Kalibratiepakketten worden alleen geaccepteerd door een systeem in de externe modus.

Microsoft.PerceptionSimulation.StreamDataTypes.Environment

Gegevensstroom voor de omgeving van het apparaat.

Microsoft.PerceptionSimulation.StreamDataTypes.SixDofControllers

Gegevensstroom voor bewegingscontrollers.

Microsoft.PerceptionSimulation.StreamDataTypes.Eyes

Gegevensstroom met de ogen van de gesimuleerde mens.

Microsoft.PerceptionSimulation.StreamDataTypes.DisplayConfiguration

Gegevensstroom met de weergaveconfiguratie van het apparaat.

Microsoft.PerceptionSimulation.StreamDataTypes.All

Een sentinel-waarde die wordt gebruikt om alle geregistreerde gegevenstypen aan te geven.

Microsoft.PerceptionSimulation.ISimulationStreamSink

Een object dat gegevenspakketten van een simulatiestroom ontvangt.

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

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

Ontvangt één pakket, dat intern is getypt en geversied.

Parameters

• lengte : de lengte van het pakket.
• pakket - De gegevens van het pakket.

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory

Een object dat ISimulationStreamSink maakt.

public interface ISimulationStreamSinkFactory
{
    ISimulationStreamSink CreateSimulationStreamSink();
}

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory.CreateSimulationStreamSink()

Hiermee maakt u één exemplaar van ISimulationStreamSink.

Retourwaarde

De gemaakte sink.