Acompanhamento da mão no Unreal

O sistema de acompanhamento de mão usa as mãos e os dedos de uma pessoa como entrada. Os dados sobre a posição e a rotação de cada dedo, a palma inteira e os gestos da mão estão disponíveis. A partir do Unreal 4.26, o acompanhamento manual é baseado no plug-in Unreal HeadMountedDisplay e usa uma API comum em todas as plataformas e dispositivos XR. A funcionalidade é a mesma para sistemas Windows Mixed Reality e OpenXR.

Pose de mão

A pose manual permite rastrear e usar as mãos e os dedos de seus usuários como entrada, que podem ser acessados em Blueprints e C++. A API do Unreal envia os dados como um sistema de coordenadas, com tiques sincronizados com o Unreal Engine.

4.26

A hierarquia é descrita por EHandKeypoint enumeração:

Você pode obter todos esses dados das mãos de um usuário usando a função Obter Dados do Controlador de Movimento . Essa função retorna uma estrutura XRMotionControllerData . Veja abaixo um exemplo de script blueprint que analisa a estrutura XRMotionControllerData para obter locais de articulação manual e desenha um sistema de coordenadas de depuração no local de cada articulação.

É importante marcar se a estrutura é válida e que é uma mão. Caso contrário, você poderá obter um comportamento indefinido no acesso a posições, rotações e matrizes de raios.

4.25

A EWMRHandKeypoint enumeração descreve a hierarquia óssea da Mão. Você pode encontrar cada ponto de chave manual listado em seus Blueprints:

A enumeração completa do C++ está listada abaixo:

enum class EWMRHandKeypoint : uint8
{
	Palm,
	Wrist,
	ThumbMetacarpal,
	ThumbProximal,
	ThumbDistal,
	ThumbTip,
	IndexMetacarpal,
	IndexProximal,
	IndexIntermediate,
	IndexDistal,
	IndexTip,
	MiddleMetacarpal,
	MiddleProximal,
	MiddleIntermediate,
	MiddleDistal,
	MiddleTip,
	RingMetacarpal,
	RingProximal,
	RingIntermediate,
	RingDistal,
	RingTip,
	LittleMetacarpal,
	LittleProximal,
	LittleIntermediate,
	LittleDistal,
	LittleTip
};

Você pode encontrar os valores numéricos para cada caso de enumeração no Windows.Perception.Pessoas. Tabela HandJointKind.

Suporte ao acompanhamento manual

Você pode usar o acompanhamento manual em Blueprints adicionando Suporte ao Controle manual do controle > manual Windows Mixed Reality:

Essa função retornará true se houver suporte para rastreamento manual no dispositivo e false se o acompanhamento manual não estiver disponível.

C++:

Inclua WindowsMixedRealityHandTrackingFunctionLibrary.h.

static bool UWindowsMixedRealityHandTrackingFunctionLibrary::SupportsHandTracking()

Obtendo acompanhamento manual

Você pode usar GetHandJointTransform para retornar dados espaciais da mão. Os dados atualizam todos os quadros, mas se você estiver dentro de um quadro, os valores retornados serão armazenados em cache. Não é recomendável ter uma lógica pesada nessa função por motivos de desempenho.

C++:

static bool UWindowsMixedRealityHandTrackingFunctionLibrary::GetHandJointTransform(EControllerHand Hand, EWMRHandKeypoint Keypoint, FTransform& OutTransform, float& OutRadius)

Aqui está um detalhamento dos parâmetros de função de GetHandJointTransform:

• Mão – pode ser os usuários à esquerda ou à direita.
• Ponto de chave – o osso da mão.
• Transformação – coordenadas e orientação da base do osso. Você pode solicitar a base do próximo osso para obter os dados de transformação para o final de um osso. Um osso de ponta especial dá fim ao distal.
• **Radius— raio da base do osso.
• **Valor retornado — true se o osso for rastreado por esse quadro, false se o osso não for rastreado.

Animação do Hand Live Link

As poses das mãos são expostas à Animação usando o plug-in link dinâmico.

Se os plug-ins Windows Mixed Reality e Link Dinâmico estiverem habilitados:

1. Selecione Janela > Ao Vivo Link para abrir a janela do editor do Link Ao Vivo.
2. Selecione Origem e habilite Windows Mixed Reality Fonte de Acompanhamento Manual

