Simulação de percepçãoPerception simulation

Deseja criar um teste automatizado para seu aplicativo?Do you want to build an automated test for your app? Você deseja que seus testes vão além dos testes de unidade de nível de componente e realmente exercitam seu aplicativo de ponta a ponta?Do you want your tests to go beyond component-level unit testing and really exercise your app end-to-end? A simulação de percepção é o que você está procurando.Perception Simulation is what you're looking for. A biblioteca de simulação de percepção envia dados de entrada humanos e mundiais para seu aplicativo para que você possa automatizar seus testes.The Perception Simulation library sends human and world input data to your app so you can automate your tests. Por exemplo, você pode simular a entrada de uma aparência humana para uma posição específica e repetível e, em seguida, usar um controlador de gesto ou movimento.For example, you can simulate the input of a human looking to a specific, repeatable position and then use a gesture or motion controller.

A simulação de percepção pode enviar uma entrada simulada como esta para um HoloLens físico, o emulador do HoloLens (primeira gen), o emulador do HoloLens 2 ou um PC com o portal de realidade misturada instalado.Perception Simulation can send simulated input like this to a physical HoloLens, the HoloLens emulator (first gen), the HoloLens 2 Emulator, or a PC with Mixed Reality Portal installed. A simulação de percepção ignora os sensores ao vivo em um dispositivo de realidade misturada e envia a entrada simulada para aplicativos em execução no dispositivo.Perception Simulation bypasses the live sensors on a Mixed Reality device and sends simulated input to applications running on the device. Os aplicativos recebem esses eventos de entrada por meio das mesmas APIs que sempre usam e não conseguem dizer a diferença entre a execução com sensores reais versus a simulação de percepção.Applications receive these input events through the same APIs they always use and can't tell the difference between running with real sensors versus Perception Simulation. A simulação de percepção é a mesma tecnologia usada pelos emuladores do HoloLens para enviar a entrada simulada para a máquina virtual do HoloLens.Perception Simulation is the same technology used by the HoloLens emulators to send simulated input to the HoloLens Virtual Machine.

Para começar a usar a simulação em seu código, comece criando um objeto IPerceptionSimulationManager.To begin using simulation in your code, start by creating an IPerceptionSimulationManager object. A partir desse objeto, você pode emitir comandos para controlar as propriedades de um "humano" simulado, incluindo a posição da cabeça, a posição da mão e os gestos.From that object, you can issue commands to control properties of a simulated "human", including head position, hand position, and gestures. Você também pode habilitar e manipular os controladores de movimento.You can also enable and manipulate motion controllers.

