Symulacja percepcji

Czy chcesz utworzyć zautomatyzowany test dla aplikacji? Czy chcesz, aby testy wykraczały poza testy jednostkowe na poziomie składnika i naprawdę pełniły swoją aplikację? Symulacja percepcji jest tym, czego szukasz. Biblioteka Perception Simulation wysyła dane wejściowe dla ludzi i świata do aplikacji, aby można było zautomatyzować testy. Na przykład można symulować dane wejściowe człowieka szukającego określonej, powtarzalnej pozycji, a następnie użyć gestu lub kontrolera ruchu.

Symulacja percepcji może wysyłać symulowane dane wejściowe w ten sposób do fizycznego HoloLens, emulatora HoloLens (pierwszej generacji), komputera HoloLens 2 Emulator lub komputera z Portal rzeczywistości mieszanej zainstalowanym. Symulacja percepcji pomija czujniki na żywo Mixed Reality urządzeniu i wysyła symulowane dane wejściowe do aplikacji uruchomionych na urządzeniu. Aplikacje odbierają te zdarzenia wejściowe za pośrednictwem tych samych interfejsów API, których zawsze używają, i nie mogą odróżnić działania z rzeczywistymi czujnikami od symulacji percepcji. Symulacja percepcji to ta sama technologia, która jest używana przez emulatory HoloLens do wysyłania symulowanych danych wejściowych do HoloLens Virtual Machine.

Aby rozpocząć korzystanie z symulacji w kodzie, zacznij od utworzenia obiektu IPerceptionSimulationManager. Z tego obiektu można wydawać polecenia sterujące właściwościami symulowanego "człowieka", w tym położeniem głowy, położeniem dłoni i gestami. Można również włączać kontrolery ruchu i manipulować nimi.

Konfigurowanie modelu Visual Studio Project symulacji percepcji

  1. Zainstaluj emulator HoloLens na komputerze dewelopera. Emulator zawiera biblioteki, których używasz do symulacji percepcji.
  2. Utwórz nowy projekt Visual Studio języku C# (aplikacja konsolowa Project się świetnie, aby rozpocząć pracę.
  3. Dodaj następujące pliki binarne do projektu jako odwołania (Project->Add->Reference...). Można je znaleźć w folderze %ProgramFiles(x86)%\Microsoft XDE (wersja), na przykład \ %ProgramFiles(x86)%\Microsoft XDE \ 10.0.18362.0 dla HoloLens 2 Emulator. (Uwaga: chociaż pliki binarne są częścią HoloLens 2 Emulator, działają one również Windows Mixed Reality na pulpicie). A. PerceptionSimulationManager.Interop.dll — zarządzana otoka języka C# do symulacji percepcji. b. PerceptionSimulationRest.dll — biblioteka do konfigurowania kanału komunikacyjnego gniazda internetowego z HoloLens lub emulatorem. c. SimulationStream.Interop.dll — typy udostępnione do symulacji.
  4. Dodaj plik binarny PerceptionSimulationManager.dll do projektu a. Najpierw dodaj go jako plik binarny do projektu (Project->Add->Existing Item...). Zapisz go jako link, aby nie kopiować go do folderu źródłowego projektu. Dodaj PerceptionSimulationManager.dll do projektu jako link b. Następnie upewnij się, że zostanie on skopiowany do folderu wyjściowego podczas kompilacji. Znajduje się on w arkuszu właściwości pliku binarnego. Oznacz PerceptionSimulationManager.dll do skopiowania do katalogu wyjściowego
  5. Ustaw aktywną platformę rozwiązania na wartość x64. (Użyj Menedżer konfiguracji, aby utworzyć wpis Platforma dla wersji x64, jeśli jeszcze nie istnieje).

Tworzenie obiektu IPerceptionSimulation Manager

Aby kontrolować symulację, należy wydać aktualizacje obiektów pobranych z obiektu IPerceptionSimulationManager. Pierwszym krokiem jest pobrać ten obiekt i połączyć go z urządzeniem docelowym lub emulatorem. Adres IP emulatora można uzyskać, klikając przycisk Portal urządzeń na pasku narzędzi

