Waarnemingssimulatie

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 invoergegevens van mensen en wereld naar uw app, zodat u uw tests kunt automatiseren. U kunt bijvoorbeeld de invoer simuleren van een persoon die naar een specifieke, herhaalbare positie kijkt en vervolgens een beweging of bewegingscontroller gebruiken.

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 invoerevenementen via dezelfde API's die ze altijd gebruiken en kunnen het verschil niet zien tussen het uitvoeren met echte sensoren en perceptionsimulatie. Perception Simulation is dezelfde technologie die door de HoloLens-emulators wordt gebruikt voor het verzenden van gesimuleerde invoer naar de virtuele HoloLens-machine.

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 de 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 perceptiesimulatie

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 prima om aan de slag te gaan).

3. Voeg de volgende binaire bestanden als verwijzingen toe aan uw project (Project-Add-Reference>>...). U vindt ze in %ProgramFiles(x86)%\Microsoft XDE\(version), 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 websocketscommunicatiekanaal naar de HoloLens of emulator.
   c. SimulationStream.Interop.dll: gedeelde typen voor simulatie.

4. Het binaire implementatie-PerceptionSimulationManager.dll toevoegen aan uw project

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

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

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

Een IPerceptionSimulation Manager-object maken

Als u de simulatie wilt beheren, geeft u updates uit voor 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 in de werkbalk te klikken

Apparaatportal openen: 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 & 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 via een HTTP-verbinding gaat beheren. 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 normal - Waar voor normale prioriteit, onwaar voor lage prioriteit. Over het algemeen wilt u dit instellen op waar voor testscenario's, zodat 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, heeft de laatst tot stand gebrachte verbinding de controle.
• System.Threading.CancellationToken- token om de asynchrone bewerking te annuleren.

Vervolgens 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 ISimulatedHuman-object retourneert. Als u de gesimuleerde persoon wilt beheren, voert u bewerkingen uit op dit object. Bijvoorbeeld:

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 op methoden op een gesimuleerde 6-DOF-controller aanroept, moet u de controller activeren. Als u dit niet doet, resulteert dit in een uitzondering. Vanaf de Update voor Windows 10, mei 2019 kunnen gesimuleerde 6-DOF-controllers worden geïnstalleerd en geactiveerd door de eigenschap Status van het object ISimulatedSixDofController in te stellen op SimulatedSixDofControllerStatus.Active. In de Update voor Windows 10, oktober 2018 en eerder moet u eerst een gesimuleerde 6-DOF-controller afzonderlijk 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 retourwaarde van nul) of mislukt (een niet-nul retourwaarde). Wanneer u de actie 'q' gebruikt om op te vragen 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 op de Update voor Windows 10, oktober 2018 of eerder verwijdert, stelt u de status eerst in op Uit 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 hoofdtrackermodus

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

Microsoft.PerceptionSimulation.HeadTrackerMode.Default

Standaard hoofdtracering. Dit betekent dat het systeem de beste hoofdtraceringsmodus kan selecteren op basis van runtimevoorwaarden.

Microsoft.PerceptionSimulation.HeadTrackerMode.Orientation

Alleen afdrukstand 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 oriëntatie 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 bewegingen aan te geven.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerPressed

Een vinger ingedrukt gebaar.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerReleased

Een met de vinger losgelaten gebaar.

Microsoft.PerceptionSimulation.SimulatedGesture.Home

Het thuis-/systeemgebaar.

Microsoft.PerceptionSimulation.SimulatedGesture.Max

De maximaal geldige beweging.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus

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

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

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Uit

De 6 DOF-controller is uitgeschakeld.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Active

De 6-DOF-controller wordt ingeschakeld en bijgehouden.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.TrackingLost

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

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 knop Grip 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 is 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 ogenkalibratie 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 worden gekalibreerd.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy

De volgnauwkeurigheid van een gewricht van de hand.

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

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Unavailable

De joint wordt niet getraceerd.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Approximate

Het gemeenschappelijk standpunt wordt afgeleid.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Visible

De verbinding is volledig getraceerd.

Microsoft.PerceptionSimulation.SimulatedHandPose