Configurando um projeto do Visual Studio para simulação de percepçãoSetting Up a Visual Studio Project for Perception Simulation

  1. Instale o emulador do HoloLens no seu computador de desenvolvimento.Install the HoloLens emulator on your development PC. O emulador inclui as bibliotecas que você usa para a simulação de percepção.The emulator includes the libraries you' use for Perception Simulation.
  2. Crie um novo projeto de desktop do Visual Studio C# (um projeto de console funciona muito bem para começar).Create a new Visual Studio C# desktop project (a Console Project works great to get started).
  3. Adicione os seguintes binários ao seu projeto como referências (projeto->referência ao suplemento de >...). Você pode encontrá-los em% ProgramFiles (x86)% \ Microsoft XDE \ (versão), como % ProgramFiles (x86)% \ Microsoft XDE \ 10.0.18362.0 para o emulador do HoloLens 2.Add the following binaries to your project as references (Project->Add->Reference...). You can find them in %ProgramFiles(x86)%\Microsoft XDE\(version), such as %ProgramFiles(x86)%\Microsoft XDE\10.0.18362.0 for the HoloLens 2 Emulator. (Observação: embora os binários façam parte do emulador do HoloLens 2, eles também funcionam para a realidade mista do Windows na área de trabalho.) um.(Note: although the binaries are part of the HoloLens 2 Emulator, they also work for Windows Mixed Reality on the desktop.) a. Wrapper de C# gerenciado por PerceptionSimulationManager.Interop.dll para simulação de percepção.PerceptionSimulationManager.Interop.dll - Managed C# wrapper for Perception Simulation. b.b. PerceptionSimulationRest.dll-Library para configurar um canal de comunicação de soquete da Web para o HoloLens ou o emulador.PerceptionSimulationRest.dll - Library for setting up a web-socket communication channel to the HoloLens or emulator. c.c. SimulationStream.Interop.dll-tipos compartilhados para simulação.SimulationStream.Interop.dll - Shared types for simulation.
  4. Adicione o PerceptionSimulationManager.dll binário de implementação ao seu projeto a.Add the implementation binary PerceptionSimulationManager.dll to your project a. Primeiro, adicione-o como um binário ao projeto (projeto->adicionar >item existente...). Salve-o como um link para que ele não o copie para a pasta de origem do projeto.First add it as a binary to the project (Project->Add->Existing Item...). Save it as a link so that it doesn't copy it to your project source folder. Adicione PerceptionSimulationManager.dll ao projeto como um link b.Add PerceptionSimulationManager.dll to the project as a link b. Em seguida, verifique se ele é copiado para a pasta de saída na compilação.Then make sure that it gets copied to your output folder on build. Isso está na folha de propriedades do binário.This is in the property sheet for the binary. Marque PerceptionSimulationManager.dll para copiar para o diretório de saídaMark PerceptionSimulationManager.dll to copy to the output directory
  5. Defina sua plataforma de solução ativa como x64.Set your active solution platform to x64. (Use o Configuration Manager para criar uma entrada de plataforma para x64 se ainda não existir uma.)(Use the Configuration Manager to create a Platform entry for x64 if one doesn't already exist.)

Criando um objeto do Gerenciador de IPerceptionSimulationCreating an IPerceptionSimulation Manager Object

Para controlar a simulação, você emitirá atualizações para objetos recuperados de um objeto IPerceptionSimulationManager.To control simulation, you'll issue updates to objects retrieved from an IPerceptionSimulationManager object. A primeira etapa é obter esse objeto e conectá-lo ao seu dispositivo de destino ou emulador.The first step is to get that object and connect it to your target device or emulator. Você pode obter o endereço IP do emulador clicando no botão portal do dispositivo na barra de ferramentasYou can get the IP address of your emulator by clicking on the Device Portal button in the toolbar

Abrir o ícone do portal do dispositivo abra o portal do dispositivo: Abra o portal do dispositivo do Windows para o sistema operacional do HoloLens no emulador.Open Device Portal icon Open Device Portal: Open the Windows Device Portal for the HoloLens OS in the emulator. Para a realidade mista do Windows, isso pode ser recuperado no aplicativo configurações em "atualizar & segurança" e, em seguida, "para desenvolvedores" na seção "conectar usando:" em "habilitar o portal do dispositivo".For Windows Mixed Reality, this can be retrieved in the Settings app under "Update & Security", then "For developers" in the "Connect using:" section under "Enable Device Portal." Lembre-se de anotar o endereço IP e a porta.Be sure to note both the IP address and port.

Primeiro, você chamará RestSimulationStreamSink. Create para obter um objeto RestSimulationStreamSink.First, you'll call RestSimulationStreamSink.Create to get a RestSimulationStreamSink object. Esse é o dispositivo ou emulador de destino que você controlará em uma conexão http.This is the target device or emulator that you'll control over an http connection. Seus comandos serão passados e manipulados pelo portal do dispositivo Windows em execução no dispositivo ou emulador.Your commands will be passed to and handled by the Windows Device Portal running on the device or emulator. Os quatro parâmetros necessários para criar um objeto são:The four parameters you'll need to create an object are:

  • URI Uri-endereço IP do dispositivo de destino (por exemplo, " https://123.123.123.123 " ou " https://123.123.123.123:50080 ")Uri uri - IP address of the target device (e.g., "https://123.123.123.123" or "https://123.123.123.123:50080")
  • System .net. NetworkCredential credenciais-nome de usuário/senha para se conectar ao portal de dispositivo do Windows no dispositivo ou emulador de destino.System.Net.NetworkCredential credentials - Username/password for connecting to the Windows Device Portal on the target device or emulator. Se você estiver se conectando ao emulador por meio de seu endereço local (por exemplo,168... *) no mesmo PC, todas as credenciais serão aceitas.If you're connecting to the emulator via its local address (e.g., 168...*) on the same PC, any credentials will be accepted.
  • bool normal-true para prioridade normal, false para baixa prioridade.bool normal - True for normal priority, false for low priority. Em geral, você desejará definir isso como verdadeiro para cenários de teste, o que permite que seu teste assuma o controle.You generally want to set this to true for test scenarios, which allows your test to take control. O emulador e a simulação de realidade mista do Windows usam conexões de baixa prioridade.The emulator and Windows Mixed Reality simulation use low-priority connections. Se o teste também usar uma conexão de baixa prioridade, a conexão estabelecida mais recentemente estará no controle.If your test also uses a low-priority connection, the most recently established connection will be in control.
  • System. Threading. CancellationToken token-token para cancelar a operação assíncrona.System.Threading.CancellationToken token - Token to cancel the async operation.

Em segundo lugar, você criará o IPerceptionSimulationManager.Second, you'll create the IPerceptionSimulationManager. Esse é o objeto que você usa para controlar a simulação.This is the object you use to control simulation. Isso também deve ser feito em um método assíncrono.This must also be done in an async method.

Controlar o humano simuladoControl the simulated Human

Um IPerceptionSimulationManager tem uma propriedade humana que retorna um objeto ISimulatedHuman.An IPerceptionSimulationManager has a Human property that returns an ISimulatedHuman object. Para controlar o humano simulado, execute operações nesse objeto.To control the simulated human, perform operations on this object. Por exemplo:For example:

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

Aplicativo de console C# de exemplo básicoBasic Sample C# console application

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

Aplicativo de console C# de exemplo estendidoExtended Sample C# console application

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

Observação em controladores 6-DOFNote on 6-DOF controllers

Antes de chamar qualquer propriedade em métodos em um controlador de 6 DOF simulado, você deve ativar o controlador.Before calling any properties on methods on a simulated 6-DOF controller, you must activate the controller. Não fazer isso resultará em uma exceção.Not doing so will result in an exception. A partir da atualização do Windows 10 de maio de 2019, os controladores 6 DOF simulados podem ser instalados e ativados definindo a propriedade status no objeto ISimulatedSixDofController como SimulatedSixDofControllerStatus. Active.Starting with the Windows 10 May 2019 Update, simulated 6-DOF controllers can be installed and activated by setting the Status property on the ISimulatedSixDofController object to SimulatedSixDofControllerStatus.Active. Na atualização do Windows 10 de outubro de 2018 e anterior, você deve instalar separadamente um controlador de 6 DOF simulado primeiro chamando a ferramenta PerceptionSimulationDevice localizada na pasta \Windows\System32.In the Windows 10 October 2018 Update and earlier, you must separately install a simulated 6-DOF controller first by calling the PerceptionSimulationDevice tool located in the \Windows\System32 folder. O uso dessa ferramenta é o seguinte:The usage of this tool is as follows:

    PerceptionSimulationDevice.exe <action> 6dof <instance>

Por exemploFor example

    PerceptionSimulationDevice.exe i 6dof 1

As ações com suporte são:Supported actions are:

  • i = instalari = install
  • q = consultaq = query
  • r = removerr = remove

As instâncias com suporte são:Supported instances are:

  • 1 = o controlador de 6 DOF à esquerda1 = the left 6-DOF controller
  • 2 = o controlador de 6 DOF à direita2 = the right 6-DOF controller

O código de saída do processo indicará êxito (um valor de retorno zero) ou falha (um valor de retorno diferente de zero).The exit code of the process will indicate success (a zero return value) or failure (a non-zero return value). Ao usar a ação ' q ' para consultar se um controlador está instalado, o valor de retorno será zero (0) se o controlador ainda não estiver instalado ou um (1) se o controlador estiver instalado.When using the 'q' action to query whether a controller is installed, the return value will be zero (0) if the controller isn't already installed or one (1) if the controller is installed.

Ao remover um controlador na atualização do Windows 10 de outubro de 2018 ou anterior, defina seu status como off por meio da API primeiro e, em seguida, chame a ferramenta PerceptionSimulationDevice.When removing a controller on the Windows 10 October 2018 Update or earlier, set its status to Off via the API first, then call the PerceptionSimulationDevice tool.

Essa ferramenta deve ser executada como administrador.This tool must be run as Administrator.

Referência de APIAPI Reference

Microsoft. PerceptionSimulation. SimulatedDeviceTypeMicrosoft.PerceptionSimulation.SimulatedDeviceType

Descreve um tipo de dispositivo simuladoDescribes a simulated device type

public enum SimulatedDeviceType
{
    Reference = 0
}

Microsoft. PerceptionSimulation. SimulatedDeviceType. ReferenceMicrosoft.PerceptionSimulation.SimulatedDeviceType.Reference

Um dispositivo de referência fictícia, o padrão para PerceptionSimulationManagerA fictitious reference device, the default for PerceptionSimulationManager

Microsoft. PerceptionSimulation. HeadTrackerModeMicrosoft.PerceptionSimulation.HeadTrackerMode

Descreve um modo de controlador de cabeçalhoDescribes a head tracker mode

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

Microsoft. PerceptionSimulation. HeadTrackerMode. DefaultMicrosoft.PerceptionSimulation.HeadTrackerMode.Default

Rastreamento de cabeçalho padrão.Default Head Tracking. Isso significa que o sistema pode selecionar o melhor modo de controle de cabeçalho com base nas condições de tempo de execução.This means the system may select the best head tracking mode based upon runtime conditions.

Microsoft. PerceptionSimulation. HeadTrackerMode. OrientationMicrosoft.PerceptionSimulation.HeadTrackerMode.Orientation

Controle de cabeçalho somente orientação.Orientation Only Head Tracking. Isso significa que a posição controlada pode não ser confiável, e algumas funcionalidades dependentes da posição de cabeçalho podem não estar disponíveis.This means that the tracked position may not be reliable, and some functionality dependent on head position may not be available.

Microsoft. PerceptionSimulation. HeadTrackerMode. PositionMicrosoft.PerceptionSimulation.HeadTrackerMode.Position

Acompanhamento da cabeça posicional.Positional Head Tracking. Isso significa que a posição e a orientação da cabeça controlada são confiáveisThis means that the tracked head position and orientation are both reliable

Microsoft. PerceptionSimulation. SimulatedGestureMicrosoft.PerceptionSimulation.SimulatedGesture

Descreve um gesto simuladoDescribes a simulated gesture

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

Microsoft. PerceptionSimulation. SimulatedGesture. NoneMicrosoft.PerceptionSimulation.SimulatedGesture.None

Um valor de sentinela usado para indicar que não há gestos.A sentinel value used to indicate no gestures.

Microsoft. PerceptionSimulation. SimulatedGesture. FingerPressedMicrosoft.PerceptionSimulation.SimulatedGesture.FingerPressed

Um gesto de dedo pressionado.A finger pressed gesture.

Microsoft. PerceptionSimulation. SimulatedGesture. FingerReleasedMicrosoft.PerceptionSimulation.SimulatedGesture.FingerReleased

Um gesto de liberação de dedo.A finger released gesture.

Microsoft. PerceptionSimulation. SimulatedGesture. HomeMicrosoft.PerceptionSimulation.SimulatedGesture.Home

O gesto de residência/sistema.The home/system gesture.

Microsoft. PerceptionSimulation. SimulatedGesture. MaxMicrosoft.PerceptionSimulation.SimulatedGesture.Max

O gesto máximo válido.The maximum valid gesture.

Microsoft. PerceptionSimulation. SimulatedSixDofControllerStatusMicrosoft.PerceptionSimulation.SimulatedSixDofControllerStatus

Os Estados possíveis de um controlador de 6 DOF simulado.The possible states of a simulated 6-DOF controller.

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

Microsoft. PerceptionSimulation. SimulatedSixDofControllerStatus. offMicrosoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Off

O controlador de 6 DOF está desligado.The 6-DOF controller is turned off.

Microsoft. PerceptionSimulation. SimulatedSixDofControllerStatus. activeMicrosoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Active

O controlador de 6 DOF é ativado e acompanhado.The 6-DOF controller is turned on and tracked.

Microsoft. PerceptionSimulation. SimulatedSixDofControllerStatus. TrackingLostMicrosoft.PerceptionSimulation.SimulatedSixDofControllerStatus.TrackingLost

O controlador de 6 DOF está ativado, mas não pode ser acompanhado.The 6-DOF controller is turned on but cannot be tracked.

Microsoft. PerceptionSimulation. SimulatedSixDofControllerButtonMicrosoft.PerceptionSimulation.SimulatedSixDofControllerButton

Os botões com suporte em um controlador de 6 DOF simulado.The supported buttons on a simulated 6-DOF controller.

public enum SimulatedSixDofControllerButton
{
    None = 0,
    Home = 1,
    Menu = 2,
    Grip = 4,
    TouchpadPress = 8,
    Select = 16,
    TouchpadTouch = 32,
    Thumbstick = 64,
    Max = Thumbstick
}

Microsoft. PerceptionSimulation. SimulatedSixDofControllerButton. NoneMicrosoft.PerceptionSimulation.SimulatedSixDofControllerButton.None

Um valor de sentinela usado para indicar nenhum botão.A sentinel value used to indicate no buttons.

Microsoft. PerceptionSimulation. SimulatedSixDofControllerButton. HomeMicrosoft.PerceptionSimulation.SimulatedSixDofControllerButton.Home

O botão página inicial é pressionado.The Home button is pressed.

Microsoft. PerceptionSimulation. SimulatedSixDofControllerButton. menuMicrosoft.PerceptionSimulation.SimulatedSixDofControllerButton.Menu

O botão de menu é pressionado.The Menu button is pressed.

Microsoft. PerceptionSimulation. SimulatedSixDofControllerButton. SegureMicrosoft.PerceptionSimulation.SimulatedSixDofControllerButton.Grip

O botão de alça é pressionado.The Grip button is pressed.

Microsoft. PerceptionSimulation. SimulatedSixDofControllerButton. TouchpadPressMicrosoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadPress

O TouchPad é pressionado.The TouchPad is pressed.

Microsoft. PerceptionSimulation. SimulatedSixDofControllerButton. SelectMicrosoft.PerceptionSimulation.SimulatedSixDofControllerButton.Select

O botão Selecionar é pressionado.The Select button is pressed.

Microsoft. PerceptionSimulation. SimulatedSixDofControllerButton. TouchpadTouchMicrosoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadTouch

O TouchPad é tocado.The TouchPad is touched.

Microsoft. PerceptionSimulation. SimulatedSixDofControllerButton. ThumbstickMicrosoft.PerceptionSimulation.SimulatedSixDofControllerButton.Thumbstick

O Thumbstick é pressionado.The Thumbstick is pressed.

Microsoft. PerceptionSimulation. SimulatedSixDofControllerButton. MaxMicrosoft.PerceptionSimulation.SimulatedSixDofControllerButton.Max

O botão máximo válido.The maximum valid button.

Microsoft. PerceptionSimulation. SimulatedEyesCalibrationStateMicrosoft.PerceptionSimulation.SimulatedEyesCalibrationState

O estado de calibragem dos olhos simuladosThe calibration state of the simulated eyes

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

Microsoft. PerceptionSimulation. SimulatedEyesCalibrationState. indisponívelMicrosoft.PerceptionSimulation.SimulatedEyesCalibrationState.Unavailable

A calibragem de olhos não está disponível.The eyes calibration is unavailable.

Microsoft. PerceptionSimulation. SimulatedEyesCalibrationState. ReadyMicrosoft.PerceptionSimulation.SimulatedEyesCalibrationState.Ready

Os olhos foram calibrados.The eyes have been calibrated. Esse é o valor padrão.This is the default value.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.ConfigUringMicrosoft.PerceptionSimulation.SimulatedEyesCalibrationState.Configuring

Os olhos estão sendo calibrados.The eyes are being calibrated.

Microsoft. PerceptionSimulation. SimulatedEyesCalibrationState. UserCalibrationNeededMicrosoft.PerceptionSimulation.SimulatedEyesCalibrationState.UserCalibrationNeeded

Os olhos precisam ser calibrados.The eyes need to be calibrated.

Microsoft. PerceptionSimulation. SimulatedHandJointTrackingAccuracyMicrosoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy

A precisão de rastreamento de um conjunto de mãos.The tracking accuracy of a joint of the hand.

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

Microsoft. PerceptionSimulation. SimulatedHandJointTrackingAccuracy. indisponívelMicrosoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Unavailable

A junção não é acompanhada.The joint isn't tracked.

Microsoft. PerceptionSimulation. SimulatedHandJointTrackingAccuracy. aproximadoMicrosoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Approximate

A posição conjunta é inferida.The joint position is inferred.

Microsoft. PerceptionSimulation. SimulatedHandJointTrackingAccuracy. VisibleMicrosoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Visible

A junção é totalmente controlada.The joint is fully tracked.

Microsoft. PerceptionSimulation. SimulatedHandPoseMicrosoft.PerceptionSimulation.SimulatedHandPose

A precisão de rastreamento de um conjunto de mãos.The tracking accuracy of a joint of the hand.

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

Microsoft. PerceptionSimulation. SimulatedHandPose. ClosedMicrosoft.PerceptionSimulation.SimulatedHandPose.Closed

As junções de dedo da mão são configuradas para refletir uma pose fechada.The hand's finger joints are configured to reflect a closed pose.

Microsoft. PerceptionSimulation. SimulatedHandPose. OpenMicrosoft.PerceptionSimulation.SimulatedHandPose.Open

As junções de dedo da mão são configuradas para refletir uma pose aberta.The hand's finger joints are configured to reflect an open pose.

Microsoft. PerceptionSimulation. SimulatedHandPose. PointMicrosoft.PerceptionSimulation.SimulatedHandPose.Point

As junções de dedo da mão são configuradas para refletir uma pose de apontador.The hand's finger joints are configured to reflect a pointing pose.

Microsoft. PerceptionSimulation. SimulatedHandPose. pinçarMicrosoft.PerceptionSimulation.SimulatedHandPose.Pinch

As junções de dedo da mão são configuradas para refletir uma pose de pinçagem.The hand's finger joints are configured to reflect a pinching pose.

Microsoft. PerceptionSimulation. SimulatedHandPose. MaxMicrosoft.PerceptionSimulation.SimulatedHandPose.Max

O valor máximo válido para SimulatedHandPose.The maximum valid value for SimulatedHandPose.

Microsoft. PerceptionSimulation. PlaybackstateMicrosoft.PerceptionSimulation.PlaybackState

Descreve o estado de uma reprodução.Describes the state of a playback.

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

Microsoft. PerceptionSimulation. Playbackstate. paradoMicrosoft.PerceptionSimulation.PlaybackState.Stopped

A gravação está atualmente parada e pronta para reprodução.The recording is currently stopped and ready for playback.

Microsoft. PerceptionSimulation. Playbackstate. reproduzindoMicrosoft.PerceptionSimulation.PlaybackState.Playing

A gravação está sendo executada no momento.The recording is currently playing.

Microsoft. PerceptionSimulation. Playbackstate. PausedMicrosoft.PerceptionSimulation.PlaybackState.Paused

A gravação está em pausa no momento.The recording is currently paused.

Microsoft. PerceptionSimulation. Playbackstate. endMicrosoft.PerceptionSimulation.PlaybackState.End

A gravação atingiu o final.The recording has reached the end.

Microsoft. PerceptionSimulation. Vector3Microsoft.PerceptionSimulation.Vector3

Descreve um vetor de três componentes, que pode descrever um ponto ou um vetor no espaço 3D.Describes a three components vector, which might describe a point or a vector in 3D space.

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

Microsoft. PerceptionSimulation. Vector3. XMicrosoft.PerceptionSimulation.Vector3.X

O componente X do vetor.The X component of the vector.

Microsoft. PerceptionSimulation. Vector3. YMicrosoft.PerceptionSimulation.Vector3.Y

O componente Y do vetor.The Y component of the vector.

Microsoft. PerceptionSimulation. Vector3. ZMicrosoft.PerceptionSimulation.Vector3.Z

O componente Z do vetor.The Z component of the vector.

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

Construa um novo Vector3.Construct a new Vector3.

ParâmetrosParameters

  • x – o componente x do vetor.x - The x component of the vector.
  • y-o componente y do vetor.y - The y component of the vector.
  • z-o componente z do vetor.z - The z component of the vector.

Microsoft. PerceptionSimulation. Rotation3Microsoft.PerceptionSimulation.Rotation3

Descreve uma rotação de três componentes.Describes a three components rotation.

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

Microsoft. PerceptionSimulation. Rotation3. pitchMicrosoft.PerceptionSimulation.Rotation3.Pitch

O componente de pitch da rotação, em volta do eixo X.The Pitch component of the Rotation, down around the X axis.

Microsoft. PerceptionSimulation. Rotation3. GuinadMicrosoft.PerceptionSimulation.Rotation3.Yaw

O componente de guinada da rotação, logo em volta do eixo Y.The Yaw component of the Rotation, right around the Y axis.

Microsoft. PerceptionSimulation. Rotation3. rollMicrosoft.PerceptionSimulation.Rotation3.Roll

O componente de roll da rotação, logo em volta do eixo Z.The Roll component of the Rotation, right around the Z axis.

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

Construa um novo Rotation3.Construct a new Rotation3.

ParâmetrosParameters

  • Pitch-o componente de pitch da rotação.pitch - The pitch component of the Rotation.
  • guinada-o componente de guinada da rotação.yaw - The yaw component of the Rotation.
  • roll-o componente de rolagem da rotação.roll - The roll component of the Rotation.

Microsoft. PerceptionSimulation. SimulatedHandJointConfigurationMicrosoft.PerceptionSimulation.SimulatedHandJointConfiguration

Descreve a configuração de uma junção em uma mão simulada.Describes the configuration of a joint on a simulated hand.

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

Microsoft. PerceptionSimulation. SimulatedHandJointConfiguration. PositionMicrosoft.PerceptionSimulation.SimulatedHandJointConfiguration.Position

A posição da junção.The position of the joint.

Microsoft. PerceptionSimulation. SimulatedHandJointConfiguration. RotationMicrosoft.PerceptionSimulation.SimulatedHandJointConfiguration.Rotation

A rotação da junção.The rotation of the joint.

Microsoft. PerceptionSimulation. SimulatedHandJointConfiguration. TrackingAccuracyMicrosoft.PerceptionSimulation.SimulatedHandJointConfiguration.TrackingAccuracy

A precisão de rastreamento da junção.The tracking accuracy of the joint.

Microsoft. PerceptionSimulation. frustumMicrosoft.PerceptionSimulation.Frustum

Descreve um frustum de exibição, como normalmente usado por uma câmera.Describes a view frustum, as typically used by a camera.

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

Microsoft. PerceptionSimulation. frustum. nearMicrosoft.PerceptionSimulation.Frustum.Near

A distância mínima que está contida no frustum.The minimum distance that is contained in the frustum.

Microsoft. PerceptionSimulation. frustum. farMicrosoft.PerceptionSimulation.Frustum.Far

A distância máxima que está contida no frustum.The maximum distance that is contained in the frustum.

Microsoft. PerceptionSimulation. frustum. FieldOfViewMicrosoft.PerceptionSimulation.Frustum.FieldOfView

O campo horizontal de exibição do frustum, em radianos (menor que PI).The horizontal field of view of the frustum, in radians (less than PI).

Microsoft. PerceptionSimulation. frustum. AspectRatioMicrosoft.PerceptionSimulation.Frustum.AspectRatio

A proporção do campo horizontal de exibição para o campo vertical da exibição.The ratio of horizontal field of view to vertical field of view.

Microsoft. PerceptionSimulation. SimulatedDisplayConfigurationMicrosoft.PerceptionSimulation.SimulatedDisplayConfiguration

Descreve a configuração da exibição do headset simulado.Describes the configuration of the simulated headset's display.

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. LeftEyePositionMicrosoft.PerceptionSimulation.SimulatedDisplayConfiguration.LeftEyePosition

A transformação do centro da cabeça à esquerda para fins de renderização de estéreo.The transform from the center of the head to the left eye for purposes of stereo rendering.

Microsoft. PerceptionSimulation. SimulatedDisplayConfiguration. LeftEyeRotationMicrosoft.PerceptionSimulation.SimulatedDisplayConfiguration.LeftEyeRotation

A rotação do olho à esquerda para fins de renderização de estéreo.The rotation of the left eye for purposes of stereo rendering.

Microsoft. PerceptionSimulation. SimulatedDisplayConfiguration. RightEyePositionMicrosoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyePosition

A transformação do centro da cabeça para o olho certo para fins de renderização de estéreo.The transform from the center of the head to the right eye for purposes of stereo rendering.

Microsoft. PerceptionSimulation. SimulatedDisplayConfiguration. RightEyeRotationMicrosoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyeRotation

A rotação do olho certo para fins de renderização de estéreo.The rotation of the right eye for purposes of stereo rendering.

Microsoft. PerceptionSimulation. SimulatedDisplayConfiguration. IPDMicrosoft.PerceptionSimulation.SimulatedDisplayConfiguration.Ipd

O valor de IPD relatado pelo sistema para fins de renderização de estéreo.The Ipd value reported by the system for purposes of stereo rendering.

Microsoft. PerceptionSimulation. SimulatedDisplayConfiguration. ApplyEyeTransformsMicrosoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyEyeTransforms

Se os valores fornecidos para transformações de olho esquerdo e direito devem ser considerados válidos e aplicados ao sistema em execução.Whether the values provided for left and right eye transforms should be considered valid and applied to the running system.

Microsoft. PerceptionSimulation. SimulatedDisplayConfiguration. ApplyIpdMicrosoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyIpd

Se o valor fornecido para o IPD deve ser considerado válido e aplicado ao sistema em execução.Whether the value provided for Ipd should be considered valid and applied to the running system.

Microsoft. PerceptionSimulation. IPerceptionSimulationManagerMicrosoft.PerceptionSimulation.IPerceptionSimulationManager

Raiz para gerar os pacotes usados para controlar um dispositivo.Root for generating the packets used to control a device.

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

Microsoft. PerceptionSimulation. IPerceptionSimulationManager. DeviceMicrosoft.PerceptionSimulation.IPerceptionSimulationManager.Device

Recupere o objeto de dispositivo simulado que interpreta o humano simulado e o mundo simulado.Retrieve the simulated device object that interprets the simulated human and the simulated world.

Microsoft. PerceptionSimulation. IPerceptionSimulationManager. HumanMicrosoft.PerceptionSimulation.IPerceptionSimulationManager.Human

Recupere o objeto que controla o humano simulado.Retrieve the object that controls the simulated human.

Microsoft. PerceptionSimulation. IPerceptionSimulationManager. ResetMicrosoft.PerceptionSimulation.IPerceptionSimulationManager.Reset

Redefine a simulação para seu estado padrão.Resets the simulation to its default state.

Microsoft. PerceptionSimulation. ISimulatedDeviceMicrosoft.PerceptionSimulation.ISimulatedDevice

Interface que descreve o dispositivo, que interpreta o mundo simulado e o humano simuladoInterface describing the device, which interprets the simulated world and the simulated human

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

Microsoft. PerceptionSimulation. ISimulatedDevice. HeadTrackerMicrosoft.PerceptionSimulation.ISimulatedDevice.HeadTracker

Recupere o controlador de cabeçalho do dispositivo simulado.Retrieve the Head Tracker from the Simulated Device.

Microsoft. PerceptionSimulation. ISimulatedDevice. HandTrackerMicrosoft.PerceptionSimulation.ISimulatedDevice.HandTracker

Recupere o rastreador de mão do dispositivo simulado.Retrieve the Hand Tracker from the Simulated Device.

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

Defina as propriedades do dispositivo simulado para corresponder ao tipo de dispositivo fornecido.Set the properties of the simulated device to match the provided device type.

ParâmetrosParameters

  • tipo – o novo tipo de dispositivo simuladotype - The new type of Simulated Device

Microsoft. PerceptionSimulation. ISimulatedDevice2Microsoft.PerceptionSimulation.ISimulatedDevice2

Propriedades adicionais estão disponíveis por meio da conversão de ISimulatedDevice para ISimulatedDevice2Additional properties are available by casting the ISimulatedDevice to ISimulatedDevice2

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

};