Otwórz Portal urządzeń Otwórz Portal urządzeń: Otwórz Windows Portal urządzeń dla HoloLens operacyjnego w emulatorze. Na Windows Mixed Reality można je pobrać w aplikacji usługi Ustawienia w obszarze "Aktualizowanie zabezpieczeń usługi &", a następnie w sekcji "Połączenie using" w sekcji "Włącz usługę Portal urządzeń". Pamiętaj, aby zanotować zarówno adres IP, jak i port.

Najpierw wywołasz obiekt RestSimulationStreamSink.Create, aby uzyskać obiekt RestSimulationStreamSink. Jest to urządzenie docelowe lub emulator, które będziesz kontrolować za pośrednictwem połączenia HTTP. Polecenia zostaną przekazane i obsłużone przez Windows Portal urządzeń uruchomione na urządzeniu lub emulatorze. Cztery parametry potrzebne do utworzenia obiektu to:

  • URI URI — adres IP urządzenia docelowego (np. https://123.123.123.123 "" lub " https://123.123.123.123:50080 ")
  • Poświadczenia System.Net.NetworkCredential — nazwa użytkownika/hasło służące do nawiązywania połączenia Windows Portal urządzeń na urządzeniu docelowym lub w emulatorze. Jeśli łączysz się z emulatorem za pośrednictwem jego adresu lokalnego (np. 168.. . *) na tym samym komputerze wszystkie poświadczenia zostaną zaakceptowane.
  • wartość logiczna normalna — prawda dla normalnego priorytetu, fałsz w przypadku niskiego priorytetu. Zwykle chcesz ustawić tę wartość na true dla scenariuszy testowych, co pozwoli testowi przejąć kontrolę. Emulator i symulacja Windows Mixed Reality używają połączeń o niskim priorytecie. Jeśli test korzysta również z połączenia o niskim priorytecie, ostatnio nawiązane połączenie będzie kontrolować.
  • Token System.Threading.CancellationToken — token do anulowania operacji asynchronicznej.

Po drugie utworzysz menedżera IPerceptionSimulationManager. Jest to obiekt, który umożliwia sterowanie symulacją. Należy to również zrobić w metodzie asynchronicznej.

Kontrolowanie symulowanego człowieka

Element IPerceptionSimulationManager ma właściwość Human, która zwraca obiekt ISimulowanyD. Aby kontrolować symulowanego człowieka, wykonaj operacje na tym obiekcie. Na przykład:

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

Podstawowa przykładowa aplikacja konsolowa w języku C#

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

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            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();
        }
    }
}

Rozszerzona przykładowa aplikacja konsolowa w języku C#

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

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

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

                    IPerceptionSimulationManager manager = PerceptionSimulationManager.CreatePerceptionSimulationManager(sink);

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

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

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

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

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

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

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

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

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

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

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

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

Uwaga na kontrolerach 6-DOF

Przed wywołaniem jakichkolwiek właściwości metod na symulowanym kontrolerze 6-DOF należy aktywować kontroler. Jeśli tego nie zrobisz, wystąpi wyjątek. Począwszy od Aktualizacja systemu Windows 10 z maja 2019, symulowane kontrolery 6-DOF można zainstalować i aktywować, ustawiając właściwość Status w obiekcie ISimulatedSixDofController na SimulatedSixDofControllerStatus.Active. W Aktualizacja systemu Windows 10 z października 2018 i starszych należy oddzielnie zainstalować symulowany kontroler 6-DOF, wywołując narzędzie PerceptionSimulationDevice znajdujące się w folderze \Windows\System32. Użycie tego narzędzia jest następujące:

    PerceptionSimulationDevice.exe <action> 6dof <instance>

Na przykład

    PerceptionSimulationDevice.exe i 6dof 1

Obsługiwane akcje to:

  • i = zainstaluj
  • q = zapytanie
  • r = usuń

Obsługiwane wystąpienia to:

  • 1 = lewy kontroler 6-DOF
  • 2 = prawy kontroler 6-DOF

Kod zakończenia procesu będzie wskazywać powodzenie (wartość zwracaną zerowo) lub niepowodzenie (wartość zwracaną zerową). W przypadku używania akcji "q" do wykonywania zapytania o to, czy kontroler jest zainstalowany, zwracana wartość będzie równa zero (0), jeśli kontroler nie został jeszcze zainstalowany, lub jeden (1), jeśli kontroler jest zainstalowany.