De volgnauwkeurigheid van een gewricht van de hand.

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

Microsoft.PerceptionSimulation.SimulatedHandPose.Closed

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

Microsoft.PerceptionSimulation.SimulatedHandPose.Open

De vingergewrichten van de hand zijn geconfigureerd om een open houding weer te geven.

Microsoft.PerceptionSimulation.SimulatedHandPose.Point

De vingergewrichten van de hand zijn geconfigureerd om een wijzende houding weer te geven.

Microsoft.PerceptionSimulation.SimulatedHandPose.Pinch

De vingergewrichten van de hand zijn geconfigureerd om een knijpende houding weer te geven.

Microsoft.PerceptionSimulation.SimulatedHandPose.Max

De maximaal geldige waarde voor SimulatedHandPose.

Microsoft.PerceptionSimulation.PlaybackState

Beschrijft de status van een afspelen.

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

Microsoft.PerceptionSimulation.PlaybackState.Stopped

De opname is momenteel gestopt en klaar voor afspelen.

Microsoft.PerceptionSimulation.PlaybackState.Playing

De opname wordt momenteel afgespeeld.

Microsoft.PerceptionSimulation.PlaybackState.Paused

De opname is momenteel onderbroken.

Microsoft.PerceptionSimulation.PlaybackState.End

Het einde van de opname is bereikt.

Microsoft.PerceptionSimulation.Vector3

Beschrijft een vector met drie componenten, 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

De Y-component van de vector.

Microsoft.PerceptionSimulation.Vector3.Z

Het Z-onderdeel van de vector.

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

Maak een nieuwe vector3.

Parameters

• x - Het x-onderdeel van de vector.
• y : de y-component van de vector.
• z - De z-component van de vector.

Microsoft.PerceptionSimulation.Rotation3

Beschrijft een rotatie 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 rotatie, omlaag rond de X-as.

Microsoft.PerceptionSimulation.Rotation3.Yaw

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

Microsoft.PerceptionSimulation.Rotation3.Roll

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

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

Maak een nieuwe rotatie3.

Parameters

• pitch: het pitch-onderdeel van de rotatie.
• yaw - Het geeuwonderdeel 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 de joint.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Rotation

De draaiing van de verbinding.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.TrackingAccuracy

De volgnauwkeurigheid van de joint.

Microsoft.PerceptionSimulation.Frustum

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

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

Microsoft.PerceptionSimulation.Frustum.Near

De minimale afstand die is opgenomen in het frustum.

Microsoft.PerceptionSimulation.Frustum.Far

De maximale afstand die in het frustum is opgenomen.

Microsoft.PerceptionSimulation.Frustum.FieldOfView

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

Microsoft.PerceptionSimulation.Frustum.AspectRatio

De verhouding tussen het horizontale beeldveld en het verticale beeldveld.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration

Beschrijft de configuratie van het beeldscherm 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 stereo rendering.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.LeftEyeRotation

De draaiing van het linkeroog voor stereo rendering.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyePosition

De transformatie van het midden van het hoofd naar het rechteroog voor stereoweergave.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyeRotation

De draaiing van het rechteroog voor stereo rendering.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.Ipd

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

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyEyeTransforms

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

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyIpd

Of de opgegeven waarde voor Ipd als geldig moet worden beschouwd en moet worden 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 wordt de standaardstatus van de simulatie hersteld.

Microsoft.PerceptionSimulation.ISimulatedDevice

Interface die het apparaat beschrijft, die de gesimuleerde wereld en de gesimuleerde mens interpreteert

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

Microsoft.PerceptionSimulation.ISimulatedDevice.HeadTracker

Haal de hoofdtracker op van het gesimuleerde apparaat.

Microsoft.PerceptionSimulation.ISimulatedDevice.HandTracker

Haal de handtracering 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

Aanvullende eigenschappen zijn beschikbaar door het ISimulatedDevice te casten naar ISimulatedDevice2

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

};

Microsoft.PerceptionSimulation.ISimulatedDevice2.IsUserPresent

Ophalen of instellen of de gesimuleerde mens actief de headset draagt of niet.