Microsoft. PerceptionSimulation. ISimulatedDevice2. IsUserPresentMicrosoft.PerceptionSimulation.ISimulatedDevice2.IsUserPresent

Recupere ou defina se o humano simulado está ou não ativamente desativando o headset.Retrieve or set whether or not the simulated human is actively wearing the headset.

Microsoft. PerceptionSimulation. ISimulatedDevice2. DisplayConfigurationMicrosoft.PerceptionSimulation.ISimulatedDevice2.DisplayConfiguration

Recupere ou defina as propriedades da exibição simulada.Retrieve or set the properties of the simulated display.

Microsoft. PerceptionSimulation. ISimulatedHeadTrackerMicrosoft.PerceptionSimulation.ISimulatedHeadTracker

Interface que descreve a parte do dispositivo simulado que controla o início do humano simulado.Interface describing the portion of the simulated device that tracks the head of the simulated human.

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

Microsoft. PerceptionSimulation. ISimulatedHeadTracker. HeadTrackerModeMicrosoft.PerceptionSimulation.ISimulatedHeadTracker.HeadTrackerMode

Recupera e define o modo de controlador de cabeçalho atual.Retrieves and sets the current head tracker mode.

Microsoft. PerceptionSimulation. ISimulatedHandTrackerMicrosoft.PerceptionSimulation.ISimulatedHandTracker

