Észlelési szimuláció

Szeretne automatizált tesztet összeépíteni az alkalmazáshoz? Azt szeretné, hogy a tesztek túlmutatnak az összetevőszintű egységtesztelésen, és valóban végpontok között gyakorolják az alkalmazást? Az észlelési szimuláció az, amit keres. Az észlelésszimulációs kódtár emberi és világbeli bemeneti adatokat küld az alkalmazásnak, így automatizálhatja a teszteket. Szimulálhatja például egy olyan ember bemenetét, aki egy adott, ismételhető pozíciót keres, majd egy kézmozdulatot vagy mozgásvezérlőt használhat.

Az észlelési szimuláció ehhez hasonló szimulált bemenetet küldhet egy fizikai HoloLens-nek, az HoloLens Emulatornak (első generációs), az HoloLens 2 Emulator-nek vagy egy olyan számítógépnek, amely Vegyes valóság portál telepítve. Az észlelési szimuláció megkerüli a virtuális Mixed Reality élő érzékelőit, és szimulált bemenetet küld az eszközön futó alkalmazásoknak. Az alkalmazások ugyanazon API-kon keresztül kapják meg ezeket a bemeneti eseményeket, mint amit mindig is, és nem tudják mondani, mi a különbség a valós érzékelőkkel való futtatás és az észlelési szimuláció között. Az észlelési szimuláció ugyanazt a technológiát használja, HoloLens emulátorok szimulált bemenetet küldenek a virtuális HoloLens gépre.

A szimuláció kódban való használatának megkezdéséhez először hozzon létre egy IPerceptionSimulationManager objektumot. Ebből az objektumból parancsokat ad ki egy szimulált "ember" tulajdonságainak vezérléséhez, beleértve a fej pozícióját, a kéz pozícióját és a kézmozdulatokat. Mozgásvezérlőket is engedélyezhet és kezelhet.

Alkalmazás beállítása Visual Studio Project észlelési szimulációhoz

  1. Telepítse a HoloLens emulátort a fejlesztői számítógépen. Az emulátor tartalmazza az észlelési szimulációhoz használt kódtárakat.
  2. Hozzon létre egy új Visual Studio C#-asztali projektet (a Console Project remek első lépések).
  3. Adja hozzá a következő bináris fájlokat a projekthez hivatkozásként (Project- > Add- > Reference...). Ezeket a %ProgramFiles(x86)%\Microsoft XDE\(version) mappában találja, például > HoloLens 2 Emulator. (Megjegyzés: bár a bináris fájlok a HoloLens 2. Emulator részét képezi, az asztali Windows Mixed Reality is működnek.) a. PerceptionSimulationManager.Interop.dll – Felügyelt C#-burkoló az észlelési szimulációhoz. b. PerceptionSimulationRest.dll – Kódtár webes szoftvercsatorna beállításához a HoloLens vagy emulátorhoz. c. SimulationStream.Interop.dll – Közös típusok szimulációhoz.
  4. Adja hozzá a PerceptionSimulationManager.dll bináris fájlját a projekthez. Először adja hozzá bináris fájlként a projekthez (Project- > Add- > Existing Item...). Mentse hivatkozásként, hogy ne másolja a projekt forrásmappába. Adja PerceptionSimulationManager.dll a projekthez b hivatkozásként. Ezután győződjön meg arról, hogy a buildben a kimeneti mappába lesz másva. Ez a bináris tulajdonságlapon található. A PerceptionSimulationManager.dll a kimeneti könyvtárba másolt felhasználók megjelölése
  5. Állítsa az aktív megoldásplatformot x64-re. (A Konfigurációkezelő hozhat létre platformbejegyzést az x64-hez, ha még nem létezik.)

IPerceptionSimulation Manager-objektum létrehozása

A szimuláció vezérléséhez az IPerceptionSimulationManager objektumból lekért objektumokhoz fog frissítéseket kinyerni. Első lépésként szerezze be ezt az objektumot, és csatlakoztassa a céleszközhöz vagy az emulátorhoz. Az emulátor IP-címét az eszköztár Eszközportál gombjára kattintva kaphatja meg