Depois de habilitar o código-fonte e abrir um ativo de animação, expanda a seção Animação na guia Cena de Visualização também veja opções adicionais.

A hierarquia de animação de mão é a mesma de em EWMRHandKeypoint. A animação pode ser redirecionada usando WindowsMixedRealityHandTrackingLiveLinkRemapAsset:

Ele também pode ser subclasse no editor:

Malha de Mão

Importante

A malha manual requer OpenXR.

O plug-in Microsoft OpenXR precisa ser usado. Ele está disponível no Unreal Marketplace ou no GitHub.

Malha manual como geometria rastreada

Importante

Obter malhas muárias como uma geometria controlada no OpenXR exige que você chame Definir Usar Malha Manual com Geometria de Acompanhamento Habilitada.

Para habilitar esse modo, você deve chamar Definir Usar Malha Manual com Geometria de Acompanhamento Habilitada:

Observação

Não é possível que ambos os modos sejam habilitados ao mesmo tempo. Se você habilitar um, o outro será desabilitado automaticamente.

Acessando dados de malha manual

Antes de acessar dados de malha manual, você precisará:

• Selecione o ativo ARSessionConfig, expanda as configurações de AR –> Mapeamento Mundial e marcar Gerar Dados de Malha da Geometria Rastreada.

Abaixo estão os parâmetros de malha padrão:

1. Usar dados de malha para oclusão
2. Gerar colisão para dados de malha
3. Gerar malha de navegação para dados de malha
4. Renderizar dados de malha no Wireframe – parâmetro de depuração que mostra a malha gerada

Esses valores de parâmetro são usados como padrões de malha de mapeamento espacial e malha manual. Você pode alterá-los a qualquer momento em Blueprints ou código para qualquer malha.

Referência de API do C++

Use EEARObjectClassification para encontrar valores de malha manual em todos os objetos rastreáveis.

enum class EARObjectClassification : uint8
{
    // Other types
	HandMesh,
};

Os delegados a seguir são chamados quando o sistema detecta qualquer objeto rastreável, incluindo uma malha manual.

class FARSupportInterface
{
    public:
    // Other params
	DECLARE_AR_SI_DELEGATE_FUNCS(OnTrackableAdded)
	DECLARE_AR_SI_DELEGATE_FUNCS(OnTrackableUpdated)
	DECLARE_AR_SI_DELEGATE_FUNCS(OnTrackableRemoved)
};

Verifique se os manipuladores delegados seguem a assinatura da função abaixo:

void UARHandMeshComponent::OnTrackableAdded(UARTrackedGeometry* Added)

Você pode acessar dados de malha por meio do UARTrackedGeometry::GetUnderlyingMesh:

UMRMeshComponent* UARTrackedGeometry::GetUnderlyingMesh()

Referência da API do Blueprint

Para trabalhar com malhas muárias em blueprints:

1. Adicionar um componente ARTrackableNotify a um ator de blueprint

2. Vá para o painel Detalhes e expanda a seção Eventos .

3. Substitua Em Adicionar/Atualizar/Remover Geometria Rastreada com os seguintes nós no Grafo de Eventos:

Visualização de malha manual no OpenXR

A maneira recomendada de visualizar a malha manual é usar o plug-in XRVisualization da Epic junto com o plug-in Microsoft OpenXR.

Em seguida, no editor de blueprint, você deve usar a função Definir Usar Malha Manual do plug-in do Microsoft OpenXR com o XRVisualization Habilitado como um parâmetro:

Para gerenciar o processo de renderização, você deve usar Renderizar o Controlador de Movimento do XRVisualization:

O resultado :

Se você precisar de algo mais complicado, como desenhar uma malha de mão com um sombreador personalizado, precisará obter as malhas como uma geometria rastreada.

Raios de mão

Obter pose de mão funciona para interações próximas, como agarrar objetos ou pressionar botões. No entanto, às vezes, você precisa trabalhar com hologramas que estão longe de seus usuários. Isso pode ser feito com raios manuais, que podem ser usados como dispositivos de apontamento em C++ e Blueprints. Você pode desenhar um raio da mão para um ponto distante e, com alguma ajuda do rastreamento de raios unreal, selecionar um holograma que, de outra forma, estaria fora de alcance.

Importante

Como todos os resultados da função mudam cada quadro, todos eles são chamados. Para obter mais informações sobre funções puras, impuras ou chamáveis, consulte o guid do usuário blueprint em funções.

4.26