Interface que descreve a parte do dispositivo simulado que controla as mãos do humano simuladoInterface describing the portion of the simulated device that tracks the hands of the simulated human

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. WorldPositionMicrosoft.PerceptionSimulation.ISimulatedHandTracker.WorldPosition

Recupere a posição do nó com relação ao mundo, em metros.Retrieve the position of the node with relation to the world, in meters.

Microsoft. PerceptionSimulation. ISimulatedHandTracker. PositionMicrosoft.PerceptionSimulation.ISimulatedHandTracker.Position

Recupere e defina a posição do controlador de mão simulado em relação ao centro do cabeçalho.Retrieve and set the position of the simulated hand tracker, relative to the center of the head.

Microsoft. PerceptionSimulation. ISimulatedHandTracker. pitchMicrosoft.PerceptionSimulation.ISimulatedHandTracker.Pitch

Recupere e defina o timbre inferior do controlador de mão simulado.Retrieve and set the downward pitch of the simulated hand tracker.

Microsoft. PerceptionSimulation. ISimulatedHandTracker. FrustumIgnoredMicrosoft.PerceptionSimulation.ISimulatedHandTracker.FrustumIgnored

Recupere e defina se a frustum do controlador de mão simulado é ignorada.Retrieve and set whether the frustum of the simulated hand tracker is ignored. Quando ignorado, ambas as mãos estão sempre visíveis.When ignored, both hands are always visible. Quando não ignoradas (as mãos padrão) ficam visíveis apenas quando estão dentro do frustum do rastreador.When not ignored (the default) hands are only visible when they are within the frustum of the hand tracker.