Nyissa Eszközportál ikontNyissa Eszközportál:Nyissa meg az Windows Eszközportál operációs rendszer HoloLens az emulátorban. A Windows Mixed Reality az "Update Security" (Biztonság frissítése) területen található Gépház-alkalmazásban, majd az "Csatlakozás using:" (Alkalmazás engedélyezése) szakasz "For developers" (Fejlesztőknek) szakaszában lehet & Eszközportál. Ügyeljen arra, hogy az IP-címet és a portot is jegyezze fel.

Először hívja meg a RestSimulationStreamSink.Create gombra a RestSimulationStreamSink objektum lehívásához. Ez az a céleszköz vagy emulátor, amely felett a HTTP-kapcsolatot fogja szabályozni. A parancsokat az eszközön vagy az emulátoron futó Windows Eszközportál kezeli és kezeli. Az objektum létrehozásához szükséges négy paraméter a következő:

  • URI URI – a céleszköz IP-címe (például " https://123.123.123.123" ; vagy " https://123.123.123.123:50080" ;)
  • System.Net.NetworkCredential hitelesítő adatok – Felhasználónév/jelszó a Windows Eszközportál a céleszközön vagy emulátoron. Ha az emulátorhoz a helyi címével csatlakozik (például 168.). *) ugyanazon a számítógépen minden hitelesítő adat el lesz fogadva.
  • bool normal – Normál prioritásnál igaz, alacsony prioritásnál hamis. Ezt általában igazra kell állítani tesztelési forgatókönyvek esetén, ami lehetővé teszi, hogy a teszt átveszi az irányítást. Az emulátor és Windows Mixed Reality szimuláció alacsony prioritású kapcsolatokat használ. Ha a teszt alacsony prioritású kapcsolatot is használ, akkor a legutóbb létesített kapcsolat lesz irányítva.
  • System.Threading.CancellationToken token – Jogkivonat az aszinkron művelet megszakításhoz.

A második az IPerceptionSimulationManager létrehozása. Ezzel az objektummal vezérelni tudja a szimulációt. Ezt aszinkron metódusban is meg kell tenni.

A szimulált ember vezérlése

Az IPerceptionSimulationManager rendelkezik egy Human tulajdonságkal, amely egy ISimulatedHuman objektumot ad vissza. A szimulált ember vezérlése érdekében hajtson végre műveleteket ezen az objektumon. Például:

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

Alapszintű C#-konzolalkalmazásminta

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

Kiterjesztett C#-konzolalkalmazás minta

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

Megjegyzés a 6 DOF-vezérlőkhöz

Mielőtt bármilyen tulajdonságot hív meg egy szimulált 6-DOF-vezérlő metódusán, aktiválnia kell a vezérlőt. Ha ezt nem teszi meg, az kivételt eredményez. A Windows 10 2019. májusi frissítése-tól kezdődően szimulált 6-DOF vezérlők telepíthetők és aktiválhatóak, ha az ISimulatedSixDofController objektum Status tulajdonságát SimulatedSixDofControllerStatus.Active állapotra helyezték. A Windows 10 2018. októberi frissítése és korábbi verziókban először egy szimulált 6-DOF-vezérlőt kell külön telepítenie a \Windows\System32 mappában található PerceptionSimulationDevice eszköz hívása segítségével. Ennek az eszköznek a használata a következő:

    PerceptionSimulationDevice.exe <action> 6dof <instance>

Példa:

    PerceptionSimulationDevice.exe i 6dof 1

A támogatott műveletek a következőek:

  • i = telepítés
  • q = lekérdezés
  • r = eltávolítás

A támogatott példányok a következőek:

  • 1 = a bal oldali 6 DOF-vezérlő
  • 2 = a jobb 6 DOF-vezérlő

A folyamat kilépési kódja sikert (nulla visszatérési értéket) vagy hibát (nem nulla visszatérési értéket) jelez. Ha a "q" művelet használatával lekérdezi, hogy telepítve van-e egy vezérlő, a visszatérési érték nulla (0), ha a vezérlő még nincs telepítve, vagy egy (1), ha a vezérlő telepítve van.

Amikor eltávolít egy vezérlőt a Windows 10 2018. októberi frissítése vagy korábbi verzióból, először állítsa Ki állapotra az API-n keresztül, majd hívja meg az PerceptionSimulationDevice eszközt.