Podczas usuwania kontrolera na Aktualizacja systemu Windows 10 z października 2018 lub wcześniejszym ustaw jego stan na Wyłączone za pośrednictwem interfejsu API, a następnie wywołaj narzędzie PerceptionSimulationDevice.

To narzędzie musi być uruchamiane jako administrator.

Dokumentacja interfejsu API

Microsoft.PerceptionSimulation.SimulatedDeviceType

Opisuje typ urządzenia symulowanego

public enum SimulatedDeviceType
{
    Reference = 0
}

Microsoft.PerceptionSimulation.SimulatedDeviceType.Reference

Fikcyjne urządzenie referencyjne, domyślne dla perceptionSimulationManager

Microsoft.PerceptionSimulation.HeadTrackerMode

Opisuje tryb śledzenia głowy

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

Microsoft.PerceptionSimulation.HeadTrackerMode.Default

Domyślne śledzenie głowy. Oznacza to, że system może wybrać najlepszy tryb śledzenia głowy na podstawie warunków środowiska uruchomieniowego.

Microsoft.PerceptionSimulation.HeadTrackerMode.Orientation

Śledzenie tylko orientacji głowy. Oznacza to, że śledzona pozycja może nie być niezawodna, a niektóre funkcje zależne od pozycji głowy mogą być niedostępne.

Microsoft.PerceptionSimulation.HeadTrackerMode.Position

Śledzenie pozyacyjne głowy. Oznacza to, że śledzona pozycja głowy i orientacja są niezawodne

Microsoft.PerceptionSimulation.SimulatedGesture

Opisuje symulowany gest

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

Microsoft.PerceptionSimulation.SimulatedGesture.None

Wartość sentinel używana do wskazywania żadnych gestów.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerPressed

Gest naciśnięcia palca.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerReleased

Palec zwolnił gest.

Microsoft.PerceptionSimulation.SimulatedGesture.Home

Gest home/system.

Microsoft.PerceptionSimulation.SimulatedGesture.Max

Maksymalny prawidłowy gest.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus

Możliwe stany symulowanego kontrolera 6-DOF.

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

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Off

Kontroler 6-DOF jest wyłączony.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Active

Kontroler 6-DOF jest włączony i śledzony.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.TrackingLost

Kontroler 6-DOF jest włączony, ale nie można go śledzić.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton

Obsługiwane przyciski na symulowanym kontrolerze 6-DOF.

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

Wartość sentinel używana do wskazywania brak przycisków.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Home

Zostanie naciśnięty przycisk Strona główna.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Menu

Zostanie naciśnięty przycisk Menu.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Gar

Zostanie naciśnięty przycisk Uchwyt.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadPress

Zostanie naciśnięty ekran TouchPad.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Select

Zostanie naciśnięty przycisk Wybierz.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadTouch

TouchPad jest dotknieny.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Thumbstick

Zostanie naciśnięta pauzy.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Max

Maksymalny prawidłowy przycisk.

Microsoft.PerceptionSimulation.SimulatedStatesCalibrationState

Stan chłoniaka symulowanych oczu

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

Microsoft.PerceptionSimulation.SimulatedStatesCalibrationState.Unavailable

Oczy są niedostępne.

Microsoft.PerceptionSimulation.SimulatedStatesCalibrationState.Ready

Oczy zostały skalibrowane. Jest to wartość domyślna.

Microsoft.PerceptionSimulation.SimulatedStatesCalibrationState.Configuring

Oczy są skalibrowane.

Microsoft.PerceptionSimulation.SimulatedStatesCalibrationState.UserCalibrationNeeded

Oczy muszą być skalibrowane.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy

Dokładność śledzenia wspólnego ręki.

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

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Unavailable

Połączenie nie jest śledzone.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Approximate

Wywnioskowana jest wspólna pozycja.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Visible

Połączenie jest w pełni śledzone.

Microsoft.PerceptionSimulation.SimulatedHandPose

Dokładność śledzenia wspólnego ręki.

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

Microsoft.PerceptionSimulation.SimulatedHandPose.Closed

Odcisk palca ręki jest skonfigurowany tak, aby odzwierciedlał zamkniętą postawę.

Microsoft.PerceptionSimulation.SimulatedHandPose.Open

Odcisk palca ręki jest skonfigurowany tak, aby odzwierciedlał otwartą postawę.

Microsoft.PerceptionSimulation.SimulatedHandPose.Point