Microsoft. PerceptionSimulation. ISimulatedHandTracker. frustumMicrosoft.PerceptionSimulation.ISimulatedHandTracker.Frustum

Recupere e defina as propriedades frustum usadas para determinar se as mãos estão visíveis para o controlador de mão simulado.Retrieve and set the frustum properties used to determine if hands are visible to the simulated hand tracker.

Microsoft. PerceptionSimulation. ISimulatedHumanMicrosoft.PerceptionSimulation.ISimulatedHuman

Interface de nível superior para controlar o humano simulado.Top-level interface for controlling the simulated human.

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

Recupere e defina a posição do nó com relação ao mundo, em metros.Retrieve and set the position of the node with relation to the world, in meters. A posição corresponde a um ponto no centro dos pés humanos.The position corresponds to a point at the center of the human's feet.

Microsoft. PerceptionSimulation. ISimulatedHuman. DirectionMicrosoft.PerceptionSimulation.ISimulatedHuman.Direction

Recupere e defina a direção das faces humanas simuladas do mundo.Retrieve and set the direction the simulated human faces in the world. 0 radianos está voltado para baixo no eixo Z negativo.0 radians faces down the negative Z axis. Radianos positivos giram no sentido horário sobre o eixo Y.Positive radians rotate clockwise about the Y axis.

Microsoft. PerceptionSimulation. ISimulatedHuman. HeightMicrosoft.PerceptionSimulation.ISimulatedHuman.Height

Recupere e defina a altura do humano simulado, em metros.Retrieve and set the height of the simulated human, in meters.

Microsoft. PerceptionSimulation. ISimulatedHuman. LeftHandMicrosoft.PerceptionSimulation.ISimulatedHuman.LeftHand

Recupere o lado esquerdo do humano simulado.Retrieve the left hand of the simulated human.

Microsoft. PerceptionSimulation. ISimulatedHuman. RightHandMicrosoft.PerceptionSimulation.ISimulatedHuman.RightHand

Recupere o lado direito do humano simulado.Retrieve the right hand of the simulated human.

Microsoft. PerceptionSimulation. ISimulatedHuman. HeadMicrosoft.PerceptionSimulation.ISimulatedHuman.Head

Recupere o cabeçalho do humano simulado.Retrieve the head of the simulated human.

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

Mova o humano simulado relativo à sua posição atual, em metros.Move the simulated human relative to its current position, in meters.

ParâmetrosParameters

  • translação-a tradução a ser movida, relativa à posição atual.translation - The translation to move, relative to current position.

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