Ezt az eszközt rendszergazdaként kell futtatni.

API-referencia

Microsoft.PerceptionSimulation.SimulatedDeviceType

Szimulált eszköztípust ír le

public enum SimulatedDeviceType
{
    Reference = 0
}

Microsoft.PerceptionSimulation.SimulatedDeviceType.Reference

Egy fiktív referenciaeszköz, az PerceptionSimulationManager alapértelmezett beállítása

Microsoft.PerceptionSimulation.HeadTrackerMode

A fejkövető módot ismerteti

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

Microsoft.PerceptionSimulation.HeadTrackerMode.Default

Alapértelmezett fejkövetés. Ez azt jelenti, hogy a rendszer a futásidejű feltételek alapján kiválaszthatja a legjobb fejkövetési módot.

Microsoft.PerceptionSimulation.HeadTrackerMode.Orientation

Tájolás csak fejkövetés. Ez azt jelenti, hogy a nyomon követhető pozíció nem biztos, hogy megbízható, és előfordulhat, hogy a fej pozíciójától függő funkciók némelyike nem érhető el.

Microsoft.PerceptionSimulation.HeadTrackerMode.Position

Pozíciós fejkövetés. Ez azt jelenti, hogy a nyomon követhető fej pozíciója és tájolása is megbízható

Microsoft.PerceptionSimulation.SimulatedGesture

Egy szimulált kézmozdulatot ismertet

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

Microsoft.PerceptionSimulation.SimulatedGesture.None

Egy sentinel érték, amely azt jelzi, hogy nincs kézmozdulat.

Microsoft.PerceptionSimulation.SimulatedGesture.Pressed

Egy kézmozdulat az ujjlenyomattal.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerReleased

Egy kiadott kézmozdulat.

Microsoft.PerceptionSimulation.SimulatedGesture.Home

A home/system kézmozdulat.

Microsoft.PerceptionSimulation.SimulatedGesture.Max

A maximális érvényes kézmozdulat.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus

Egy szimulált 6-DOF-vezérlő lehetséges állama.

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

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Off

A 6-DOF vezérlő ki van kapcsolva.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Active

A 6-DOF vezérlő be van kapcsolva és nyomon van követve.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.TrackingLost

A 6-DOF vezérlő be van kapcsolva, de nem követhető nyomon.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton

A támogatott gombok egy szimulált 6-DOF-vezérlőn.

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

Egy sentinel érték, amely a gombok mellőzését jelzi.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Home

A Kezdőlap gomb le van nyomva.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Menu

A Menü gomb le van nyomva.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Fog

A Gomb gomb megnyomása.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadPress

A TouchPad le van nyomva.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Select

A Kijelölés gomb le van nyomva.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Touchpad Touch

A TouchPad meg van hatódva.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Thumbstick

A thumbstick le van nyomva.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Max

A maximális érvényes gomb.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState

A szimulált szem állapota

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

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Unavailable

A tekintet nem érhető el.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Ready

A szemeket berakták. Ez az alapértelmezett érték.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Configuring

A szemeket berakják.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.UserCalibrationNeeded

A szemeket be kell állítani.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy

Egy kézkövetési pontosság.

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

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Unavailable

A közös nincs nyomon követve.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Approximate

A közös pozíció kikövetkeztetve.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Visible

A közös teljes körűen nyomon van követve.

Microsoft.PerceptionSimulation.SimulatedHandPose

Egy kézkövetési pontosság.

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

Microsoft.PerceptionSimulation.SimulatedHandPose.Closed

A kéz ujjlenyomata úgy van konfigurálva, hogy zárt testalkatot tükrözze.

Microsoft.PerceptionSimulation.SimulatedHandPose.Open

A kéz ujjlenyomata úgy van konfigurálva, hogy nyitott pozíciót tükrözze.

Microsoft.PerceptionSimulation.SimulatedHandPose.Point

A kéz ujjlenyomata úgy van konfigurálva, hogy tükrözze a mutató pozíciót.

Microsoft.PerceptionSimulation.SimulatedHandPose.Csippent

A kéz ujjlenyomata úgy van konfigurálva, hogy egy csippentés pozíciót tükrözze.

