Acompanhamento da mão no 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, a palma da mão inteira e gestos com as mãos estão disponíveis. A partir do Unreal 4.26, o rastreamento manual é 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 com as mãos permite que você rastreie e use as mãos e os dedos de seus usuários como entrada, que podem ser acessados 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 Obter dados do controlador de movimento. Essa função retorna uma estrutura XRMotionControllerData . Abaixo está 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 verificar se a estrutura é válida e se é uma mãozinha. Caso contrário, você poderá 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 Blueprints:

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 manual em Blueprints adicionando Suporta rastreamento de mão do Windows Mixed Reality de rastreamento > de mão:

Essa função retorna true se o rastreamento manual for suportado no dispositivo e false se o rastreamento manual não estiver disponível.

C++:

Incluir WindowsMixedRealityHandTrackingFunctionLibrary.h.

static bool UWindowsMixedRealityHandTrackingFunctionLibrary::SupportsHandTracking()

Obtendo rastreamento de mãos

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 é recomendado ter lógica pesada nesta 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 a mão esquerda ou direita do usuário.
• Keypoint – o osso da mão.
• Transformar – coordenadas e orientação da base do osso. Você pode solicitar a base do próximo bone para obter os dados de transformação para o final de um bone. Um osso especial da ponta dá fim de distal.
• **Raio – raio da base do osso.
• **Valor de retorno—true se o bone for rastreado neste quadro, false se o bone 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 Windows Mixed Reality e Live Link estiverem habilitados:

1. Selecione Window > Live Link para abrir a janela do editor Live Link.
2. Selecione Origem e habilite a Origem de Rastreamento de Mão 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 também veja opções adicionais.

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

Também pode ser subclassificado no editor:

Malha de Mão

Importante

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 manuais como uma geometria rastreada no OpenXR requer que você chame Set Use Hand Mesh with Enabled Tracking Geometry.

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

Observação

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

Acessando dados de malha manual

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

• Selecione seu ativo ARSessionConfig , expanda as configurações de AR Settings -> World Mapping e marque Generate Mesh Data from Tracked Geometry.

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

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 plantas:

1. Adicionar um componente ARTrackableNotify a um ator do Blueprint

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

3. Substituir 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 plugin 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 habilitado como parâmetro:

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

O resultado :

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

Raios de mão

Fazer pose com as mãos funciona para interações próximas, como pegar 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 de funções mudam a cada quadro, todos eles são tornados chamáveis. Para obter mais informações sobre funções puras e impuras ou chamáveis, consulte o GUID do 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 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 da mira e Rotação da mira. Esses parâmetros formam um raio direcionado 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.

Enum

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,
//......
};

Abaixo está uma divisão dos dois casos de enum aplicáveis:

• Select - Evento Select acionado pelo usuário.
  • Acionado no HoloLens 2 por toque de ar, 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 enum EHMDTrackingStatus mostrado abaixo:

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

Abaixo está uma divisão dos dois casos de enum aplicáveis:

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

Estrutura

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

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

Você pode acessar a estrutura 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. Obter informações de pose de ponteiro retorna informações completas sobre a direção do raio de mão no quadro atual.

Esquema:

C++:

static FPointerPoseInfo UWindowsMixedRealityFunctionLibrary::GetPointerPoseInfo(EControllerHand hand);

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

Esquema:

C++:

static bool UWindowsMixedRealityFunctionLibrary::IsGrasped(EControllerHand hand);

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

Esquema:

C++:

static bool UWindowsMixedRealityFunctionLibrary::IsSelectPressed(EControllerHand hand);

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

Esquema:

C++:

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

5. Obter Status de Rastreamento do Controlador retorna o status de rastreamento no quadro atual.

Esquema:

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 deseja rastrear. Você pode encontrar mais detalhes sobre gestos no documento HoloLens 2 Basic Usage .

4.26

Windows Mixed Reality

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

OpenXR

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

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.

Enum

Esquema:

C++:

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

Função

Você pode ativar e desativar 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.

Esquema:

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