Girar o humano simulado em relação à sua direção atual, no sentido horário, sobre o eixo YRotate the simulated human relative to its current direction, clockwise about the Y axis

ParâmetrosParameters

  • radianos-o valor a ser girado em volta do eixo Y.radians - The amount to rotate around the Y axis.

Microsoft. PerceptionSimulation. ISimulatedHuman2Microsoft.PerceptionSimulation.ISimulatedHuman2

Propriedades adicionais estão disponíveis por meio da conversão de ISimulatedHuman para ISimulatedHuman2Additional properties are available by casting the ISimulatedHuman to ISimulatedHuman2

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

Microsoft. PerceptionSimulation. ISimulatedHuman2. LeftControllerMicrosoft.PerceptionSimulation.ISimulatedHuman2.LeftController

Recupere o controlador esquerdo 6-DOF.Retrieve the left 6-DOF controller.

Microsoft. PerceptionSimulation. ISimulatedHuman2. RightControllerMicrosoft.PerceptionSimulation.ISimulatedHuman2.RightController

Recupere o controlador de 6 DOF à direita.Retrieve the right 6-DOF controller.

Microsoft. PerceptionSimulation. ISimulatedHandMicrosoft.PerceptionSimulation.ISimulatedHand

Interface que descreve uma mão do humano simuladoInterface describing a hand of the simulated human

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. WorldPositionMicrosoft.PerceptionSimulation.ISimulatedHand.WorldPosition

Recupere a posição do nó com relação ao mundo, em metros.Retrieve the position of the node with relation to the world, in meters.

Microsoft. PerceptionSimulation. ISimulatedHand. PositionMicrosoft.PerceptionSimulation.ISimulatedHand.Position

Recupere e defina a posição da mão simulada em relação ao humano, em metros.Retrieve and set the position of the simulated hand relative to the human, in meters.

Microsoft. PerceptionSimulation. ISimulatedHand. ActivatedMicrosoft.PerceptionSimulation.ISimulatedHand.Activated

Recuperar e definir se a mão está ativada no momento.Retrieve and set whether the hand is currently activated.

Microsoft. PerceptionSimulation. ISimulatedHand. VisibleMicrosoft.PerceptionSimulation.ISimulatedHand.Visible