Microsoft.PerceptionSimulation.SimulatedHandPose.Max

A SimulatedHandPose maximális érvényes értéke.

Microsoft.PerceptionSimulation.PlaybackState

A lejátszás állapotát írja le.

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

Microsoft.PerceptionSimulation.PlaybackState.Stopped

A felvétel jelenleg le van állítva, és lejátszásra kész.

Microsoft.PerceptionSimulation.PlaybackState.Playing

A felvétel lejátszása folyamatban van.

Microsoft.PerceptionSimulation.PlaybackState.Paused

A felvétel jelenleg szüneteltetve van.

Microsoft.PerceptionSimulation.PlaybackState.End

A felvétel elérte a végét.

Microsoft.PerceptionSimulation.Vector3

Egy három összetevővektort ír le, amely egy pontot vagy egy 3D térben egy vektort ír le.

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

Microsoft.PerceptionSimulation.Vector3.X

A vektor X összetevője.

Microsoft.PerceptionSimulation.Vector3.Y

A vektor Y összetevője.

Microsoft.PerceptionSimulation.Vector3.Z

A vektor Z összetevője.

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

Új Vector3 létrehozása.

Paraméterek

  • x – A vektor x összetevője.
  • y – A vektor y összetevője.
  • z – A vektor z összetevője.

Microsoft.PerceptionSimulation.Rotation3

Három összetevő rotációját ismerteti.

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

Microsoft.PerceptionSimulation.Rotation3.Pitch

A rotáció Pitch összetevője az X tengely körül.

Microsoft.PerceptionSimulation.Rotation3.Yaw

A rotáció Yaw összetevője, közvetlenül az Y tengely körül.

Microsoft.PerceptionSimulation.Rotation3.Roll

A Rotáció Roll összetevője, közvetlenül a Z tengely körül.

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

Új rotáció létrehozása3.

Paraméterek

  • pitch – A rotáció pitch összetevője.
  • yaw – A rotáció yaw összetevője.
  • roll – A rotáció roll összetevője.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration

Egy szimulált kézen egy közös konfigurációját ismerteti.

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

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Position

A közös pozíciója.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Rotation

A közös rotációja.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.TrackingAccuracy

A közös követési pontossága.

Microsoft.PerceptionSimulation.Frustum

A kamera által általában használt nézet-frustumot írja le.

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

Microsoft.PerceptionSimulation.Frustum.Near

A frustumban található minimális távolság.

Microsoft.PerceptionSimulation.Frustum.Far

A frustumban található maximális távolság.

Microsoft.PerceptionSimulation.Frustum.FieldOfView

A frustum vízszintes nézete radiánban (pi-nél kisebb).

Microsoft.PerceptionSimulation.Frustum.AspectRatio

A vízszintes és a függőleges nézetmezők aránya.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration

A szimulált headset kijelzője konfigurációját ismerteti.

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

Az átalakítás a fej közepétől a bal szem felé a sztereotens renderelés céljából.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.LeftEyeRotation

A bal szem elforgatása a sztereotens rendereléshez.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyePosition

Az átalakítás a fej közepétől a jobb szem felé a sztereotens renderelés céljából.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyeRotation

A jobb szem elforgatása a sztereotens rendereléshez.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.Ipd

A rendszer által a sztereotens renderelés céljából jelentett IPd-érték.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyEyeTransforms

Azt határozza meg, hogy a bal és jobb szem transzformációkhoz megadott értékeket érvényesnek kell-e tekinteni, és alkalmazni kell-e a futó rendszerre.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyIpd

Azt határozza meg, hogy az IPd számára megadott értéket érvényesnek kell-e tekinteni, és alkalmazni kell-e a futó rendszerre.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager

Az eszköz vezérléséhez használt csomagok generálásának gyökere.

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

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Device

Lekéri a szimulált emberi és szimulált világot értelmező szimulálteszköz-objektumot.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Human

A szimulált embert vezérlő objektum lekérése.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Reset

Visszaállítja a szimulációt az alapértelmezett állapotába.

Microsoft.PerceptionSimulation.ISimulatedDevice

Az eszközt leíró interfész, amely értelmezi a szimulált világot és a szimulált embert

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

