Rastreamento de mãos em Unreal

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

Pose de mão

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

4.26

A hierarquia é descrita por EHandKeypoint enum:

Você pode obter todos esses dados das mãos de um usuário usando a função Get Motion Controller Data . Essa função retorna uma estrutura XRMotionControllerData . Abaixo está um exemplo de script Blueprint que analisa a estrutura XRMotionControllerData para obter localizações de juntas manuais e desenha um sistema de coordenadas de depuração no local de cada junta.

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

4.25

O EWMRHandKeypoint enum descreve a hierarquia óssea da Mão. Você pode encontrar cada ponto chave de mão listado em seus Planos:

O enum C++ completo está listado 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 enum na tabela Windows.Perception.People.HandJointKind .

Suporte ao rastreamento de mãos

Você pode usar o rastreamento de mãos em Blueprints adicionando Suporta rastreamento de mãos do Windows Mixed Reality de rastreamento > de mãos:

Esta função retorna true se o rastreamento de mãos for suportado no dispositivo e false se o rastreamento de mãos não estiver disponível.

C++:

Incluir WindowsMixedRealityHandTrackingFunctionLibrary.h.

static bool UWindowsMixedRealityHandTrackingFunctionLibrary::SupportsHandTracking()

Obter rastreamento de mãos

Você pode usar GetHandJointTransform para retornar dados espaciais da mão. Os dados atualizam cada quadro, mas se você estiver dentro de um quadro, os valores retornados serão armazenados em cache. Não é recomendado ter lógica pesada nesta função por razões 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 a mão esquerda ou direita dos utilizadores.
• Keypoint – o osso da mão.
• Transformar – 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 de distal.
• **Rádio—raio da base do osso.
• **Valor de retorno—true se o osso for rastreado neste quadro, false se o osso não for rastreado.

Animação Hand Live Link

As poses das mãos são expostas à animação usando o plug-in Live Link.

Se os plug-ins do Windows Mixed Reality e do Live Link estiverem ativados:

1. Selecione Window > Live Link para abrir a janela do editor Live Link.
2. Selecione Origem e ative a Origem de Rastreamento de Mãos do Windows Mixed Reality

Depois de habilitar a origem e abrir um ativo de animação, expanda a seção Animação na guia Visualizar cena e veja opções adicionais.

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

Também pode ser subclassificado no editor:

Malha de Mão

Importante

A malha manual requer OpenXR.

O plug-in Microsoft OpenXR deve ser usado, disponível no Unreal Marketplace ou GitHub.

Malha manual como geometria rastreada

Importante

Obter malhas manuais como uma geometria rastreada no OpenXR requer que você chame set Use Hand Mesh with Enabled Tracking Geometry.

Para ativar esse modo, você deve chamar set Use Hand Mesh with Enabled Tracking Geometry:

Nota

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

Acessando dados de malha manual

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

• Selecione seu ativo ARSessionConfig , expanda as configurações de AR -> World Mapping e marque Gerar dados de malha a partir de 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. Render Mesh Data in Wireframe – parâmetro de depuração que mostra a malha gerada

Esses valores de parâmetro são usados como os 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 da API C++

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

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

Os seguintes delegados são chamados quando o sistema deteta 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)
};

Certifique-se de que seus manipuladores delegados sigam a assinatura de função abaixo:

void UARHandMeshComponent::OnTrackableAdded(UARTrackedGeometry* Added)

Você pode acessar dados de malha através do UARTrackedGeometry::GetUnderlyingMesh:

UMRMeshComponent* UARTrackedGeometry::GetUnderlyingMesh()

Referência da API do Blueprint

Para trabalhar com malhas manuais em Blueprints:

1. Adicionar um componente ARTrackableNotify a um ator do Blueprint

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

3. Substitua em Adicionar/Atualizar/Remover Geometria Controlada com os seguintes nós no Gráfico 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 set Use Hand Mesh do plug-in Microsoft OpenXR com XRVisualization ativado como parâmetro:

Para gerenciar o processo de renderização, você deve usar o Render Motion Controller do XRVisualization:

O resultado:

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

Raios de mão

Fazer 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 de mão, que podem ser usados como dispositivos apontadores em C++ e Blueprints. Você pode desenhar um raio de sua mão até um ponto distante e, com alguma ajuda do traçado de raios Unreal, selecionar um holograma que, de outra forma, estaria fora de alcance.

Importante

Como todos os resultados da função mudam a cada quadro, todos eles são chamáveis. Para obter mais informações sobre funções puras e impuras ou chamáveis, consulte o guia de usuário do Blueprint sobre funções.

4.26

Para obter os dados para os raios de mão, você deve usar a função Get Motion Controller Data 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 da mira e Rotação da mira. Estes parâmetros formam um raio dirigido pelo cotovelo. Você deve levá-los e encontrar um holograma sendo apontado.

Abaixo está um exemplo de determinar se um raio de mão atinge um Widget e definir um resultado de acerto personalizado:

4.25

Para usar Hand Rays em Blueprints, procure qualquer uma das ações em Windows Mixed Reality HMD:

Para acessá-los em 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 em C++, use a EHMDInputControllerButtons classe enum:

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

Segue-se uma repartição dos dois casos de enum aplicáveis:

• Selecionar - Evento Select acionado pelo usuário.
  • Acionado no HoloLens 2 por toque, olhar e confirmar, ou dizendo "Selecionar" com a entrada de voz ativada.
• Grasp - Evento Grasp acionado pelo usuário.
  • Acionado no HoloLens 2 fechando os dedos do usuário em um holograma.

Você pode acessar o status de rastreamento de sua malha de mão em C++ através do EHMDTrackingStatus enum mostrado abaixo:

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

Segue-se uma repartição dos dois casos de enum aplicáveis:

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

Estrutura

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

• Origem – origem da mão
• Direção – direção da mão
• Up – vetor up da mão
• Orientação – quaternião de orientação
• Status de rastreamento – status de rastreamento atual

Você pode acessar o struct PointerPoseInfo através de Blueprints, como 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. Get Pointer Pose Info retorna informações completas sobre a direção do raio de mão no quadro atual.

Modelo:

C++:

static FPointerPoseInfo UWindowsMixedRealityFunctionLibrary::GetPointerPoseInfo(EControllerHand hand);

2. Is Grasped retorna true se a mão estiver agarrada no quadro atual.

Modelo:

C++:

static bool UWindowsMixedRealityFunctionLibrary::IsGrasped(EControllerHand hand);

3. Is Select Pressed retorna true se o usuário acionou Select no quadro atual.

Modelo:

C++:

static bool UWindowsMixedRealityFunctionLibrary::IsSelectPressed(EControllerHand hand);

4. O botão clicado retorna true se o evento ou botão for acionado no quadro atual.

Modelo:

C++:

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

5. Get Controller Tracking Status retorna o status de rastreamento 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 rastreamento 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 de uso básico do HoloLens 2.

4.26

Windows Mixed Reality

Em seguida, você deve adicionar código para se inscrever nos seguintes eventos:

OpenXR

No OpenXR, os eventos de gestos são rastreados através do pipeline de entrada. Usando a interação com as mãos, 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, você deve declarar os eventos em Configurações do projeto/Motor/Entrada, assim como:

4.25

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

Enumeração

Modelo:

C++:

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

Function

Você pode ativar e desativar a captura de gestos com a CaptureGestures função. Quando um gesto ativado 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);

A seguir estão 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 você está seguindo a jornada de desenvolvimento da Unreal que estabelecemos, está no meio da exploração dos principais blocos de construção do MRTK. A partir daqui, você pode continuar para o próximo bloco de construção:

Âncoras espaciais locais

Ou pule para os recursos e APIs da plataforma de Realidade Mista:

Câmara HoloLens

Você sempre pode voltar aos pontos de verificação de desenvolvimento da Unreal a qualquer momento.