Recupere se a mão está visível no momento para o SimulatedDevice (ou seja, se está em uma posição a ser detectada pelo HandTracker).Retrieve whether the hand is currently visible to the SimulatedDevice (that is, whether it's in a position to be detected by the HandTracker).

Microsoft. PerceptionSimulation. ISimulatedHand. EnsureVisibleMicrosoft.PerceptionSimulation.ISimulatedHand.EnsureVisible

Mova a mão de modo que fique visível para o SimulatedDevice.Move the hand such that it is visible to the SimulatedDevice.

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

Mova a posição da mão simulada em relação à sua posição atual, em metros.Move the position of the simulated hand relative to its current position, in meters.

ParâmetrosParameters

  • translation-o valor para converter a mão simulada.translation - The amount to translate the simulated hand.

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

Execute um gesto usando a mão simulada.Perform a gesture using the simulated hand. Ele só será detectado pelo sistema se a mão estiver habilitada.It will only be detected by the system if the hand is enabled.

ParâmetrosParameters

  • gesto-o gesto a ser executado.gesture - The gesture to perform.

Microsoft. PerceptionSimulation. ISimulatedHand2Microsoft.PerceptionSimulation.ISimulatedHand2

Propriedades adicionais estão disponíveis por meio da conversão de um ISimulatedHand em ISimulatedHand2.Additional properties are available by casting an ISimulatedHand to ISimulatedHand2.

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

Microsoft. PerceptionSimulation. ISimulatedHand2. OrientationMicrosoft.PerceptionSimulation.ISimulatedHand2.Orientation

Recupere ou defina a rotação da mão simulada.Retrieve or set the rotation of the simulated hand. Radianos positivos giram no sentido horário ao olhar ao longo do eixo.Positive radians rotate clockwise when looking along the axis.

Microsoft. PerceptionSimulation. ISimulatedHand3Microsoft.PerceptionSimulation.ISimulatedHand3

Propriedades adicionais estão disponíveis por meio da conversão de um ISimulatedHand para ISimulatedHand3Additional properties are available by casting an ISimulatedHand to ISimulatedHand3

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

Microsoft. PerceptionSimulation. ISimulatedHand3. GetJointConfigurationMicrosoft.PerceptionSimulation.ISimulatedHand3.GetJointConfiguration

Obter a configuração conjunta para a junção especificada.Get the joint configuration for the specified joint.

Microsoft. PerceptionSimulation. ISimulatedHand3. SetJointConfigurationMicrosoft.PerceptionSimulation.ISimulatedHand3.SetJointConfiguration

Defina a configuração conjunta para a junção especificada.Set the joint configuration for the specified joint.

Microsoft. PerceptionSimulation. ISimulatedHand3. SetHandPoseMicrosoft.PerceptionSimulation.ISimulatedHand3.SetHandPose

Defina a mão como uma pose conhecida com um sinalizador opcional para animar.Set the hand to a known pose with an optional flag to animate. Observação: a animação não resultará em junções imediatamente refletindo suas configurações de conjuntos finais.Note: animating won't result in joints immediately reflecting their final joint configurations.

Microsoft. PerceptionSimulation. ISimulatedHeadMicrosoft.PerceptionSimulation.ISimulatedHead

Interface que descreve o cabeçalho do humano simulado.Interface describing the head of the simulated human.

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

Microsoft. PerceptionSimulation. ISimulatedHead. WorldPositionMicrosoft.PerceptionSimulation.ISimulatedHead.WorldPosition

Recupere a posição do nó com relação ao mundo, em metros.Retrieve the position of the node with relation to the world, in meters.

Microsoft. PerceptionSimulation. ISimulatedHead. RotationMicrosoft.PerceptionSimulation.ISimulatedHead.Rotation

Recupere a rotação da cabeça simulada.Retrieve the rotation of the simulated head. Radianos positivos giram no sentido horário ao olhar ao longo do eixo.Positive radians rotate clockwise when looking along the axis.

Microsoft. PerceptionSimulation. ISimulatedHead. diâmetroMicrosoft.PerceptionSimulation.ISimulatedHead.Diameter

Recupere o diâmetro da cabeça simulada.Retrieve the simulated head's diameter. Esse valor é usado para determinar o centro da cabeça (ponto de rotação).This value is used to determine the head's center (point of rotation).

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

Girar a cabeça simulada em relação à sua rotação atual.Rotate the simulated head relative to its current rotation. Radianos positivos giram no sentido horário ao olhar ao longo do eixo.Positive radians rotate clockwise when looking along the axis.

ParâmetrosParameters

  • rotação-o valor a ser girado.rotation - The amount to rotate.

Microsoft. PerceptionSimulation. ISimulatedHead2Microsoft.PerceptionSimulation.ISimulatedHead2

Propriedades adicionais estão disponíveis por meio da conversão de um ISimulatedHead para ISimulatedHead2Additional properties are available by casting an ISimulatedHead to ISimulatedHead2

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

Microsoft. PerceptionSimulation. ISimulatedHead2. eyessMicrosoft.PerceptionSimulation.ISimulatedHead2.Eyes

Recupere os olhos do humano simulado.Retrieve the eyes of the simulated human.

Microsoft. PerceptionSimulation. ISimulatedSixDofControllerMicrosoft.PerceptionSimulation.ISimulatedSixDofController

Interface que descreve um controlador de 6 DOF associado ao humano simulado.Interface describing a 6-DOF controller associated with the simulated human.

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. WorldPositionMicrosoft.PerceptionSimulation.ISimulatedSixDofController.WorldPosition

Recupere a posição do nó com relação ao mundo, em metros.Retrieve the position of the node with relation to the world, in meters.

Microsoft. PerceptionSimulation. ISimulatedSixDofController. statusMicrosoft.PerceptionSimulation.ISimulatedSixDofController.Status

Recupere ou defina o estado atual do controlador.Retrieve or set the current state of the controller. O status do controlador deve ser definido com um valor diferente de desativado antes que as chamadas para mover, girar ou pressionar botões tenham sucesso.The controller status must be set to a value other than Off before any calls to move, rotate, or press buttons will succeed.

Microsoft. PerceptionSimulation. ISimulatedSixDofController. PositionMicrosoft.PerceptionSimulation.ISimulatedSixDofController.Position

Recupere ou defina a posição do controlador simulado em relação ao humano, em metros.Retrieve or set the position of the simulated controller relative to the human, in meters.

Microsoft. PerceptionSimulation. ISimulatedSixDofController. OrientationMicrosoft.PerceptionSimulation.ISimulatedSixDofController.Orientation

Recupere ou defina a orientação do controlador simulado.Retrieve or set the orientation of the simulated controller.

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

Mova a posição do controlador simulado em relação à sua posição atual, em metros.Move the position of the simulated controller relative to its current position, in meters.

ParâmetrosParameters

  • translation-o valor para converter o controlador simulado.translation - The amount to translate the simulated controller.

Microsoft. PerceptionSimulation. ISimulatedSixDofController. PressButton (SimulatedSixDofControllerButton)Microsoft.PerceptionSimulation.ISimulatedSixDofController.PressButton(SimulatedSixDofControllerButton)

Pressione um botão no controlador simulado.Press a button on the simulated controller. Ele só será detectado pelo sistema se o controlador estiver habilitado.It will only be detected by the system if the controller is enabled.

ParâmetrosParameters

  • botão-o botão para pressionar.button - The button to press.

Microsoft. PerceptionSimulation. ISimulatedSixDofController. ReleaseButton (SimulatedSixDofControllerButton)Microsoft.PerceptionSimulation.ISimulatedSixDofController.ReleaseButton(SimulatedSixDofControllerButton)

Libere um botão no controlador simulado.Release a button on the simulated controller. Ele só será detectado pelo sistema se o controlador estiver habilitado.It will only be detected by the system if the controller is enabled.

ParâmetrosParameters

  • botão-o botão a ser liberado.button - The button to release.

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

Obtenha a posição de um dedo simulado no Touchpad do controlador simulado.Get the position of a simulated finger on the simulated controller's touchpad.

ParâmetrosParameters

  • x-a posição horizontal do dedo.x - The horizontal position of the finger.
  • y-a posição vertical do dedo.y - The vertical position of the finger.

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

Defina a posição de um dedo simulado no Touchpad do controlador simulado.Set the position of a simulated finger on the simulated controller's touchpad.

ParâmetrosParameters

  • x-a posição horizontal do dedo.x - The horizontal position of the finger.
  • y-a posição vertical do dedo.y - The vertical position of the finger.

Microsoft. PerceptionSimulation. ISimulatedSixDofController2Microsoft.PerceptionSimulation.ISimulatedSixDofController2

Propriedades e métodos adicionais estão disponíveis por meio da conversão de um ISimulatedSixDofController para ISimulatedSixDofController2Additional properties and methods are available by casting an ISimulatedSixDofController to ISimulatedSixDofController2

public interface ISimulatedSixDofController2
{
    /* New members in addition to those available on ISimulatedSixDofController */
    void GetThumbstickPosition(out float x, out float y);
    void SetThumbstickPosition(float x, float y);
    float BatteryLevel { get; set; }
}

Microsoft. PerceptionSimulation. ISimulatedSixDofController2. GetThumbstickPosition (out float, out float)Microsoft.PerceptionSimulation.ISimulatedSixDofController2.GetThumbstickPosition(out float, out float)

Obtém a posição do Thumbstick simulado no controlador simulado.Get the position of the simulated thumbstick on the simulated controller.

ParâmetrosParameters

  • x-a posição horizontal do Thumbstick.x - The horizontal position of the thumbstick.
  • y-a posição vertical do Thumbstick.y - The vertical position of the thumbstick.

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

Defina a posição do Thumbstick simulado no controlador simulado.Set the position of the simulated thumbstick on the simulated controller.

ParâmetrosParameters

  • x-a posição horizontal do Thumbstick.x - The horizontal position of the thumbstick.
  • y-a posição vertical do Thumbstick.y - The vertical position of the thumbstick.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2.BatteryLevelMicrosoft.PerceptionSimulation.ISimulatedSixDofController2.BatteryLevel

Recupere ou defina o nível de bateria do controlador simulado.Retrieve or set the battery level of the simulated controller. O valor deve ser maior que 0,0 e menor ou igual a 100,0.The value must be greater than 0.0 and less than or equal to 100.0.

Microsoft. PerceptionSimulation. ISimulatedEyesMicrosoft.PerceptionSimulation.ISimulatedEyes

Interface que descreve os olhos do humano simulado.Interface describing the eyes of the simulated human.

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

Microsoft. PerceptionSimulation. ISimulatedEyes. RotationMicrosoft.PerceptionSimulation.ISimulatedEyes.Rotation

Recupere a rotação dos olhos simulados.Retrieve the rotation of the simulated eyes. Radianos positivos giram no sentido horário ao olhar ao longo do eixo.Positive radians rotate clockwise when looking along the axis.

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

Gire os olhos simulados em relação à sua rotação atual.Rotate the simulated eyes relative to its current rotation. Radianos positivos giram no sentido horário ao olhar ao longo do eixo.Positive radians rotate clockwise when looking along the axis.

ParâmetrosParameters

  • rotação-o valor a ser girado.rotation - The amount to rotate.

Microsoft. PerceptionSimulation. ISimulatedEyes. calibrableMicrosoft.PerceptionSimulation.ISimulatedEyes.CalibrationState

Recupera ou define o estado de calibragem dos olhos simulados.Retrieves or sets the calibration state of the simulated eyes.

Microsoft. PerceptionSimulation. ISimulatedEyes. WorldPositionMicrosoft.PerceptionSimulation.ISimulatedEyes.WorldPosition

Recupere a posição do nó com relação ao mundo, em metros.Retrieve the position of the node with relation to the world, in meters.

Microsoft. PerceptionSimulation. ISimulationRecordingMicrosoft.PerceptionSimulation.ISimulationRecording

Interface para interagir com uma única gravação carregada para reprodução.Interface for interacting with a single recording loaded for playback.

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

Microsoft. PerceptionSimulation. ISimulationRecording. datatiposMicrosoft.PerceptionSimulation.ISimulationRecording.DataTypes

Recupera a lista de tipos de dados na gravação.Retrieves the list of data types in the recording.

Microsoft. PerceptionSimulation. ISimulationRecording. StateMicrosoft.PerceptionSimulation.ISimulationRecording.State

Recupera o estado atual da gravação.Retrieves the current state of the recording.

Microsoft. PerceptionSimulation. ISimulationRecording. PlayMicrosoft.PerceptionSimulation.ISimulationRecording.Play

Inicie a reprodução.Start the playback. Se a gravação for pausada, a reprodução será retomada do local em pausa; Se for interrompido, a reprodução será iniciada no início.If the recording is paused, playback will resume from the paused location; if stopped, playback will start at the beginning. Se já estiver em execução, essa chamada será ignorada.If already playing, this call is ignored.

Microsoft. PerceptionSimulation. ISimulationRecording. PauseMicrosoft.PerceptionSimulation.ISimulationRecording.Pause

Pausa a reprodução em seu local atual.Pauses the playback at its current location. Se a gravação for interrompida, a chamada será ignorada.If the recording is stopped, the call is ignored.

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

Procura a gravação no tempo especificado (em intervalos de 100 a nanossegundos desde o início) e pausa nesse local.Seeks the recording to the specified time (in 100-nanoseconds intervals from the beginning) and pauses at that location. Se o tempo estiver além do fim da gravação, ele será pausado no último quadro.If the time is beyond the end of the recording, it's paused at the last frame.

ParâmetrosParameters

  • tiques-o tempo para o qual buscar.ticks - The time to which to seek.

Microsoft. PerceptionSimulation. ISimulationRecording. StopMicrosoft.PerceptionSimulation.ISimulationRecording.Stop

Interrompe a reprodução e redefine a posição para o início.Stops the playback and resets the position to the beginning.

Microsoft. PerceptionSimulation. ISimulationRecordingCallbackMicrosoft.PerceptionSimulation.ISimulationRecordingCallback

Interface para receber alterações de estado durante a reprodução.Interface for receiving state changes during playback.

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

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

Chamado quando o estado de reprodução de um ISimulationRecording é alterado.Called when an ISimulationRecording's playback state has changed.

ParâmetrosParameters

  • newState – o novo estado da gravação.newState - The new state of the recording.

Microsoft. PerceptionSimulation. PerceptionSimulationManagerMicrosoft.PerceptionSimulation.PerceptionSimulationManager

Objeto raiz para criar objetos de simulação de percepção.Root object for creating Perception Simulation objects.

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)Microsoft.PerceptionSimulation.PerceptionSimulationManager.CreatePerceptionSimulationManager(Microsoft.PerceptionSimulation.ISimulationStreamSink)