Microsoft.PerceptionSimulation.ISimulatedDevice.HeadTracker

A Head Tracker lekérése a szimulált eszközről.

Microsoft.PerceptionSimulation.ISimulatedDevice.HandTracker

A Kézkövető lekérése a szimulált eszközről.

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

Állítsa be a szimulált eszköz tulajdonságait úgy, hogy megegyeznek a megadott eszköztípussal.

Paraméterek

  • type – A Szimulált eszköz új típusa

Microsoft.PerceptionSimulation.ISimulatedDevice2

További tulajdonságok érhetők el az ISimulatedDevice ISimulatedDevice2-re való átszámítása által

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

};

Microsoft.PerceptionSimulation.ISimulatedDevice2.IsUserPresent

Annak lekérése vagy beállítása, hogy a szimulált ember aktívan viseli-e a headsetet.

Microsoft.PerceptionSimulation.ISimulatedDevice2.DisplayConfiguration

A szimulált megjelenítés tulajdonságainak lekérése vagy beállítása.

Microsoft.PerceptionSimulation.ISimulatedHeadTracker

A szimulált eszköz azon részét leíró interfész, amely nyomon követi a szimulált ember fejét.

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

Microsoft.PerceptionSimulation.ISimulatedHeadTracker.HeadTrackerMode

Lekéri és beállítja az aktuális fejkövető módot.

Microsoft.PerceptionSimulation.ISimulatedHandTracker

A szimulált eszköz azon részét leíró interfész, amely nyomon követi a szimulált ember kezében

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

A világhoz kapcsolódó csomópont pozíciójának lekérése mérőkben.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Position

A szimulált kézkövető pozíciójának lekérése és beállítása a fej közepéhez viszonyítva.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Pitch

A szimulált kézkövető lefelé irányuló dobása lekérése és beállítása.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.FrustumIgnored

Lekéri és beállítja, hogy a rendszer figyelmen kívül hagyja-e a szimulált kézkövető frustumját. Figyelmen kívül hagyva a két kéz mindig látható lesz. Ha nincs figyelmen kívül hagyva (az alapértelmezett) kéz csak akkor látható, ha a kézkövető frustumában vannak.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Frustum

A frustumtulajdonságok lekérése és beállítása annak meghatározásához, hogy a kéz látható-e a szimulált kézkövető számára.

Microsoft.PerceptionSimulation.ISimulatedHuman

Legfelső szintű interfész a szimulált ember vezérlésére.

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

A csomópont pozíciójának lekérése és beállítása a világhoz való viszonyhoz mérőkben. A pozíció az ember lábának közepén található pontnak felel meg.

Microsoft.PerceptionSimulation.ISimulatedHuman.Direction

A szimulált emberi arcok irányának lekérése és beállítása a világon. 0 radián a negatív Z tengelyen lefelé néz. A pozitív radiánok az Y tengelyhez képest az óramutató járásával megegyező irányban elforgatva irányúak.

Microsoft.PerceptionSimulation.ISimulatedHuman.Height

A szimulált ember magasságának lekérése és beállítása mérőkben.

Microsoft.PerceptionSimulation.ISimulatedHuman.LeftHand

A szimulált ember bal kézzel való lekérése.

Microsoft.PerceptionSimulation.ISimulatedHuman.RightHand

A szimulált ember jobb kezében.

Microsoft.PerceptionSimulation.ISimulatedHuman.Head

A szimulált ember fejének lekérése.

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

Helyezze át a szimulált emberit az aktuális pozíciójához képest mérőkben.

Paraméterek

  • translation – Az áthelyezni szükséges fordítás az aktuális pozícióhoz viszonyítva.

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

A szimulált ember elforgatása az aktuális irányhoz képest, az Y tengely óramutató járásával megegyező irányban

Paraméterek

  • radián – Az Y tengely körül elforgatni kívánt mennyiség.

Microsoft.PerceptionSimulation.ISimulatedHuman2

További tulajdonságok érhetők el az ISimulatedHuman ISimulatedHuman2-re való átküldéssel

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

Microsoft.PerceptionSimulation.ISimulatedHuman2.LeftController

A bal oldali 6-DOF vezérlő lekérése.

Microsoft.PerceptionSimulation.ISimulatedHuman2.RightController

