Een HolographicSpace verkrijgen

  • Artikel

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 immersive rendering, biedt cameragegevens en biedt toegang tot API's voor ruimtelijke redenering. 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 hun toepassingsweergave. Deze wisselketen wordt weergegeven in een slate in de holografische gebruikersinterface. Als u de toepassingsweergave holografisch wilt maken in plaats van een 2D-lei, maakt u een holografische ruimte voor het kernvenster in plaats van een wisselketen. Het presenteren van holografische frames die door deze holografische ruimte zijn gemaakt, plaatst uw app in de weergavemodus volledig scherm.

Voor een UWP-appdie begint met de sjabloon Holographic DirectX 11 App (Universal Windows), zoekt u deze code in de methode SetWindow in AppView.cpp:

m_holographicSpace = HolographicSpace::CreateForCoreWindow(window);

Als u een Win32-app bouwt die begint met het Win32-voorbeeld BasicHologram, bekijkt u App::CreateWindowAndHolographicSpace voor een HWND-voorbeeld. U kunt deze vervolgens converteren naar een meeslepende HWND door een bijbehorende 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);
}

Zodra u een HolographicSpace hebt verkregen voor uw UWP CoreWindow of Win32 HWND, kan holographicSpace holografische camera's verwerken, coördinaatsystemen maken en holografische rendering uitvoeren. De huidige holografische ruimte wordt op meerdere plaatsen gebruikt 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 het holografische beeldscherm. De klasse HolographicSpace gebruikt het Direct3D 11-apparaat van uw app voor het maken en beheren van resources op basis van apparaten, zoals de achterbuffers voor elke holografische camera. Als u wilt weten 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

Hoewel in de onderstaande secties functienamen uit de sjabloon worden vermeld, zoals AppView::SetWindow , waarbij wordt ervan uitgegaan dat u bent gestart met de holografische UWP-app-sjabloon, worden de codefragmenten die u ziet, ook 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 voor holografische camera's ontvangen.

Uw app moet reageren op CameraToevoegingsgebeurtenissen 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 van CameraRemoved 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 wat werk voltooien om holografische rendering soepel te laten verlopen en uw app-rendering helemaal niet. Lees de code en opmerkingen voor de details: u kunt zoeken naar OnCameraAdded en OnCameraRemoved 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 die wordt uitgevoerd om uw app in staat te stellen op de hoogte te zijn van holografische camera's. Met dit in gedachten is het belangrijk om rekening te houden met de volgende twee vereisten:

  1. Voor de gebeurtenis-handler CameraToevoegen kan de app asynchroon werken om het maken van resources en het laden van assets voor de nieuwe holografische camera te voltooien. Apps die meer dan één frame nodig hebben om dit werk te voltooien, moeten 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 naar die camera kan worden weergegeven wanneer de gebeurtenis-handler wordt afgesloten of wanneer de uitstel is voltooid. Als u de gebeurtenis-handler afsluit of de uitstel voltooit, wordt aan het systeem aangegeven dat uw app nu klaar is voor het ontvangen van holografische frames met die camera.

  2. Wanneer de app een gebeurtenis CameraRemoved ontvangt, moet deze alle verwijzingen naar de achterbuffer vrijgeven en de functie direct afsluiten. Dit omvat het weergeven van doelweergaven en andere resources die mogelijk een verwijzing naar de IDXGIResource bevatten. De app moet er ook voor zorgen dat de backbuffer niet is gekoppeld als een renderdoel, zoals wordt weergegeven in CameraResources::ReleaseResourcesForBackBuffer. Om de snelheid te versnellen, kan uw app de achterbuffer vrijgeven en vervolgens een taak starten om asynchroon andere scheurwerkzaamheden voor de camera te voltooien. De holografische app-sjabloon bevat een PPL-taak die u voor dit doeleinde kunt gebruiken.

Notitie

Als u wilt bepalen wanneer een toegevoegde of verwijderde camera op het frame wordt weergegeven, gebruikt u de eigenschappen HolographicFrameAddedCameras en RemovedCameras .

Een referentiekader maken voor uw holografische inhoud

De inhoud van uw app moet worden geplaatst in een ruimtelijk coördinatensysteem om te worden weergegeven in de HolographicSpace. Het systeem biedt twee primaire referentieframes, die u kunt gebruiken om een coördinatensysteem voor uw hologrammen tot stand te brengen.

Er zijn twee soorten referentieframes in Windows Holographic: referentieframes die aan het apparaat zijn gekoppeld en referentieframes die stil blijven staan terwijl het apparaat zich door de omgeving van de gebruiker verplaatst. De holografische app-sjabloon maakt standaard gebruik van een stationair referentieframe; dit is een van de eenvoudigste manieren om hologrammen met wereldvergrendeling weer te geven.

Stationaire referentieframes zijn ontworpen om de 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 naarmate het apparaat meer te weten komt over de ruimte eromheen. Er zijn twee manieren om een stationair referentiekader te maken: het coördinatensysteem verkrijgen uit de ruimtelijke fase of de standaard SpatialLocator gebruiken. Als u een Windows Mixed Reality-app voor immersive headsets maakt, is het aanbevolen uitgangspunt de ruimtelijke fase. De ruimtelijke fase biedt ook informatie over de mogelijkheden van de immersive 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 beweegt niet met het apparaat mee.

Vanuit AppMain::SetHolographicSpace:

m_stationaryReferenceFrame =
    m_spatialLocator.CreateStationaryFrameOfReferenceAtCurrentLocation();

Alle referentieframes zijn uitgelijnd op de zwaartekracht, 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 een nauwkeurige plaatsing van afzonderlijke hologrammen vereist, gebruikt u een SpatialAnchor om het afzonderlijke hologram te verankeren op 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 kunnen wel worden aangepast. Wanneer een anker wordt aangepast, wordt standaard de positie van het anker over de volgende frames aangepast nadat de correctie is opgetreden. Afhankelijk van uw toepassing kunt u, wanneer dit gebeurt, de aanpassing op een andere manier afhandelen (bijvoorbeeld door deze uit te stellen totdat het hologram niet meer zichtbaar is). De eigenschap RawCoordinateSystem en de gebeurtenissen RawCoordinateSystemAdjusted maken deze aanpassingen mogelijk.

Reageren op gewijzigde gebeurtenissen van de beschikbaarheid

Voor het weergeven van wereld vergrendelde hologrammen moet het apparaat zich in de wereld bevinden. Dit is mogelijk niet altijd mogelijk vanwege omgevingscondities en zo ja, dan kan de gebruiker een visuele indicatie van de traceringsonderbreking verwachten. Deze visuele indicatie moet worden weergegeven met behulp van referentieframes die aan het apparaat zijn gekoppeld, in plaats van vast te zetten voor de wereld.

Uw app kan verzoeken om een melding te ontvangen als het bijhouden om welke reden dan ook wordt onderbroken. Registreer u voor de gebeurtenis LocatabilityChanged om te detecteren wanneer de mogelijkheid van het apparaat om zichzelf in de wereld te vinden, verandert. Vanuit AppMain::SetHolographicSpace:

m_locatabilityChangedToken = m_spatialLocator.LocatabilityChanged(
    std::bind(&HolographicApp6Main::OnLocatabilityChanged, this, _1, _2));

Gebruik deze gebeurtenis vervolgens om te bepalen wanneer hologrammen niet stationair kunnen worden weergegeven voor de wereld.

Zie ook