Odcisk palca ręki jest skonfigurowany tak, aby odzwierciedlał ułożenie wskazujące.

Microsoft.PerceptionSimulation.SimulatedHandPose.Pinch

Odcisk palca ręki jest skonfigurowany tak, aby odzwierciedlał uszczypnij ułożenie.

Microsoft.PerceptionSimulation.SimulatedHandPose.Max

Maksymalna prawidłowa wartość simulatedHandPose.

Microsoft.PerceptionSimulation.PlaybackState

Opisuje stan odtwarzania.

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

Microsoft.PerceptionSimulation.PlaybackState.Stopped

Rejestrowanie jest obecnie zatrzymane i gotowe do odtwarzania.

Microsoft.PerceptionSimulation.PlaybackState.Playing

Nagranie jest aktualnie odtwarzane.

Microsoft.PerceptionSimulation.PlaybackState.Paused

Rejestrowanie jest obecnie wstrzymane.

Microsoft.PerceptionSimulation.PlaybackState.End

Nagranie osiągnęło koniec.

Microsoft.PerceptionSimulation.Vector3

Opisuje wektor trzech składników, który może opisywać punkt lub wektor w przestrzeni 3D.

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

Microsoft.PerceptionSimulation.Vector3.X

Składnik X wektora.

Microsoft.PerceptionSimulation.Vector3.Y

Składnik Y wektora.

Microsoft.PerceptionSimulation.Vector3.Z

Składnik Z wektora.

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

Konstruowanie nowego wektora 3.

Parametry

  • x — składnik x wektora.
  • y — składnik y wektora.
  • z — składnik z wektora.

Microsoft.PerceptionSimulation.Rotation3

Opisuje rotację trzech składników.

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

Microsoft.PerceptionSimulation.Rotation3.Pitch

Składnik Pitch obrotu w dół wokół osi X.

Microsoft.PerceptionSimulation.Rotation3.Yaw

Składnik Yaw obrotu, tuż wokół osi Y.

Microsoft.PerceptionSimulation.Rotation3.Roll

Składnik Roll obrotu, tuż wokół osi Z.

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

Skonstruuj nową platformę Rotation3.

Parametry

  • pitch ( wysokość) — składnik obrotu.
  • yaw — składnik yaw obrotu.
  • roll — składnik rzutu obrotu.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration

Opisuje konfigurację połączenia na symulowanej dłoni.

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

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Position

Pozycja wspólnego.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Rotation

Obrót wspólnego.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.TrackingAccuracy

Dokładność śledzenia wspólnego.

Microsoft.PerceptionSimulation.Frustum

Opisuje widok frustum, który jest zwykle używany przez aparat fotograficzny.

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

Microsoft.PerceptionSimulation.Frustum.Near

Minimalna odległość, która znajduje się w frustum.

Microsoft.PerceptionSimulation.Frustum.Far

Maksymalna odległość, która znajduje się w frustum.

Microsoft.PerceptionSimulation.Frustum.FieldOfView

Poziome pole widoku frustum w radianach (mniejsze niż PI).

Microsoft.PerceptionSimulation.Frustum.AspectRatio

Stosunek poziomego pola widoku do pionowego pola widoku.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration

Opisuje konfigurację wyświetlania symulowanego zestawu nagłownego.

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

Przekształcenie od środka głowy do lewego oka na potrzeby renderowania stereo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.Left AutomatycznieRotation

Obrót lewego oka na potrzeby renderowania stereo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightPosition

Przekształcenie od środka głowy do prawego oka na potrzeby renderowania stereo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightGateRotation

Obrót prawego oka na potrzeby renderowania stereo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.Ipd

Wartość Ipd zgłoszona przez system na potrzeby renderowania stereo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.Apply AutomatyczneTransforms

Określa, czy wartości podane dla przekształceń lewego i prawego oka powinny być uznawane za prawidłowe i stosowane do działającego systemu.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyIpd

Określa, czy wartość dla adresu Ipd powinna być uważana za prawidłową i zastosowana do działającego systemu.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager

Katalog główny do generowania pakietów używanych do sterowania urządzeniem.

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

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Device

Pobierz obiekt urządzenia symulowanego, który interpretuje symulowanego człowieka i symulowany świat.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Human

