Hämta en HolographicSpace
Kommentar
Den här artikeln handlar om äldre inbyggda WinRT-API:er. För nya interna appprojekt rekommenderar vi att du använder OpenXR-API:et.
Klassen HolographicSpace är din portal i den holografiska världen. Den styr avancerad rendering, tillhandahåller kameradata och ger åtkomst till API:er för spatiala resonemang. Du skapar en för UWP-appens CoreWindow eller win32-appens HWND.
Konfigurera det holografiska utrymmet
Att skapa det holografiska rymdobjektet är det första steget i att skapa din Windows Mixed Reality-app. Traditionella Windows-appar renderas till en Direct3D-växlingskedja som skapats för kärnfönstret i deras programvy. Den här växlingskedjan visas på en skiffer i det holografiska användargränssnittet. Skapa ett holografiskt utrymme för dess kärnfönster i stället för en växlingskedja för att göra programvyn holografisk i stället för en 2D-skiffer. Om du presenterar holografiska ramar som skapas av det här holografiska utrymmet försätts din app i fullskärmsläge för återgivning.
Om du vill ha en UWP-app från mallen Holographic DirectX 11 App (Universal Windows) letar du efter den här koden i metoden SetWindow i AppView.cpp:
m_holographicSpace = HolographicSpace::CreateForCoreWindow(window);
Om du skapar en Win32-app från Exemplet BasicHologram Win32 kan du titta på App::CreateWindowAndHolographicSpace för ett HWND-exempel. Du kan sedan konvertera den till en uppslukande HWND genom att skapa en associerad HolographicSpace:
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);
}
När du har fått en HolographicSpace för UWP CoreWindow eller Win32 HWND kan HolographicSpace hantera holografiska kameror, skapa koordinatsystem och göra holografisk rendering. Det aktuella holografiska utrymmet används på flera platser i DirectX-mallen:
- Klassen DeviceResources måste hämta information från HolographicSpace-objektet för att skapa Direct3D-enheten. Det här är det DXGI-adapter-ID som är associerat med den holografiska visningen. Klassen HolographicSpace använder appens Direct3D 11-enhet för att skapa och hantera enhetsbaserade resurser, till exempel serverbuffertar för varje holografisk kamera. Om du är intresserad av att se vad den här funktionen gör under huven hittar du den i DeviceResources.cpp.
- Funktionen DeviceResources::InitializeUsingHolographicSpace visar hur du hämtar adaptern genom att leta upp LUID – och hur du väljer ett standardkort när inget prioriterat kort har angetts.
- Appens huvudklass använder det holografiska utrymmet från AppView::SetWindow eller App::CreateWindowAndHolographicSpace för uppdateringar och återgivning.
Kommentar
Även om avsnitten nedan nämner funktionsnamn från mallen som AppView::SetWindow som förutsätter att du har startat från den holografiska UWP-appmallen, tillämpas kodfragmenten som du ser lika mellan UWP- och Win32-appar.
Nu ska vi gå in på konfigurationsprocessen som SetHolographicSpace ansvarar för i Klassen AppMain.
Prenumerera på kamerahändelser, skapa och ta bort kameraresurser
Appens holografiska innehåll finns i dess holografiska utrymme och visas via en eller flera holografiska kameror, som representerar olika perspektiv på scenen. Nu när du har det holografiska utrymmet kan du ta emot data för holografiska kameror.
Din app måste svara på CameraAdded-händelser genom att skapa resurser som är specifika för kameran. Ett exempel på en sådan resurs är målvyn för serverbuffertåtergivning. Du kan se den här koden i funktionen DeviceResources::SetHolographicSpace , som anropas av AppView::SetWindow innan appen skapar några holografiska ramar:
m_cameraAddedToken = m_holographicSpace.CameraAdded(
std::bind(&AppMain::OnCameraAdded, this, _1, _2));
Din app måste också svara på CameraRemoved-händelser genom att frigöra resurser som har skapats för kameran.
Från DeviceResources::SetHolographicSpace:
m_cameraRemovedToken = m_holographicSpace.CameraRemoved(
std::bind(&AppMain::OnCameraRemoved, this, _1, _2));
Händelsehanterarna måste slutföra en del arbete för att hålla holografisk återgivning smidig och appåtergivningen alls. Läs koden och kommentarerna för informationen: du kan leta efter OnCameraAdded och OnCameraRemoved i huvudklassen för att förstå hur m_cameraResources-kartan hanteras av DeviceResources.
Just nu fokuserar vi på AppMain och den konfiguration som den gör för att göra det möjligt för din app att känna till holografiska kameror. Med detta i åtanke är det viktigt att notera följande två krav:
För cameraAdded-händelsehanteraren kan appen arbeta asynkront för att slutföra skapandet av resurser och läsa in tillgångar för den nya holografiska kameran. Appar som tar mer än en bildruta för att slutföra det här arbetet bör begära en fördröjning och slutföra uppskjutningen när de har lästs in asynkront. En PPL-uppgift kan användas för att utföra asynkront arbete. Din app måste se till att den är redo att återges till kameran direkt när den avslutar händelsehanteraren, eller när den slutför uppskjutningen. När du avslutar händelsehanteraren eller slutför uppskjutningen meddelar systemet att din app nu är redo att ta emot holografiska ramar med kameran inkluderad.
När appen tar emot en CameraRemoved-händelse måste den släppa alla referenser till backbufferten och avsluta funktionen direkt. Detta omfattar återgivning av målvyer och alla andra resurser som kan innehålla en referens till IDXGIResource. Appen måste också se till att serverbufferten inte är ansluten som ett återgivningsmål, som visas i CameraResources::ReleaseResourcesForBackBuffer. För att påskynda saker och ting kan din app frigöra bufferten på baksidan och sedan starta en uppgift för att asynkront slutföra allt annat arbete med att riva ned kameran. Den holografiska appmallen innehåller en PPL-uppgift som du kan använda för detta ändamål.
Kommentar
Om du vill avgöra när en tillagd eller borttagen kamera visas på ramen använder du egenskaperna HolographicFrame AddedCameras och RemovedCameras .
Skapa en referensram för ditt holografiska innehåll
Appens innehåll måste placeras i ett rumsligt koordinatsystem för att återges i HolographicSpace. Systemet innehåller två primära referensramar som du kan använda för att upprätta ett koordinatsystem för dina hologram.
Det finns två typer av referensramar i Windows Holographic: referensramar som är anslutna till enheten och referensramar som förblir stationära när enheten rör sig genom användarens miljö. Den holografiska appmallen använder en stationär referensram som standard. Detta är ett av de enklaste sätten att återge världslåst hologram.
Stationära referensramar är utformade för att stabilisera positioner nära enhetens aktuella plats. Det innebär att koordinaterna längre från enheten kan glida något i förhållande till användarens miljö eftersom enheten lär sig mer om utrymmet runt den. Det finns två sätt att skapa en stationär referensram: hämta koordinatsystemet från den rumsliga fasen eller använda standardinställningen SpatialLocator. Om du skapar en Windows Mixed Reality-app för uppslukande headset är den rekommenderade startpunkten den rumsliga fasen. Den rumsliga scenen ger också information om funktionerna i det uppslukande headsetet som spelaren bär. Här visar vi hur du använder standardinställningen SpatialLocator.
Den rumsliga positioneraren representerar Windows Mixed Reality-enheten och spårar enhetens rörelse och tillhandahåller koordinatsystem som kan förstås i förhållande till dess plats.
Från AppMain::OnHolographicDisplayIsAvailableChanged:
spatialLocator = SpatialLocator::GetDefault();
Skapa den stationära referensramen en gång när appen startas. Detta är detsamma som att definiera ett system för världskoordinat, med ursprunget som placeras på enhetens position när appen startas. Den här referensramen flyttas inte med enheten.
Från AppMain::SetHolographicSpace:
m_stationaryReferenceFrame =
m_spatialLocator.CreateStationaryFrameOfReferenceAtCurrentLocation();
Alla referensramar är gravitationsjusterade, vilket innebär att y-axeln pekar "uppåt" i förhållande till användarens miljö. Eftersom Windows använder "högerhänta" koordinatsystem sammanfaller riktningen för -z-axeln med den framåtriktade riktning som enheten är riktad mot när referensramen skapas.
Kommentar
När appen kräver exakt placering av enskilda hologram använder du en SpatialAnchor för att fästa det enskilda hologrammet på en position i verkligheten. Använd till exempel ett rumsligt fästpunkt när användaren anger att en punkt ska vara av särskilt intresse. Fästpunkter driver inte, men de kan justeras. När ett fästpunkt justeras underlättar det som standard sin position på plats under de kommande flera bildrutorna efter att korrigeringen har inträffat. Beroende på ditt program kanske du vill hantera justeringen på ett annat sätt (t.ex. genom att skjuta upp den tills hologrammet inte visas). Egenskapen RawCoordinateSystem och RawCoordinateSystemAdjusterade händelser aktiverar dessa anpassningar.
Svara på ändrade händelser för locatability
Om du vill återge världslåst hologram måste enheten hitta sig själv i världen. Detta kanske inte alltid är möjligt på grund av miljöförhållanden, och i så fall kan användaren förvänta sig en visuell indikation på spårningsavbrottet. Den här visuella indikeringen måste återges med hjälp av referensramar som är kopplade till enheten, i stället för stationära för världen.
Din app kan begära att få ett meddelande om spårningen avbryts av någon anledning. Registrera dig för händelsen LocatabilityChanged för att identifiera när enhetens möjlighet att hitta sig själv i världen ändras. Från AppMain::SetHolographicSpace:
m_locatabilityChangedToken = m_spatialLocator.LocatabilityChanged(
std::bind(&HolographicApp6Main::OnLocatabilityChanged, this, _1, _2));
Använd sedan den här händelsen för att avgöra när hologram inte kan återges stationära för världen.