Crie um objeto para gerar pacotes simulados e fornecê-los ao coletor fornecido.Create on object for generating simulated packets and delivering them to the provided sink.

ParâmetrosParameters

  • coletor-o coletor que receberá todos os pacotes gerados.sink - The sink that will receive all generated packets.

Valor retornadoReturn value

O gerente criado.The created Manager.

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

Crie um coletor, que armazena todos os pacotes recebidos em um arquivo no caminho especificado.Create a sink, which stores all received packets in a file at the specified path.

ParâmetrosParameters

  • caminho-o caminho do arquivo a ser criado.path - The path of the file to create.

Valor retornadoReturn value

O coletor criado.The created sink.

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

Carregar uma gravação do arquivo especificado.Load a recording from the specified file.

ParâmetrosParameters

  • caminho-o caminho do arquivo a ser carregado.path - The path of the file to load.
  • Factory-uma fábrica usada pela gravação para criar um ISimulationStreamSink quando necessário.factory - A factory used by the recording for creating an ISimulationStreamSink when required.

Valor retornadoReturn value

A gravação carregada.The loaded recording.

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

Carregar uma gravação do arquivo especificado.Load a recording from the specified file.

ParâmetrosParameters

  • caminho-o caminho do arquivo a ser carregado.path - The path of the file to load.
  • Factory-uma fábrica usada pela gravação para criar um ISimulationStreamSink quando necessário.factory - A factory used by the recording for creating an ISimulationStreamSink when required.
  • retorno de chamada-um retorno de chamada, que recebe atualizações que retratam o status da gravação.callback - A callback, which receives updates regrading the recording's status.

Valor retornadoReturn value

A gravação carregada.The loaded recording.

Microsoft. PerceptionSimulation. StreamDataTypesMicrosoft.PerceptionSimulation.StreamDataTypes

Descreve os diferentes tipos de dados de fluxo.Describes the different types of stream data.

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. NoneMicrosoft.PerceptionSimulation.StreamDataTypes.None

Um valor de sentinela usado para indicar nenhum tipo de dados de fluxo.A sentinel value used to indicate no stream data types.

Microsoft. PerceptionSimulation. StreamDataTypes. HeadMicrosoft.PerceptionSimulation.StreamDataTypes.Head

Fluxo de dados para a posição e a orientação do cabeçalho.Stream of data for the position and orientation of the head.

Microsoft. PerceptionSimulation. StreamDataTypes. handsMicrosoft.PerceptionSimulation.StreamDataTypes.Hands

Fluxo de dados para a posição e gestos de mãos.Stream of data for the position and gestures of hands.

Microsoft. PerceptionSimulation. StreamDataTypes. SpatialMappingMicrosoft.PerceptionSimulation.StreamDataTypes.SpatialMapping

Fluxo de dados para o mapeamento espacial do ambiente.Stream of data for spatial mapping of the environment.

Microsoft. PerceptionSimulation. StreamDataTypes. CalibrationMicrosoft.PerceptionSimulation.StreamDataTypes.Calibration

Fluxo de dados para a calibragem do dispositivo.Stream of data for calibration of the device. Os pacotes de calibragem são aceitos apenas por um sistema no modo remoto.Calibration packets are only accepted by a system in Remote Mode.

Microsoft. PerceptionSimulation. StreamDataTypes. EnvironmentMicrosoft.PerceptionSimulation.StreamDataTypes.Environment

Fluxo de dados para o ambiente do dispositivo.Stream of data for the environment of the device.

Microsoft. PerceptionSimulation. StreamDataTypes. SixDofControllersMicrosoft.PerceptionSimulation.StreamDataTypes.SixDofControllers

Fluxo de dados para controladores de movimento.Stream of data for motion controllers.

Microsoft. PerceptionSimulation. StreamDataTypes. eyessMicrosoft.PerceptionSimulation.StreamDataTypes.Eyes

Fluxo de dados com os olhos do humano simulado.Stream of data with the eyes of the simulated human.

Microsoft. PerceptionSimulation. StreamDataTypes. DisplayConfigurationMicrosoft.PerceptionSimulation.StreamDataTypes.DisplayConfiguration

Fluxo de dados com a configuração de exibição do dispositivo.Stream of data with the display configuration of the device.

Microsoft. PerceptionSimulation. StreamDataTypes. AllMicrosoft.PerceptionSimulation.StreamDataTypes.All

Um valor de sentinela usado para indicar todos os tipos de dados gravados.A sentinel value used to indicate all recorded data types.

Microsoft. PerceptionSimulation. ISimulationStreamSinkMicrosoft.PerceptionSimulation.ISimulationStreamSink

Um objeto que recebe pacotes de dados de um fluxo de simulação.An object that receives data packets from a simulation stream.

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

Microsoft. PerceptionSimulation. ISimulationStreamSink. OnPacketReceived (pacote de comprimento uint, Byte [])Microsoft.PerceptionSimulation.ISimulationStreamSink.OnPacketReceived(uint length, byte[] packet)

Recebe um único pacote, que é digitado internamente e com controle de versão.Receives a single packet, which is internally typed and versioned.

ParâmetrosParameters

  • comprimento-o comprimento do pacote.length - The length of the packet.
  • pacote-os dados do pacote.packet - The data of the packet.

Microsoft. PerceptionSimulation. ISimulationStreamSinkFactoryMicrosoft.PerceptionSimulation.ISimulationStreamSinkFactory

Um objeto que cria ISimulationStreamSink.An object that creates ISimulationStreamSink.

public interface ISimulationStreamSinkFactory
{
    ISimulationStreamSink CreateSimulationStreamSink();
}

Microsoft. PerceptionSimulation. ISimulationStreamSinkFactory. CreateSimulationStreamSink ()Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory.CreateSimulationStreamSink()

Cria uma única instância de ISimulationStreamSink.Creates a single instance of ISimulationStreamSink.

Valor retornadoReturn value

O coletor criado.The created sink.