Pobierz obiekt, który kontroluje symulowanego człowieka.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Reset

Resetuje symulację do stanu domyślnego.

Microsoft.PerceptionSimulation.ISimulatedDevice

Interfejs opisujący urządzenie, który interpretuje symulowany świat i symulowanego człowieka

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

Microsoft.PerceptionSimulation.ISimulatedDevice.HeadTracker

Pobierz monitor head z urządzenia symulowanego.

Microsoft.PerceptionSimulation.ISimulatedDevice.HandTracker

Pobieranie śledzenia ręcznego z urządzenia symulowanego.

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

Ustaw właściwości symulowanego urządzenia tak, aby dopasować je do podanego typu urządzenia.

Parametry

  • typ — nowy typ urządzenia symulowanego

Microsoft.PerceptionSimulation.ISimulatedDevice2

Dostępne są dodatkowe właściwości rzutowania ISimulatedDevice do ISimulatedDevice2

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

};

Microsoft.PerceptionSimulation.ISimulatedDevice2.IsUserPresent

Pobieranie lub ustawianie, czy symulowany człowiek aktywnie chowa zestaw nagłowny.

Microsoft.PerceptionSimulation.ISimulatedDevice2.DisplayConfiguration

Pobierz lub ustaw właściwości symulowanego ekranu.

Microsoft.PerceptionSimulation.ISimulatedHeadTracker

Interfejs opisujący część symulowanego urządzenia, która śledzi głowy symulowanego człowieka.

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

Microsoft.PerceptionSimulation.ISimulatedHeadTracker.HeadTrackerMode

Pobiera i ustawia bieżący tryb trackera.

Microsoft.PerceptionSimulation.ISimulatedHandTracker

Interfejs opisujący część symulowanego urządzenia, która śledzi ręce symulowanego człowieka

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

Pobierz pozycję węzła z relacją do świata, w miernikach.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Position

Pobierz i ustaw położenie symulowanego monitora ręki względem środka głowy.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Pitch

Pobieranie i ustawianie spadku symulowanego monitora rąk.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.FrustumIgnored

Pobieranie i ustawianie, czy frustum symulowanego śledzenia ręcznego jest ignorowane. Po zignorowania obie strony są zawsze widoczne. Gdy nie zostaną zignorowane (ustawienie domyślne), ręce będą widoczne tylko wtedy, gdy znajdują się w frustum trackera ręcznego.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Frustum

Pobierz i ustaw właściwości frustum używane do określenia, czy ręce są widoczne dla symulowanego śledzenia rąk.

Microsoft.PerceptionSimulation.ISimulated Nie

Interfejs najwyższego poziomu do kontrolowania symulowanego człowieka.

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.ISimulatedPozycją.WorldPosition

Pobieranie i ustawianie pozycji węzła w odniesieniu do świata, w miernikach. Pozycja odpowiada punktowi w środku ludzkiego ciała.

Microsoft.PerceptionSimulation.ISimulowaneKierunkowe

Pobieranie i ustawianie kierunku symulowanych ludzkich twarzy na świecie. 0 radianów powierzchni w dół ujemnej osi Z. Dodatnie radiany obracają się w prawo wokół osi Y.

Microsoft.PerceptionSimulation.ISimulowaneDymulacja.Height

Pobieranie i ustawianie wysokości symulowanego człowieka w metrach.

Microsoft.PerceptionSimulation.ISimulatedHand.LeftHand

Pobierz lewą rękę symulowanego człowieka.

Microsoft.PerceptionSimulation.ISimulowaneD.RightHand

Pobierz prawą rękę symulowanego człowieka.

Microsoft.PerceptionSimulation.ISimulowaneZagła

Pobieranie głowy symulowanego człowieka.

Microsoft.PerceptionSimulation.ISimulowaneZasunięcie.Move(Microsoft.PerceptionSimulation.Vector3)

Przenieś symulowanego człowieka względem jego bieżącej pozycji w metrach.

Parametry

  • translation — tłumaczenie do przeniesienia względem bieżącej pozycji.

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

Obracanie symulowanego człowieka względem jego bieżącego kierunku, zgodnie z ruchem wskazówek zegara wokół osi Y

Parametry

  • radiany — ilość do obrócenia wokół osi Y.

Microsoft.PerceptionSimulation.ISimulowane 2