A megfelelő 6-DOF vezérlő lekérése.

Microsoft.PerceptionSimulation.ISimulatedHand

A szimulált ember egy kézét leíró felület

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

A csomópont pozíciójának lekérése a világhoz viszonyítva, méterben.

Microsoft.PerceptionSimulation.ISimulatedHand.Position

A szimulált kéz pozíciójának lekérése és beállítása az emberhez képest mérőkben.

Microsoft.PerceptionSimulation.ISimulatedHand.Activated

Lekéri és beállítja, hogy a kéz jelenleg aktiválva van-e.

Microsoft.PerceptionSimulation.ISimulatedHand.Visible

Annak lekérése, hogy a kéz látható-e a SimulatedDevice számára (ez azt jelenti, hogy a HandTracker észlelni tudja-e).

Microsoft.PerceptionSimulation.ISimulatedHand.EnsureVisible

Mozgassa úgy a kézét, hogy látható legyen a SimulatedDevice számára.

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

Mozgassa a szimulált kéz pozícióját az aktuális pozíciójához képest mérőkben.

Paraméterek

  • translation – A szimulált kéz fordításának mennyisége.

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

Hajtson végre egy kézmozdulatot a szimulált kézzel. A rendszer csak akkor észleli, ha a kéz engedélyezve van.

Paraméterek

  • kézmozdulat – A végrehajtani szükséges kézmozdulat.

Microsoft.PerceptionSimulation.ISimulatedHand2

További tulajdonságok az ISimulatedHand tulajdonság ISimulatedHand2-re való átírása esetén érhetők el.

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

Microsoft.PerceptionSimulation.ISimulatedHand2.Orientation

A szimulált kéz rotációja lekérése vagy beállítása. A pozitív radiánok az óramutató járásával megegyező irányban forgassuk a tengely mentén való megjelenéskor.

Microsoft.PerceptionSimulation.ISimulatedHand3

További tulajdonságok érhetők el az ISimulatedHand az ISimulatedHand3-ra való átírása által

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

Szerezze be a megadott közös konfigurációt.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetJointConfiguration

Állítsa be a közös konfigurációt a megadott közöshez.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetHandPose

Állítsa be a kéz egy ismert testhelyzetet, és egy opcionális jelzővel adja meg az annimate jelölőt. Megjegyzés: az animatálás nem eredményez azonnali tükrözéseket a végső közös konfigurációjuknak.

Microsoft.PerceptionSimulation.ISimulatedHead

A szimulált ember fejét leíró interfész.

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

Microsoft.PerceptionSimulation.ISimulatedHead.WorldPosition

A csomópont pozíciójának lekérése a világhoz viszonyítva, méterben.

Microsoft.PerceptionSimulation.ISimulatedHead.Rotation

A szimulált fej elforgatásának lekérése. A pozitív radiánok az óramutató járásával megegyező irányban forgassuk a tengely mentén való megjelenéskor.

Microsoft.PerceptionSimulation.ISimulatedHead.Egyed

Lekéri a szimulált fejet. Ez az érték határozza meg a fej középpontját (a rotációs pontot).

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

Forgassa el a szimulált fejet az aktuális rotációhoz viszonyítva. A pozitív radiánok az óramutató járásával megegyező irányban forgassuk a tengely mentén való megjelenéskor.

Paraméterek

  • rotation ( elforgatás) – A rotációban elforgatni kívánt mennyiség.

Microsoft.PerceptionSimulation.ISimulatedHead2

További tulajdonságok érhetők el az ISimulatedHead ISimulatedHead2-re való átküldéssel

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

Microsoft.PerceptionSimulation.ISimulatedHead2.Eyes

A szimulált ember szemének lekérése.

Microsoft.PerceptionSimulation.ISimulatedSixDofController

A szimulált emberhez társított 6-DOF vezérlőt leíró felület.

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

A csomópont pozíciójának lekérése a világhoz viszonyítva, méterben.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Status

A vezérlő aktuális állapotának lekérése vagy beállítása. Ahhoz, hogy a gombok mozgatása, elforgatása vagy lenyomása sikeres legyen, a vezérlő állapotát a Ki értéktől más értékre kell állítani.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Position