Para obter os dados dos raios de mão, você deve usar a função Obter Dados do Controlador de Movimento da seção anterior. A estrutura retornada contém dois parâmetros que você pode usar para criar um raio de mão – Posição de Mira e Rotação de Objetivo. Esses parâmetros formam um raio direcionado pelo cotovelo. Você deve levá-los e encontrar um holograma sendo apontado por.

Veja abaixo um exemplo de como determinar se um raio de mão atinge um Widget e definir um resultado de ocorrência personalizado:

4.25

Para usar os Raios de Mão em Blueprints, pesquise qualquer uma das ações em Windows Mixed Reality HMD:

Para acessá-los no C++, inclua WindowsMixedRealityFunctionLibrary.h na parte superior do arquivo de código de chamada.

Enumeração

Você também tem acesso a casos de entrada em EHMDInputControllerButtons, que podem ser usados em Blueprints:

Para acesso no C++, use a EHMDInputControllerButtons classe de enumeração :

enum class EHMDInputControllerButtons : uint8
{
	Select,
	Grasp,
//......
};

Veja abaixo um detalhamento dos dois casos de enumeração aplicáveis:

• Selecione – Usuário acionado Selecionar evento.
  • Disparada em HoloLens 2 por toque no ar, foco e confirmação ou dizendo "Selecionar" com a entrada de voz habilitada.
• Agarramento – evento Grasp disparado pelo usuário.
  • Disparada em HoloLens 2 fechando os dedos do usuário em um holograma.

Você pode acessar o status de acompanhamento da malha de mão em C++ por meio da EHMDTrackingStatus enumeração mostrada abaixo:

enum class EHMDTrackingStatus : uint8
{
	NotTracked,
	//......
	Tracked
};

Veja abaixo um detalhamento dos dois casos de enumeração aplicáveis:

• NotTracked –- a mão não está visível
• Rastreada – a mão é totalmente controlada

Estrutura

O struct PointerPoseInfo pode fornecer informações sobre os seguintes dados de mão:

• Origem – origem da mão
• Direção – direção da mão
• Para cima – vetor superior da mão
• Orientação – quatérnio de orientação
• Status de acompanhamento – status de acompanhamento atual

Você pode acessar o struct PointerPoseInfo por meio de Blueprints, conforme mostrado abaixo:

Ou com C++:

struct FPointerPoseInfo
{
	FVector Origin;
	FVector Direction;
	FVector Up;
	FQuat Orientation;
	EHMDTrackingStatus TrackingStatus;
};

Funções

Todas as funções listadas abaixo podem ser chamadas em cada quadro, o que permite o monitoramento contínuo.

1. Obter informações de pose de ponteiro retorna informações completas sobre a direção do raio da mão no quadro atual.

Modelo:

C++:

static FPointerPoseInfo UWindowsMixedRealityFunctionLibrary::GetPointerPoseInfo(EControllerHand hand);

2. É Agarrada retorna true se a mão é agarrada no quadro atual.

Modelo:

C++:

static bool UWindowsMixedRealityFunctionLibrary::IsGrasped(EControllerHand hand);

3. Selecionar Pressionado retornará true se o usuário acionado Selecionar no quadro atual.

Modelo:

C++:

static bool UWindowsMixedRealityFunctionLibrary::IsSelectPressed(EControllerHand hand);

4. Is Button Clicked retornará true se o evento ou o botão for disparado no quadro atual.

Modelo:

C++:

static bool UWindowsMixedRealityFunctionLibrary::IsButtonClicked(EControllerHand hand, EHMDInputControllerButtons button);

5. Obter Status de Acompanhamento do Controlador retorna a status de acompanhamento no quadro atual.

Modelo:

C++:

static EHMDTrackingStatus UWindowsMixedRealityFunctionLibrary::GetControllerTrackingStatus(EControllerHand hand);

Gestos

O HoloLens 2 rastreia gestos espaciais, o que significa que você pode capturar esses gestos como entrada. O acompanhamento de gestos é baseado em um modelo de assinatura. Você deve usar a função "Configurar Gestos" para informar ao dispositivo quais gestos você deseja rastrear. Você pode encontrar mais detalhes sobre gestos no documento HoloLens 2 Uso Básico.

4.26

Windows Mixed Reality

Em seguida, você deve adicionar código para assinar os seguintes eventos:

OpenXR