Microsoft.PerceptionSimulation.ISimulatedDevice2.DisplayConfiguration

De eigenschappen van het gesimuleerde beeldscherm ophalen of instellen.

Microsoft.PerceptionSimulation.ISimulatedHeadTracker

Interface die het gedeelte van het gesimuleerde apparaat beschrijft dat het hoofd van de gesimuleerde mens volgt.

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

Microsoft.PerceptionSimulation.ISimulatedHeadTracker.HeadTrackerMode

Hiermee wordt de huidige hoofdtrackermodus opgehaald en ingesteld.

Microsoft.PerceptionSimulation.ISimulatedHandTracker

Interface die het gedeelte van het gesimuleerde apparaat beschrijft dat de handen van de gesimuleerde mens volgt

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 handtracering op en stel deze in ten opzichte van het midden van het hoofd.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Pitch

De neerwaartse toonhoogte van de gesimuleerde handtracering ophalen en instellen.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.FrustumIgnored

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

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Frustum

De frustum-eigenschappen ophalen en instellen die worden gebruikt om te bepalen of handen zichtbaar zijn voor de gesimuleerde handtracering.

Microsoft.PerceptionSimulation.ISimulatedHuman

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.ISimulatedHuman.WorldPosition

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

Microsoft.PerceptionSimulation.ISimulatedHuman.Direction

De gesimuleerde menselijke gezichten in de wereld ophalen en instellen. 0 radialen naar beneden op de negatieve Z-as. Positieve radialen draaien rechtsom rond de Y-as.

Microsoft.PerceptionSimulation.ISimulatedHuman.Height

De hoogte van de gesimuleerde mens in meters ophalen en instellen.

Microsoft.PerceptionSimulation.ISimulatedHuman.LeftHand

Haal de linkerhand van de gesimuleerde mens op.

Microsoft.PerceptionSimulation.ISimulatedHuman.RightHand

Haal de rechterhand van de gesimuleerde mens op.

Microsoft.PerceptionSimulation.ISimulatedHuman.Head

Haal het hoofd van de gesimuleerde mens op.

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

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

Parameters

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

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

De gesimuleerde mens draaien ten opzichte van de huidige richting, rechtsom rond de Y-as

Parameters

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

Microsoft.PerceptionSimulation.ISimulatedHuman2

Aanvullende eigenschappen zijn beschikbaar door de ISimulatedHuman te casten naar ISimulatedHuman2

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

Microsoft.PerceptionSimulation.ISimulatedHuman2.LeftController

Haal de linker 6-DOF-controller op.

Microsoft.PerceptionSimulation.ISimulatedHuman2.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

De positie van de gesimuleerde hand ten opzichte van de mens ophalen en instellen, in meters.

Microsoft.PerceptionSimulation.ISimulatedHand.Activated

Ophalen en instellen of de hand momenteel is geactiveerd.

Microsoft.PerceptionSimulation.ISimulatedHand.Visible

Ophalen of de hand momenteel zichtbaar is voor het 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 het SimulatedDevice.

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

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

Parameters

• translation: het bedrag om de gesimuleerde hand te vertalen.

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

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

Parameters

• gebaar: de beweging die moet worden uitgevoerd.

Microsoft.PerceptionSimulation.ISimulatedHand2

Aanvullende eigenschappen zijn beschikbaar door een ISimulatedHand te casten naar ISimulatedHand2.

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 rechtsom wanneer u langs de as kijkt.

Microsoft.PerceptionSimulation.ISimulatedHand3

Aanvullende eigenschappen zijn beschikbaar door een ISimulatedHand te casten naar ISimulatedHand3

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

Microsoft.PerceptionSimulation.ISimulatedHand3.GetJointConfiguration

Haal de gezamenlijke configuratie voor de opgegeven joint op.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetJointConfiguration

Stel de gezamenlijke configuratie in voor de opgegeven joint.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetHandPose

Stel de hand in op een bekende houding met een optionele vlag om animatie toe te voegen. Opmerking: als u animaties aanbrengen, resulteert dit niet in het onmiddellijk weergeven van de uiteindelijke configuratie van de joints.

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 de gesimuleerde kop op. Positieve radialen draaien rechtsom wanneer u langs de as kijkt.