Dodatkowe właściwości są dostępne przez rzutowanie ISimulowanejAdymulowanej Do ISimulowanej 2

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

Microsoft.PerceptionSimulation.ISimulowaneKontroler2.LeftController

Pobierz lewy kontroler 6-DOF.

Microsoft.PerceptionSimulation.ISimulowaneKontroler2.RightController

Pobierz odpowiedni kontroler 6-DOF.

Microsoft.PerceptionSimulation.ISimulatedHand

Interfejs opisujący rękę symulowanego człowieka

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

Pobierz pozycję węzła z relacją do świata, w miernikach.

Microsoft.PerceptionSimulation.ISimulatedHand.Position

Pobierz i ustaw pozycję symulowanej ręki względem człowieka, w metrach.

Microsoft.PerceptionSimulation.ISimulatedHand.Activated

Pobierz i ustaw, czy ręka jest aktualnie aktywowana.

Microsoft.PerceptionSimulation.ISimulatedHand.Visible

Sprawdź, czy ręka jest obecnie widoczna dla urządzenia SimulatedDevice (czyli czy jest w stanie do wykrycia przez handtracker).

Microsoft.PerceptionSimulation.ISimulatedHand.EnsureVisible

Przenieś rękę w taki sposób, aby była widoczna dla urządzenia SimulatedDevice.

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

Przenieś położenie symulowanej ręki względem jej bieżącej pozycji w metrach.

Parametry

  • translation — kwota do przetłumaczenia symulowanej ręki.

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

Wykonaj gest przy użyciu symulowanej ręki. Zostanie on wykryty przez system tylko wtedy, gdy ręka jest włączona.

Parametry

  • gesture — gest do wykonania.

Microsoft.PerceptionSimulation.ISimulatedHand2

Dodatkowe właściwości są dostępne przez rzutowanie ISimulatedHand do ISimulatedHand2.

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

Microsoft.PerceptionSimulation.ISimulatedHand2.Orientation

Pobieranie lub ustawianie obrotu symulowanej ręki. Dodatnie radiany obracają się w prawo podczas patrzcenia wzdłuż osi.

Microsoft.PerceptionSimulation.ISimulatedHand3

Dodatkowe właściwości są dostępne przez rzutowanie ISimulatedHand do ISimulowanejHand3

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

Pobierz wspólną konfigurację dla określonej wspólnej.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetJointConfiguration

Ustaw wspólną konfigurację dla określonej wspólnej.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetHandPose

Ustaw rękę na znaną postawę z opcjonalną flagą, aby animować. Uwaga: animowanie nie spowoduje natychmiastowego odzwierciedlenia ich ostatecznych wspólnych konfiguracji.

Microsoft.PerceptionSimulation.ISimulatedHead

Interfejs opisujący głowy symulowanego człowieka.

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

Microsoft.PerceptionSimulation.ISimulatedHead.WorldPosition

Pobierz pozycję węzła z relacją do świata, w miernikach.

Microsoft.PerceptionSimulation.ISimulatedHead.Rotation

Pobieranie obrotu symulowanego głowy. Dodatnie radiany obracają się w prawo podczas patrzcenia wzdłuż osi.

Microsoft.PerceptionSimulation.ISimulowanyHead.Wyliczenie

Pobieranie symulowanego podbłoniaka. Ta wartość jest używana do określenia środka głowy (punktu obrotu).

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

Obróć symulowaną głowy względem jej bieżącego obrotu. Dodatnie radiany obracają się w prawo podczas patrzcenia wzdłuż osi.

Parametry

  • rotation — kwota do rotacji.

Microsoft.PerceptionSimulation.ISimulatedHead2

Dodatkowe właściwości są dostępne przez rzutowanie ISimulowanejHead do ISimulatedHead2

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

Microsoft.PerceptionSimulation.ISimulatedHead2.Eyes

Pobieranie oczu symulowanego człowieka.

Microsoft.PerceptionSimulation.ISimulatedSixDofController

Interfejs opisujący kontroler 6-DOF skojarzony z symulowanym człowiekiem.

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

Pobierz pozycję węzła z relacją do świata, w miernikach.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Status

Pobieranie lub ustawianie bieżącego stanu kontrolera. Aby jakiekolwiek wywołania przenoszenia, obracania lub naciskania przycisków zakończyły się powodzeniem, stan kontrolera musi być ustawiony na wartość inną niż Wyłączone.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Position