No OpenXR, os eventos de gesto são rastreados por meio do pipeline de entrada. Usando a interação manual, o dispositivo pode reconhecer automaticamente os gestos Tocar e Segurar, mas não os outros. Eles são nomeados como mapeamentos OpenXRMsftHandInteraction Select e Grip. Você não precisa habilitar a assinatura, deve declarar os eventos em Configurações do Projeto/Mecanismo/Entrada, da seguinte maneira:

4.25

Você pode encontrar a função Blueprint em em Windows Mixed Reality Entrada Espacial e a função C++ adicionando WindowsMixedRealitySpatialInputFunctionLibrary.h no arquivo de código de chamada.

Enumeração

Modelo:

C++:

enum class ESpatialInputAxisGestureType : uint8
{
	None = 0,
	Manipulation = 1,
	Navigation = 2,
	NavigationRails = 3
};

Função

Você pode habilitar e desabilitar a captura de gestos com a CaptureGestures função . Quando um gesto habilitado dispara eventos de entrada, a função retorna true se a captura de gestos foi bem-sucedida e false , se houver um erro.

Modelo:

C++:

static bool UWindowsMixedRealitySpatialInputFunctionLibrary::CaptureGestures(
	bool Tap = false,
	bool Hold = false,
	ESpatialInputAxisGestureType AxisGesture = ESpatialInputAxisGestureType::None,
	bool NavigationAxisX = true,
	bool NavigationAxisY = true,
	bool NavigationAxisZ = true);

Veja a seguir os principais eventos, que você pode encontrar em Blueprints e C++:

const FKey FSpatialInputKeys::TapGesture(TapGestureName);
const FKey FSpatialInputKeys::DoubleTapGesture(DoubleTapGestureName);
const FKey FSpatialInputKeys::HoldGesture(HoldGestureName);

const FKey FSpatialInputKeys::LeftTapGesture(LeftTapGestureName);
const FKey FSpatialInputKeys::LeftDoubleTapGesture(LeftDoubleTapGestureName);
const FKey FSpatialInputKeys::LeftHoldGesture(LeftHoldGestureName);

const FKey FSpatialInputKeys::RightTapGesture(RightTapGestureName);
const FKey FSpatialInputKeys::RightDoubleTapGesture(RightDoubleTapGestureName);
const FKey FSpatialInputKeys::RightHoldGesture(RightHoldGestureName);

const FKey FSpatialInputKeys::LeftManipulationGesture(LeftManipulationGestureName);
const FKey FSpatialInputKeys::LeftManipulationXGesture(LeftManipulationXGestureName);
const FKey FSpatialInputKeys::LeftManipulationYGesture(LeftManipulationYGestureName);
const FKey FSpatialInputKeys::LeftManipulationZGesture(LeftManipulationZGestureName);

const FKey FSpatialInputKeys::LeftNavigationGesture(LeftNavigationGestureName);
const FKey FSpatialInputKeys::LeftNavigationXGesture(LeftNavigationXGestureName);
const FKey FSpatialInputKeys::LeftNavigationYGesture(LeftNavigationYGestureName);
const FKey FSpatialInputKeys::LeftNavigationZGesture(LeftNavigationZGestureName);


const FKey FSpatialInputKeys::RightManipulationGesture(RightManipulationGestureName);
const FKey FSpatialInputKeys::RightManipulationXGesture(RightManipulationXGestureName);
const FKey FSpatialInputKeys::RightManipulationYGesture(RightManipulationYGestureName);
const FKey FSpatialInputKeys::RightManipulationZGesture(RightManipulationZGestureName);

const FKey FSpatialInputKeys::RightNavigationGesture(RightNavigationGestureName);
const FKey FSpatialInputKeys::RightNavigationXGesture(RightNavigationXGestureName);
const FKey FSpatialInputKeys::RightNavigationYGesture(RightNavigationYGestureName);
const FKey FSpatialInputKeys::RightNavigationZGesture(RightNavigationZGestureName);

Próximo ponto de verificação de desenvolvimento

Se está seguindo o percurso de desenvolvimento do Unreal que estabelecemos, você está no meio da exploração dos principais blocos de construção do MRTK. Deste ponto, você pode prosseguir para o próximo bloco de construção:

Âncoras Espaciais locais

Ou vá diretamente para as funcionalidades e APIs da plataforma de Realidade Misturada:

Câmera do HoloLens

Você sempre pode voltar para os pontos de verificação de desenvolvimento do Unreal a qualquer momento.