Microsoft.PerceptionSimulation.ISimulatedHead.Diameter

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

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

Draai de gesimuleerde kop ten opzichte van de huidige draaiing. Positieve radialen draaien rechtsom wanneer u langs de as kijkt.

Parameters

• rotatie: het bedrag dat moet worden gedraaid.

Microsoft.PerceptionSimulation.ISimulatedHead2

Aanvullende eigenschappen zijn beschikbaar door een ISimulatedHead te casten naar ISimulatedHead2

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 voor het verplaatsen, draaien of drukken van knoppen slagen.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Position

De positie van de gesimuleerde controller ten opzichte van de mens ophalen of instellen, 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

• translation: het bedrag om de gesimuleerde controller te vertalen.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.PressButton(SimulatedSixDofControllerButton)

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

Parameters

• button: de knop om op te drukken.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.ReleaseButton(SimulatedSixDofControllerButton)

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

Parameters

• button: de knop die u wilt loslaten.

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

De positie van een gesimuleerde vinger op het touchpad van de gesimuleerde controller ophalen.

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 het 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 op van de gesimuleerde duimstick op de gesimuleerde controller.

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 op de gesimuleerde controller in.

Parameters

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

Microsoft.PerceptionSimulation.ISimulatedSixDofController2.BatteryLevel

Het batterijniveau van de gesimuleerde controller ophalen of instellen. 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 rechtsom wanneer u langs de as kijkt.

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

Draai de gesimuleerde ogen ten opzichte van de huidige draaiing. Positieve radialen draaien rechtsom wanneer u langs de as kijkt.

Parameters

• rotatie: het bedrag dat moet worden gedraaid.

Microsoft.PerceptionSimulation.ISimulatedEyes.CalibrationState

Hiermee wordt de kalibratiestatus van de gesimuleerde ogen opgehaald of ingesteld.

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

Hiermee haalt u de lijst met gegevenstypen in de opname op.

Microsoft.PerceptionSimulation.ISimulationRecording.State

Hiermee haalt u de huidige status van de opname op.

Microsoft.PerceptionSimulation.ISimulationRecording.Play

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

Microsoft.PerceptionSimulation.ISimulationRecording.Pause

Onderbreekt het afspelen 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 voorbij het einde van de opname valt, wordt deze onderbroken bij het laatste frame.

Parameters

• ticks : de tijd waarnaar moet worden gezocht.

Microsoft.PerceptionSimulation.ISimulationRecording.Stop

Hiermee wordt het afspelen gestopt en wordt de positie naar het begin teruggezet.

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 op 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 u wilt maken.

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 indien nodig.

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 indien nodig.
• callback: een callback, die updates ontvangt om de status van de opname te herstellen.

Retourwaarde

De geladen opname.

Microsoft.PerceptionSimulation.StreamDataTypes

Hierin worden de verschillende typen stroomgegevens beschreven.

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

Stroom van gegevens 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.Calibration

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

Microsoft.PerceptionSimulation.StreamDataTypes.Environment

Stroom van gegevens voor de omgeving van het apparaat.

Microsoft.PerceptionSimulation.StreamDataTypes.SixDofControllers

Stroom van gegevens voor bewegingscontrollers.

Microsoft.PerceptionSimulation.StreamDataTypes.Eyes

Stroom van gegevens met de ogen van de gesimuleerde mens.

Microsoft.PerceptionSimulation.StreamDataTypes.DisplayConfiguration

Stroom van gegevens 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 ontvangt van een simulatiestroom.

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

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

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

Parameters

• length: de lengte van het pakket.
• packet: de gegevens van het pakket.

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory

Een object waarmee ISimulationStreamSink wordt gemaakt.

public interface ISimulationStreamSinkFactory
{
    ISimulationStreamSink CreateSimulationStreamSink();
}

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory.CreateSimulationStreamSink()

Hiermee maakt u één exemplaar van ISimulationStreamSink.

Retourwaarde

De gemaakte sink.