A szimulált vezérlő pozíciójának lekérése vagy beállítása az emberhez képest mérőkben.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Orientation

A szimulált vezérlő tájolásának lekérése vagy beállítása.

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

Helyezze át a szimulált vezérlő pozícióját az aktuális pozíciójához képest mérőkban.

Paraméterek

  • translation – A szimulált vezérlő fordításának mennyisége.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.PressButton(SimulatedSixDofControllerButton)

Kattintson egy gombra a szimulált vezérlőn. A rendszer csak akkor észleli, ha a vezérlő engedélyezve van.

Paraméterek

  • gomb – A lenyomni való gomb.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.ReleaseButton(SimulatedSixDofControllerButton)

Engedjen el egy gombot a szimulált vezérlőn. A rendszer csak akkor észleli, ha a vezérlő engedélyezve van.

Paraméterek

  • gomb – A felszabadítható gomb.

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

Egy szimulált ujjlenyomat pozíciójának lekért pozíciója a szimulált vezérlő touchpadén.

Paraméterek

  • x – Az ujjlenyomat vízszintes helyzete.
  • y – Az ujjlenyomat függőleges helyzete.

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

Állítsa be egy szimulált ujjlenyomat pozícióját a szimulált vezérlő touchpadén.

Paraméterek

  • x – Az ujjlenyomat vízszintes helyzete.
  • y – Az ujjlenyomat függőleges helyzete.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2

További tulajdonságok és metódusok érhetők el az ISimulatedSixDofController ISimulatedSixDofController2-re való átszámításával

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)

Szerezze be a szimulált ujjlenyomat pozícióját a szimulált vezérlőn.

Paraméterek

  • x – Az ujjlenyomat vízszintes pozíciója.
  • y – Az ujjlenyomat függőleges pozíciója.

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

Állítsa be a szimulált ujjlenyomat pozícióját a szimulált vezérlőn.

Paraméterek

  • x – Az ujjlenyomat vízszintes pozíciója.
  • y – Az ujjlenyomat függőleges pozíciója.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2.BatteryLevel

A szimulált vezérlő akkumulátor-szintjének lekérése vagy beállítása. Az értéknek 0,0-snál nagyobbnak és 100,0-snál kisebbnek vagy egyenlőnek kell lennie.

Microsoft.PerceptionSimulation.ISimulatedEyes

A szimulált ember tekintetét leíró interfész.

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

Microsoft.PerceptionSimulation.ISimulatedEyes.Rotation

A szimulált szem elforgatását olvassa be. A pozitív radiánok az óramutató járásával megegyező irányban forgassuk a tengely mentén való megjelenéskor.

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

A szimulált szem elforgatása az aktuális rotációhoz képest. A pozitív radiánok az óramutató járásával megegyező irányban forgassuk a tengely mentén való megjelenéskor.

Paraméterek

  • rotation ( elforgatás) – A rotációhoz szükséges mennyiség.

Microsoft.PerceptionSimulation.ISimulatedEyes.UlationState

Lekéri vagy beállítja a szimulált szem állapotát.

Microsoft.PerceptionSimulation.ISimulatedEyes.WorldPosition

A világhoz kapcsolódó csomópont pozíciójának lekérése mérőkben.

Microsoft.PerceptionSimulation.ISimulationRecording

Egy lejátszásra betöltött felvételhez készült felület.

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

Microsoft.PerceptionSimulation.ISimulationRecording.DataTypes

Lekéri a felvételben található adattípusok listáját.

Microsoft.PerceptionSimulation.ISimulationRecording.State

Lekéri a felvétel aktuális állapotát.

Microsoft.PerceptionSimulation.ISimulationRecording.Play

Indítsa el a lejátszást. Ha a felvétel szüneteltetve van, a lejátszás a szüneteltetett helyről folytatódik; Ha le van állítva, a lejátszás az elején kezdődik. Ha már játszik, a rendszer figyelmen kívül hagyja ezt a hívást.

Microsoft.PerceptionSimulation.ISimulationRecording.Pause

Szünetelteti a lejátszást az aktuális helyén. Ha a felvétel le van állítva, a hívás figyelmen kívül lesz hagyva.

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