Pobieranie lub ustawianie pozycji symulowanego kontrolera względem człowieka w miernikach.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Orientation

Pobierz lub ustaw orientację symulowanego kontrolera.

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

Przenieś położenie symulowanego kontrolera względem jego bieżącej pozycji w metrach.

Parametry

  • translation — kwota do przetłumaczenia symulowanego kontrolera.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.PressButton(SimulatedSixDofControllerButton)

Naciśnij przycisk na symulowanym kontrolerze. Zostanie on wykryty przez system tylko wtedy, gdy kontroler jest włączony.

Parametry

  • button — przycisk do naciśnięcia.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.ReleaseButton(SimulatedSixDofControllerButton)

Zwolnij przycisk na symulowanym kontrolerze. Zostanie on wykryty przez system tylko wtedy, gdy kontroler jest włączony.

Parametry

  • button — przycisk do zwolnienia.

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

Uzyskaj pozycję symulowanego palca na panelu dotykowym symulowanego kontrolera.

Parametry

  • x — pozioma pozycja palca.
  • y — pionowa pozycja palca.

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

Ustaw pozycję symulowanego palca na panelu dotykowym symulowanego kontrolera.

Parametry

  • x — pozioma pozycja palca.
  • y — pionowa pozycja palca.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2

Dodatkowe właściwości i metody są dostępne przez rzutowanie ISimulatedSixDofController do 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(zmiennoprzecinkowa, zmiennoprzecinkowa)

Pobierz pozycję symulowanej pazyki kciuka na symulowanym kontrolerze.

Parametry

  • x — pozioma pozycja pazy.
  • y — pionowa pozycja pazy.

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

Ustaw położenie symulowanej pazyki kciuka na symulowanym kontrolerze.

Parametry

  • x — pozioma pozycja pazy.
  • y — pionowa pozycja pazy.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2.BatteryLevel

Pobierz lub ustaw poziom naładowania baterii symulowanego kontrolera. Wartość musi być większa niż 0,0 i mniejsza niż lub równa 100,0.

Microsoft.PerceptionSimulation.ISimulowaneZasyłanie

Interfejs opisujący wzrok symulowanego człowieka.

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

Microsoft.PerceptionSimulation.ISimulatedInstals.Rotation

Pobieranie obrotu symulowanych oczu. Dodatnie radiany obracają się zgodnie z ruchem wskazówek zegara podczas patrzeniom wzdłuż osi.

Microsoft.PerceptionSimulation.ISimulatedInstals.Rotate(Microsoft.PerceptionSimulation.Rotation3)

Obróć symulowane oczy względem bieżącego obrotu. Dodatnie radiany obracają się zgodnie z ruchem wskazówek zegara podczas patrzeniom wzdłuż osi.

Parametry

  • rotation — ilość do rotacji.

Microsoft.PerceptionSimulation.ISimulatedState

Pobiera lub ustawia stan odwzorowania symulowanych oczu.

Microsoft.PerceptionSimulation.ISimulowaneZasłania.WorldPosition

Pobierz pozycję węzła w odniesieniu do świata, w metrach.

Microsoft.PerceptionSimulation.ISimulationRecording

Interfejs do interakcji z pojedynczym nagraniem załadowanym do odtwarzania.

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

Microsoft.PerceptionSimulation.ISimulationRecording.DataTypes

Pobiera listę typów danych podczas rejestrowania.

Microsoft.PerceptionSimulation.ISimulationRecording.State

Pobiera bieżący stan nagrania.

Microsoft.PerceptionSimulation.ISimulationRecording.Play

Uruchom odtwarzanie. Jeśli rejestrowanie zostało wstrzymane, odtwarzanie zostanie wznowione z wstrzymanej lokalizacji; Jeśli odtwarzanie zostanie zatrzymane, odtwarzanie rozpocznie się od początku. Jeśli odtwarzanie jest już odtwarzane, to wywołanie jest ignorowane.

Microsoft.PerceptionSimulation.ISimulationRecording.Pause

Wstrzymuje odtwarzanie w bieżącej lokalizacji. Jeśli rejestrowanie zostanie zatrzymane, wywołanie zostanie zignorowane.

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

