Een HolographicSpace verkrijgen
Notitie
Dit artikel heeft betrekking op de verouderde Systeemeigen WinRT-API's. Voor nieuwe systeemeigen app-projecten raden we u aan de OpenXR-API te gebruiken.
De klasse HolographicSpace is uw portal in de holografische wereld. Het beheert insluitende rendering, biedt cameragegevens en biedt toegang tot ruimtelijke redenerings-API's. U maakt er een voor de CoreWindow van uw UWP-app of de HWND van uw Win32-app.
De holografische ruimte instellen
Het maken van het holografische ruimteobject is de eerste stap bij het maken van uw Windows Mixed Reality-app. Traditionele Windows-apps worden weergegeven in een Direct3D-wisselketen die is gemaakt voor het kernvenster van de toepassingsweergave. Deze wisselketen wordt weergegeven in een leisteen in de holografische gebruikersinterface. Als u uw toepassingsweergave holografisch wilt maken in plaats van een 2D-lei, maakt u een holografische ruimte voor het kernvenster in plaats van een wisselketen. Als u holografische frames presenteert die door deze holografische ruimte worden gemaakt, wordt uw app in de modus volledig scherm weergegeven.
Zoek voor een UWP-app die begint met de Holographic DirectX 11 App (Universal Windows)-sjabloon deze code in de methode SetWindow in AppView.cpp:
m_holographicSpace = HolographicSpace::CreateForCoreWindow(window);
Als u een Win32-app bouwt die begint met het BasicHologram Win32-voorbeeld, bekijkt u App::CreateWindowAndHolographicSpace voor een HWND-voorbeeld. U kunt deze vervolgens converteren naar een insluitende HWND door een gekoppelde HolographicSpace te maken:
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);
}
Nadat u een HolographicSpace hebt verkregen voor uw UWP CoreWindow of Win32 HWND, kan de HolographicSpace holografische camera's verwerken, coördinaatsystemen maken en holografische rendering uitvoeren. De huidige holografische ruimte wordt gebruikt op meerdere plaatsen in de DirectX-sjabloon:
- De klasse DeviceResources moet informatie ophalen uit het HolographicSpace-object om het Direct3D-apparaat te maken. Dit is de DXGI-adapter-id die is gekoppeld aan de holografische weergave. De klasse HolographicSpace maakt gebruik van het Direct3D 11-apparaat van uw app om resources op basis van apparaten te maken en te beheren, zoals de backbuffers voor elke holografische camera. Als u wilt zien wat deze functie onder de motorkap doet, vindt u deze in DeviceResources.cpp.
- De functie DeviceResources::InitializeUsingHolographicSpace laat zien hoe u de adapter kunt verkrijgen door de LUID op te zoeken en hoe u een standaardadapter kiest wanneer er geen voorkeursadapter is opgegeven.
- De hoofdklasse van de app maakt gebruik van de holografische ruimte van AppView::SetWindow of App::CreateWindowAndHolographicSpace voor updates en rendering.
Notitie
Terwijl in de onderstaande secties functienamen van de sjabloon worden vermeld, zoals AppView::SetWindow die ervan uitgaan dat u bent gestart vanuit de holografische UWP-app-sjabloon, worden de codefragmenten die u ziet, gelijk toegepast op UWP- en Win32-apps.
Vervolgens gaan we dieper in op het installatieproces waarvoor SetHolographicSpace verantwoordelijk is in de AppMain-klasse.
Abonneren op camera-gebeurtenissen, camera-resources maken en verwijderen
De holografische inhoud van uw app bevindt zich in de holografische ruimte en wordt bekeken via een of meer holografische camera's, die verschillende perspectieven op de scène vertegenwoordigen. Nu u de holografische ruimte hebt, kunt u gegevens ontvangen voor holografische camera's.
Uw app moet reageren op CameraAdded-gebeurtenissen door resources te maken die specifiek zijn voor die camera. Een voorbeeld van een dergelijke resource is de doelweergave van de backbuffer. U kunt deze code zien in de functie DeviceResources::SetHolographicSpace , aangeroepen door AppView::SetWindow voordat de app holografische frames maakt:
m_cameraAddedToken = m_holographicSpace.CameraAdded(
std::bind(&AppMain::OnCameraAdded, this, _1, _2));
Uw app moet ook reageren op gebeurtenissen die door CameraRe zijn verplaatst door resources vrij te geven die voor die camera zijn gemaakt.
Van DeviceResources::SetHolographicSpace:
m_cameraRemovedToken = m_holographicSpace.CameraRemoved(
std::bind(&AppMain::OnCameraRemoved, this, _1, _2));
De gebeurtenis-handlers moeten werk voltooien om holografische rendering soepel te laten verlopen en uw app-rendering helemaal. Lees de code en opmerkingen voor de details: u kunt zoeken naar OnCameraAdded en OnCameraRe verplaatst in uw hoofdklasse om te begrijpen hoe de m_cameraResources kaart wordt verwerkt door DeviceResources.
Op dit moment richten we ons op AppMain en de installatie waarmee uw app kennis kan maken van holografische camera's. Met dit in gedachten is het belangrijk om rekening te houden met de volgende twee vereisten:
Voor de Gebeurtenis-handler CameraAdded kan de app asynchroon werken om het maken van resources te voltooien en assets te laden voor de nieuwe holografische camera. Apps die meer dan één frame nodig hebben om dit werk te voltooien, moeten een uitstel aanvragen en de uitstel voltooien nadat ze asynchroon zijn geladen. Een PPL-taak kan worden gebruikt om asynchroon werk uit te voeren. Uw app moet ervoor zorgen dat deze direct aan die camera kan worden weergegeven wanneer de gebeurtenis-handler wordt afgesloten of wanneer deze het uitstel voltooit. Het afsluiten van de gebeurtenishandler of het voltooien van het uitstel vertelt het systeem dat uw app nu klaar is voor het ontvangen van holografische frames met die camera.
Wanneer de app een CameraRe verplaatste gebeurtenis ontvangt, moet deze alle verwijzingen naar de backbuffer vrijgeven en de functie meteen afsluiten. Dit omvat weergaven van doelweergaven en andere resources die een verwijzing naar de IDXGIResource kunnen bevatten. De app moet er ook voor zorgen dat de backbuffer niet is gekoppeld als renderdoel, zoals wordt weergegeven in CameraResources::ReleaseResourcesForBackBuffer. Om dingen sneller te laten verlopen, kan uw app de achterbuffer vrijgeven en vervolgens een taak starten om asynchroon andere scheurwerk voor de camera te voltooien. De holografische app-sjabloon bevat een PPL-taak die u voor dit doel kunt gebruiken.
Notitie
Als u wilt bepalen wanneer een toegevoegde of verwijderde camera wordt weergegeven in het frame, gebruikt u de eigenschappen HolographicFrame AddedCameras en RemovedCameras .
Een referentiekader maken voor uw holografische inhoud
De inhoud van uw app moet in een ruimtelijk coördinaatsysteem worden weergegeven in de HolographicSpace. Het systeem biedt twee primaire referentieframes, die u kunt gebruiken om een coördinaatsysteem voor uw hologrammen tot stand te brengen.
Er zijn twee soorten referentieframes in Windows Holographic: referentieframes die zijn gekoppeld aan het apparaat en referentieframes die stationair blijven terwijl het apparaat door de omgeving van de gebruiker gaat. De sjabloon voor holografische apps maakt standaard gebruik van een stationair referentieframe; dit is een van de eenvoudigste manieren om hologrammen met een wereldvergrendeling weer te geven.
Stationaire referentieframes zijn ontworpen om posities in de buurt van de huidige locatie van het apparaat te stabiliseren. Dit betekent dat coördinaten verder van het apparaat enigszins kunnen afwijken ten opzichte van de omgeving van de gebruiker, omdat het apparaat meer leert over de ruimte eromheen. Er zijn twee manieren om een stationair referentiekader te maken: het coördinaatsysteem verkrijgen uit de ruimtelijke fase of de standaard SpatialLocator gebruiken. Als u een Windows Mixed Reality-app voor insluitende headsets maakt, is het aanbevolen startpunt het ruimtelijke stadium. De ruimtelijke fase biedt ook informatie over de mogelijkheden van de insluitende headset die door de speler wordt gedragen. Hier laten we zien hoe u de standaard SpatialLocator gebruikt.
De ruimtelijke locator vertegenwoordigt het Windows Mixed Reality-apparaat en houdt de beweging van het apparaat bij en biedt coördinatensystemen die kunnen worden begrepen ten opzichte van de locatie.
Van AppMain::OnHolographicDisplayIsAvailableChanged:
spatialLocator = SpatialLocator::GetDefault();
Maak het stationaire referentieframe eenmaal wanneer de app wordt gestart. Dit is vergelijkbaar met het definiëren van een wereldcoördinaatsysteem, waarbij de oorsprong op de positie van het apparaat wordt geplaatst wanneer de app wordt gestart. Dit referentieframe wordt niet verplaatst met het apparaat.
Van AppMain::SetHolographicSpace:
m_stationaryReferenceFrame =
m_spatialLocator.CreateStationaryFrameOfReferenceAtCurrentLocation();
Alle referentieframes zijn zwaartekracht uitgelijnd, wat betekent dat de y-as 'omhoog' wijst ten opzichte van de omgeving van de gebruiker. Omdat Windows gebruikmaakt van 'rechtshandige' coördinatensystemen, valt de richting van de –z-as samen met de 'voorwaartse' richting waarmee het apparaat wordt geconfronteerd wanneer het referentieframe wordt gemaakt.
Notitie
Wanneer uw app nauwkeurige plaatsing van afzonderlijke hologrammen vereist, gebruikt u een SpatialAnchor om het afzonderlijke hologram te verankeren in een positie in de echte wereld. Gebruik bijvoorbeeld een ruimtelijk anker wanneer de gebruiker aangeeft dat een punt van bijzonder belang is. Ankerposities drijven niet af, maar ze kunnen worden aangepast. Wanneer een anker is aangepast, wordt standaard de positie in de volgende frames versoepeld nadat de correctie heeft plaatsgevonden. Afhankelijk van uw toepassing, kunt u de aanpassing op een andere manier afhandelen (bijvoorbeeld door deze uit te stellen totdat het hologram niet wordt weergegeven). De eigenschap RawCoördinaatSystem en rawCoördinaatSystemAdjusted-gebeurtenissen maken deze aanpassingen mogelijk.
Reageren op gewijzigde gebeurtenissen voor locatability
Voor het weergeven van hologrammen met vergrendelde wereld moet het apparaat zichzelf in de wereld vinden. Dit is mogelijk niet altijd mogelijk vanwege omgevingsomstandigheden, en als dat het zo is, kan de gebruiker een visuele indicatie van de traceringsonderbreking verwachten. Deze visuele indicatie moet worden weergegeven met behulp van referentieframes die zijn gekoppeld aan het apparaat, in plaats van stationair te zijn voor de wereld.
Uw app kan om welke reden dan ook worden gewaarschuwd als het bijhouden wordt onderbroken. Registreer u voor de gebeurtenis LocatabilityChanged om te detecteren wanneer het apparaat zichzelf kan vinden in de wereldwijzigingen. Van AppMain::SetHolographicSpace:
m_locatabilityChangedToken = m_spatialLocator.LocatabilityChanged(
std::bind(&HolographicApp6Main::OnLocatabilityChanged, this, _1, _2));
Gebruik deze gebeurtenis vervolgens om te bepalen wanneer hologrammen niet kunnen worden weergegeven, stationair naar de wereld.