Megkeresi a rögzítést a megadott időpontban (100 nanoszekundumos intervallumokban az elejétől), és ott szünetel. Ha az idő meghaladja a felvétel végét, akkor az utolsó képkockánál szünetel.

Paraméterek

  • ticks – A keresés ideje.

Microsoft.PerceptionSimulation.ISimulationRecording.Stop

Leállítja a lejátszást, és visszaállítja a pozíciót az elejére.

Microsoft.PerceptionSimulation.ISimulationRecordingCallback

Az állapotváltozások lejátszás közbeni fogadására való felület.

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

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

Akkor lesz meghívva, ha az ISimulationRecording lejátszási állapota megváltozott.

Paraméterek

  • newState – A felvétel új állapota.

Microsoft.PerceptionSimulation.PerceptionSimulationManager

Gyökérobjektum észlelésszimulációs objektumok létrehozásához.

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)

Hozzon létre egy objektumot a szimulált csomagok létrehozásához és a megadott fogadóhoz való kézbesítéshez.

Paraméterek

  • sink – Az a fogadó, amely az összes létrehozott csomagot fogadja.

Visszatérési érték

A létrehozott vezető.

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

Hozzon létre egy fogadót, amely az összes fogadott csomagot egy fájlban tárolja a megadott elérési úton.

Paraméterek

  • path – A létrehozni kívánt fájl elérési útja.

Visszatérési érték

A létrehozott fogadó.

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

Töltsön be egy felvételt a megadott fájlból.

Paraméterek

  • path – A betöltni kívánt fájl elérési útja.
  • factory – A felvétel által az ISimulationStreamSink létrehozásához használt gyár, ha szükséges.

Visszatérési érték

A betöltött felvétel.

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

Töltsön be egy felvételt a megadott fájlból.

Paraméterek

  • path – A betöltni kívánt fájl elérési útja.
  • factory – A felvétel által az ISimulationStreamSink létrehozásához használt gyár, ha szükséges.
  • visszahívás – Visszahívás, amely megkapja a rögzítés állapotának újragradiens frissítéseit.

Visszatérési érték

A betöltött felvétel.

Microsoft.PerceptionSimulation.StreamDataTypes

A streamadatok különböző típusait ismerteti.

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

Egy sentinel-érték, amely a stream adattípusok mellőzését jelzi.

Microsoft.PerceptionSimulation.StreamDataTypes.Head

Adatfolyam a fej pozíciójához és tájoláshoz.

Microsoft.PerceptionSimulation.StreamDataTypes.Hands

Adatok streamelése a kézmozdulatok pozíciójához és kézmozdulataihoz.

Microsoft.PerceptionSimulation.StreamDataTypes.SpatialMapping

Adatfolyam a környezet térbeli leképezéséhez.

Microsoft.PerceptionSimulation.StreamDataTypes.Fogazás

Adatstreamek az eszköz áramlásához. A rendszer csak távoli módban fogadja el a csomagokat.

Microsoft.PerceptionSimulation.StreamDataTypes.Environment

Streamelés az eszköz környezetében.

Microsoft.PerceptionSimulation.StreamDataTypes.SixDofControllers

Adatfolyam mozgásvezérlők számára.

Microsoft.PerceptionSimulation.StreamDataTypes.Eyes

Az adatok streamelése a szimulált ember szemével.

Microsoft.PerceptionSimulation.StreamDataTypes.DisplayConfiguration

Streamelés az eszköz megjelenítési konfigurációval.

Microsoft.PerceptionSimulation.StreamDataTypes.All

Egy sentinel érték, amely az összes rögzített adattípust jelzi.

Microsoft.PerceptionSimulation.ISimulationStreamSink

Egy objektum, amely adatcsomagokat fogad egy szimulációs streamből.

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

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

Egyetlen, belsőleg típusos és verziószámú csomagot fogad.

Paraméterek

  • length – A csomag hossza.
  • packet – A csomag adatai.

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory

Egy objektum, amely létrehozza az ISimulationStreamSink et.

public interface ISimulationStreamSinkFactory
{
    ISimulationStreamSink CreateSimulationStreamSink();
}

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory.CreateSimulationStreamSink()

Egyetlen ISimulationStreamSink-példányt hoz létre.

Visszatérési érték

A létrehozott fogadó.