Szuka rejestrowania do określonego czasu (w interwałach 100 nanosekund od początku) i wstrzymuje się w tej lokalizacji. Jeśli czas jest poza zakończeniem rejestrowania, jest wstrzymany w ostatniej ramce.

Parametry

  • ticks — czas, do którego należy szukać.

Microsoft.PerceptionSimulation.ISimulationRecording.Stop

Zatrzymuje odtwarzanie i resetuje położenie do początku.

Microsoft.PerceptionSimulation.ISimulationRecordingCallback

Interfejs do odbierania zmian stanu podczas odtwarzania.

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

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

Wywoływana po zmianie stanu odtwarzania rekordu ISimulationRecording.

Parametry

  • newState — nowy stan rejestrowania.

Microsoft.PerceptionSimulation.PerceptionSimulationManager

Obiekt główny do tworzenia obiektów symulacji percepcji.

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)

Utwórz obiekt w celu wygenerowania symulowanych pakietów i dostarczenia ich do dostarczonego ujścia.

Parametry

  • ujścia — ujścia, które będzie odbierać wszystkie wygenerowane pakiety.

Wartość zwracana

Utworzony menedżer.

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

Utwórz ujścia, które przechowuje wszystkie odebrane pakiety w pliku w określonej ścieżce.

Parametry

  • path — ścieżka pliku do utworzenia.

Wartość zwracana

Utworzone ujścia.

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

Załaduj nagranie z określonego pliku.

Parametry

  • path — ścieżka pliku do załadowania.
  • factory — fabryka używana przez rejestrowanie do tworzenia ISimulationStreamSink, jeśli jest to wymagane.

Wartość zwracana

Załadowane nagranie.

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

Załaduj nagranie z określonego pliku.

Parametry

  • path — ścieżka pliku do załadowania.
  • factory — fabryka używana przez rejestrowanie do tworzenia ISimulationStreamSink, jeśli jest to wymagane.
  • wywołanie zwrotne — wywołanie zwrotne, które odbiera aktualizacje w celu zmiany klasyfikacji stanu nagrania.

Wartość zwracana

Załadowane nagranie.

Microsoft.PerceptionSimulation.StreamDataTypes

Opisuje różne typy danych strumieniowych.

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

Wartość sentinel używana do wskazywania typów danych strumienia.

Microsoft.PerceptionSimulation.StreamDataTypes.Head

Strumień danych dla położenia i orientacji głowy.

Microsoft.PerceptionSimulation.StreamDataTypes.Hands

Strumień danych dla położenia i gestów rąk.

Microsoft.PerceptionSimulation.StreamDataTypes.SpatialMapping

Strumień danych do mapowania przestrzennego środowiska.

Microsoft.PerceptionSimulation.StreamDataTypes.Wyliczenie

Strumień danych do odwzorowania urządzenia. Pakiety insektacyjne są akceptowane tylko przez system w trybie zdalnym.

Microsoft.PerceptionSimulation.StreamDataTypes.Environment

Strumień danych dla środowiska urządzenia.

Microsoft.PerceptionSimulation.StreamDataTypes.SixDofControllers

Strumień danych dla kontrolerów ruchu.

Microsoft.PerceptionSimulation.StreamDataTypes.Eyes

Strumień danych z okiem symulowanego człowieka.

Microsoft.PerceptionSimulation.StreamDataTypes.DisplayConfiguration

Strumień danych z konfiguracją wyświetlania urządzenia.

Microsoft.PerceptionSimulation.StreamDataTypes.All

Wartość sentinel używana do wskazywania wszystkich zarejestrowanych typów danych.

Microsoft.PerceptionSimulation.ISimulationStreamSink

Obiekt, który odbiera pakiety danych ze strumienia symulacji.

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

Microsoft.PerceptionSimulation.ISimulationStreamSink.OnPacketReceived(długość uint, bajt[] pakiet)

Odbiera jeden pakiet, który jest wewnętrznie typowany i wersjonarowany.

Parametry

  • length — długość pakietu.
  • packet — dane pakietu.

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory

Obiekt, który tworzy element ISimulationStreamSink.

public interface ISimulationStreamSinkFactory
{
    ISimulationStreamSink CreateSimulationStreamSink();
}

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory.CreateSimulationStreamSink()

Tworzy pojedyncze wystąpienie ISimulationStreamSink.

Wartość zwracana

Utworzone ujścia.