Obter um HolographicSpace
Nota
Este artigo está relacionado às APIs nativas herdadas do WinRT. Para novos projetos de aplicativos nativos, recomendamos o uso da API OpenXR.
A classe HolographicSpace é o seu portal para o mundo holográfico. Ele controla a renderização imersiva, fornece dados da câmera e fornece acesso a APIs de raciocínio espacial. Você criará um para CoreWindow do seu aplicativo UWP ou para o HWND do seu aplicativo Win32.
Configurar o espaço holográfico
Criar o objeto de espaço holográfico é o primeiro passo para criar seu aplicativo Windows Mixed Reality. Os aplicativos tradicionais do Windows são renderizados em uma cadeia de permuta Direct3D criada para a janela principal da exibição do aplicativo. Essa cadeia de permuta é exibida para uma ardósia na interface do usuário holográfica. Para tornar sua aplicação holográfica em vez de uma ardósia 2D, crie um espaço holográfico para sua janela principal em vez de uma cadeia de permuta. A apresentação de quadros holográficos criados por esse espaço holográfico coloca seu aplicativo no modo de renderização em tela cheia.
Para um aplicativo UWP a partir do modelo Holográfico DirectX 11 App (Universal Windows), procure este código no método SetWindow em AppView.cpp:
m_holographicSpace = HolographicSpace::CreateForCoreWindow(window);
Se você estiver criando um aplicativo Win32 a partir do exemplo BasicHologram Win32, veja App::CreateWindowAndHolographicSpace para obter um exemplo de HWND. Você pode então convertê-lo em um HWND imersivo criando um HolographicSpace associado:
void App::CreateWindowAndHolographicSpace(HINSTANCE hInstance, int nCmdShow)
{
// Store the instance handle in our class variable.
m_hInst = hInstance;
// Create the window for the HolographicSpace.
hWnd = CreateWindowW(
m_szWindowClass,
m_szTitle,
WS_VISIBLE,
CW_USEDEFAULT,
0,
CW_USEDEFAULT,
0,
nullptr,
nullptr,
hInstance,
nullptr);
if (!hWnd)
{
winrt::check_hresult(E_FAIL);
}
{
// Use WinRT factory to create the holographic space.
using namespace winrt::Windows::Graphics::Holographic;
winrt::com_ptr<IHolographicSpaceInterop> holographicSpaceInterop =
winrt::get_activation_factory<HolographicSpace, IHolographicSpaceInterop>();
winrt::com_ptr<ABI::Windows::Graphics::Holographic::IHolographicSpace> spHolographicSpace;
winrt::check_hresult(holographicSpaceInterop->CreateForWindow(
hWnd, __uuidof(ABI::Windows::Graphics::Holographic::IHolographicSpace),
winrt::put_abi(spHolographicSpace)));
if (!spHolographicSpace)
{
winrt::check_hresult(E_FAIL);
}
// Store the holographic space.
m_holographicSpace = spHolographicSpace.as<HolographicSpace>();
}
// The DeviceResources class uses the preferred DXGI adapter ID from the holographic
// space (when available) to create a Direct3D device. The HolographicSpace
// uses this ID3D11Device to create and manage device-based resources such as
// swap chains.
m_deviceResources->SetHolographicSpace(m_holographicSpace);
// The main class uses the holographic space for updates and rendering.
m_main->SetHolographicSpace(hWnd, m_holographicSpace);
// Show the window. This will activate the holographic view and switch focus
// to the app in Windows Mixed Reality.
ShowWindow(hWnd, nCmdShow);
UpdateWindow(hWnd);
}
Depois de obter um HolographicSpace para seu UWP CoreWindow ou Win32 HWND, o HolographicSpace pode lidar com câmeras holográficas, criar sistemas de coordenadas e fazer renderização holográfica. O espaço holográfico atual é usado em vários lugares no modelo DirectX:
- A classe DeviceResources precisa obter algumas informações do objeto HolographicSpace para criar o dispositivo Direct3D. Este é o ID do adaptador DXGI associado ao visor holográfico. A classe HolographicSpace usa o dispositivo Direct3D 11 do seu aplicativo para criar e gerenciar recursos baseados em dispositivos, como os buffers traseiros de cada câmera holográfica. Se você estiver interessado em ver o que essa função faz sob o capô, você vai encontrá-la em DeviceResources.cpp.
- A função DeviceResources::InitializeUsingHolographicSpace demonstra como obter o adaptador procurando o LUID – e como escolher um adaptador padrão quando nenhum adaptador preferencial é especificado.
- A classe principal do aplicativo usa o espaço holográfico de AppView::SetWindow ou App::CreateWindowAndHolographicSpace para atualizações e renderização.
Nota
Embora as seções abaixo mencionem nomes de funções do modelo, como AppView::SetWindow , que pressupõem que você começou a partir do modelo holográfico de aplicativo UWP, os trechos de código que você vê serão aplicados igualmente em aplicativos UWP e Win32.
Em seguida, vamos mergulhar no processo de configuração pelo qual SetHolographicSpace é responsável na classe AppMain.
Inscrever-se em eventos da câmera, criar e remover recursos da câmera
O conteúdo holográfico do seu aplicativo vive em seu espaço holográfico e é visualizado por meio de uma ou mais câmeras holográficas, que representam diferentes perspetivas na cena. Agora que você tem o espaço holográfico, você pode receber dados para câmeras holográficas.
Seu aplicativo precisa responder aos eventos CameraAdded criando quaisquer recursos específicos para essa câmera. Um exemplo de tal recurso é sua exibição de destino de renderização de buffer traseiro. Você pode ver esse código na função DeviceResources::SetHolographicSpace , chamada por AppView::SetWindow antes que o aplicativo crie qualquer quadro holográfico:
m_cameraAddedToken = m_holographicSpace.CameraAdded(
std::bind(&AppMain::OnCameraAdded, this, _1, _2));
Seu aplicativo também precisa responder aos eventos CameraRemoved liberando recursos que foram criados para essa câmera.
De DeviceResources::SetHolographicSpace:
m_cameraRemovedToken = m_holographicSpace.CameraRemoved(
std::bind(&AppMain::OnCameraRemoved, this, _1, _2));
Os manipuladores de eventos devem concluir algum trabalho para manter a renderização holográfica fluindo sem problemas e a renderização do seu aplicativo. Leia o código e os comentários para obter os detalhes: você pode procurar por OnCameraAdded e OnCameraRemoved em sua classe principal para entender como o mapa de m_cameraResources é manipulado por DeviceResources.
No momento, estamos focados no AppMain e na configuração que ele faz para permitir que seu aplicativo saiba sobre câmeras holográficas. Com isso em mente, é importante tomar nota dos dois requisitos a seguir:
Para o manipulador de eventos CameraAdded , o aplicativo pode trabalhar de forma assíncrona para concluir a criação de recursos e o carregamento de ativos para a nova câmera holográfica. Os aplicativos que levam mais de um quadro para concluir esse trabalho devem solicitar um adiamento e concluí-lo após o carregamento assíncrono. Uma tarefa PPL pode ser usada para fazer trabalho assíncrono. Seu aplicativo deve garantir que esteja pronto para renderizar para essa câmera imediatamente quando sair do manipulador de eventos ou quando concluir o adiamento. Sair do manipulador de eventos ou concluir o adiamento informa ao sistema que seu aplicativo está pronto para receber quadros holográficos com essa câmera incluída.
Quando o aplicativo recebe um evento CameraRemoved , ele deve liberar todas as referências ao buffer traseiro e sair da função imediatamente. Isso inclui visualizações de destino de renderização e qualquer outro recurso que possa conter uma referência ao IDXGIResource. O aplicativo também deve garantir que o buffer traseiro não esteja anexado como um destino de renderização, conforme mostrado em CameraResources::ReleaseResourcesForBackBuffer. Para ajudar a acelerar as coisas, seu aplicativo pode liberar o buffer traseiro e, em seguida, iniciar uma tarefa para concluir de forma assíncrona qualquer outro trabalho de demolição para a câmera. O modelo de aplicativo holográfico inclui uma tarefa PPL que você pode usar para essa finalidade.
Nota
Se quiser determinar quando uma câmera adicionada ou removida aparece no quadro, use as propriedades HolographicFrame AddedCameras e RemovedCameras.
Crie um quadro de referência para o seu conteúdo holográfico
O conteúdo do seu aplicativo deve ser posicionado em um sistema de coordenadas espaciais para ser renderizado no HolographicSpace. O sistema fornece dois quadros de referência primários, que você pode usar para estabelecer um sistema de coordenadas para seus hologramas.
Há dois tipos de quadros de referência no Windows Holographic: quadros de referência anexados ao dispositivo e quadros de referência que permanecem estacionários à medida que o dispositivo se move pelo ambiente do usuário. O modelo de aplicativo holográfico usa um quadro de referência estacionário por padrão; Esta é uma das maneiras mais simples de renderizar hologramas bloqueados pelo mundo.
Os quadros de referência estacionários são projetados para estabilizar posições próximas à localização atual do dispositivo. Isso significa que as coordenadas mais distantes do dispositivo podem se desviar ligeiramente em relação ao ambiente do usuário à medida que o dispositivo aprende mais sobre o espaço ao seu redor. Há duas maneiras de criar um quadro de referência estacionário: adquirir o sistema de coordenadas do estágio espacial ou usar o SpatialLocator padrão. Se estiver a criar uma aplicação Windows Mixed Reality para auriculares imersivos, o ponto de partida recomendado é o palco espacial. O palco espacial também fornece informações sobre as capacidades do fone de ouvido imersivo usado pelo jogador. Aqui, mostramos como usar o SpatialLocator padrão.
O localizador espacial representa o dispositivo Windows Mixed Reality e rastreia o movimento do dispositivo e fornece sistemas de coordenadas que podem ser compreendidos em relação à sua localização.
De AppMain::OnHolographicDisplayIsAvailableChanged:
spatialLocator = SpatialLocator::GetDefault();
Crie o quadro de referência estacionário uma vez quando o aplicativo for iniciado. Isso é análogo à definição de um sistema de coordenadas mundiais, com a origem colocada na posição do dispositivo quando o aplicativo é iniciado. Este quadro de referência não se move com o dispositivo.
De AppMain::SetHolographicSpace:
m_stationaryReferenceFrame =
m_spatialLocator.CreateStationaryFrameOfReferenceAtCurrentLocation();
Todos os quadros de referência são alinhados por gravidade, o que significa que o eixo y aponta "para cima" em relação ao ambiente do usuário. Como o Windows usa sistemas de coordenadas "destros", a direção do eixo –z coincide com a direção "para frente" que o dispositivo está enfrentando quando o quadro de referência é criado.
Nota
Quando seu aplicativo exigir o posicionamento preciso de hologramas individuais, use um SpatialAnchor para ancorar o holograma individual a uma posição no mundo real. Por exemplo, use uma âncora espacial quando o usuário indicar um ponto de interesse especial. As posições de ancoragem não se desviam, mas podem ser ajustadas. Por padrão, quando uma âncora é ajustada, ela facilita sua posição no lugar ao longo dos próximos quadros após a correção ter ocorrido. Dependendo da sua aplicação, quando isso ocorre, você pode querer lidar com o ajuste de uma maneira diferente (por exemplo, adiando-o até que o holograma esteja fora de vista). A propriedade RawCoordinateSystem e os eventos RawCoordinateSystemAdjusted permitem essas personalizações.
Responder a eventos alterados de locatabilidade
A renderização de hologramas bloqueados pelo mundo requer que o dispositivo se localize no mundo. Isso pode nem sempre ser possível devido às condições ambientais e, em caso afirmativo, o usuário pode esperar uma indicação visual da interrupção do rastreamento. Esta indicação visual deve ser processada utilizando quadros de referência ligados ao dispositivo, em vez de estacionária para o mundo.
Seu aplicativo pode solicitar ser notificado se o rastreamento for interrompido por qualquer motivo. Registre-se no evento LocatabilityChanged para detetar quando a capacidade do dispositivo de se localizar no mundo muda. De AppMain::SetHolographicSpace:
m_locatabilityChangedToken = m_spatialLocator.LocatabilityChanged(
std::bind(&HolographicApp6Main::OnLocatabilityChanged, this, _1, _2));
Em seguida, use esse evento para determinar quando os hologramas não podem ser tornados estacionários para o mundo.