Een HolographicSpace verkrijgen

Notitie

Dit artikel heeft betrekking op de verouderde, native WinRT-API's. Voor nieuwe native app-projecten raden we u aan de OpenXR-API te gebruiken.

De HolographicSpace-klasse is uw portal in de holografische wereld. Het beheert in 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 de toepassingsweergave. Deze wisselingsketen wordt weergegeven op een slate in de holografische gebruikersinterface. Als u uw toepassing holografische weergave wilt maken in plaats van een 2D-slate, maakt u een holografische ruimte voor het kernvenster in plaats van een wisselketen. Door holografische frames te presenteren die door deze holografische ruimte worden gemaakt, wordt uw app in de modus volledig scherm weergegeven.

Als u een UWP-app wilt starten vanuit de Holographic DirectX 11 App-sjabloon (Universal Windows), gaat u naar deze code in de methode SetWindow in AppView.cpp:

m_holographicSpace = HolographicSpace::CreateForCoreWindow(window);

Als u een Win32-app bouwt op basis van het BasicOgram Win32-voorbeeld, bekijkt u App::CreateWindowAndOloographicSpace voor een HWND-voorbeeld. U kunt deze vervolgens converteren naar een immersieve 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);
}

Zodra u een HolographicSpace hebt verkregen voor uw UWP CoreWindow of Win32 HWND, kan de HolographicSpace holografische camera's verwerken, coördinatensystemen maken en holografische renderingen. De huidige holografische ruimte wordt op meerdere plaatsen in de DirectX-sjabloon gebruikt:

  • De deviceResources-klasse moet informatie verkrijgen van het HolographicSpace-object om het Direct3D-apparaat te maken. Dit is de id van de DXGI-adapter die is gekoppeld aan de holografische weergave. De HolographicSpace-klasse gebruikt het Direct3D 11-apparaat van uw app om op apparaten gebaseerde resources te maken en te beheren, zoals de backbuffers voor elke holografische camera. Als u wilt zien wat deze functie doet, vindt u deze in DeviceResources.cpp.
  • De functie DeviceResources::InitializeUsingOloographicSpace laat zien hoe u de adapter kunt verkrijgen door de INDIEN 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::CreateWindowAndServer voor updates en rendering.

Notitie

In de onderstaande secties worden functienamen uit de sjabloon vermeld, zoals AppView::SetWindow , die ervan uitgaan dat u bent gestart vanuit de holografische UWP-app-sjabloon, maar de codefragmenten die u ziet, gelden evenveel voor UWP- en Win32-apps.

Vervolgens gaan we dieper in op het installatieproces voor SetServergraphicSpace in de klasse AppMain.

Abonneren op cameragebeurtenissen, camera-resources maken en verwijderen

De holografische inhoud van uw app staat 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 CameraGeaddeerde gebeurtenissen door resources te maken die specifiek zijn voor die camera. Een voorbeeld van een dergelijke resource is de weergave van de doelweergave van de backbuffer. U kunt deze code zien in de functie DeviceResources::SetServerographicSpace , 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 CameraRemoved-gebeurtenissen door resources vrij te geven die voor die camera zijn gemaakt.

Van DeviceResources::SetServergraphicSpace:

m_cameraRemovedToken = m_holographicSpace.CameraRemoved(
    std::bind(&AppMain::OnCameraRemoved, this, _1, _2));

De gebeurtenis-handlers moeten een aantal werkzaamheden voltooien om ervoor te zorgen dat holografische rendering soepel blijft verlopen en uw app helemaal niet wordt weergeven. Lees de code en opmerkingen voor meer informatie: 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 het doet om uw app op de weg te laten staan over holografische camera's. Met dit in gedachten is het belangrijk om rekening te houden met de volgende twee vereisten:

  1. Voor de gebeurtenis-handler CameraAdded 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 na het laden asynchroon voltooien. Een PPL-taak kan worden gebruikt om asynchroon werk uit te voeren. Uw app moet ervoor zorgen dat deze direct kan worden weergegeven voor die camera wanneer deze de gebeurtenis-handler verlaat of wanneer het uitstellen is voltooid. Het afsluiten van de gebeurtenis-handler of het voltooien van het uitstel vertelt het systeem dat uw app nu gereed is voor het ontvangen van holografische frames met die camera.

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

Notitie

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

Een referentiekader voor uw holografische inhoud maken

De inhoud van uw app moet in een ruimtelijk coördinaatsysteem worden geplaatst om te 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 brengt.

Er zijn twee soorten referentieframes in Windows Holographic: referentieframes die aan het apparaat zijn gekoppeld en referentieframes die stationair blijven wanneer het apparaat zich door de omgeving van de gebruiker verplaatst. De sjabloon voor holografische apps maakt standaard gebruik van een stationair referentieframe; Dit is een van de eenvoudigste manieren om wereldge vergrendelde hologrammen 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 wanneer het apparaat meer over de ruimte eromheen leert. Er zijn twee manieren om een stationair referentieframe te maken: het coördinaatsysteem verkrijgen uit de ruimtelijke fase of de standaard spatialLocator gebruiken. Als u een app maakt Windows Mixed Reality voor immersieve headsets, is het aanbevolen beginpunt de ruimtelijke fase. De ruimtelijke fase biedt ook informatie over de mogelijkheden van de immersive headset die door de speler worden gedragen. Hier laten we zien hoe u de standaard spatiallocator gebruikt.

De ruimtelijke locator vertegenwoordigt het Windows Mixed Reality apparaat, houdt de beweging van het apparaat bij en biedt coördinatensystemen die kunnen worden begrepen ten opzichte van de locatie.

Van AppMain::OnOlographicDisplayIsAvailableChanged:

spatialLocator = SpatialLocator::GetDefault();

Maak het stationaire referentieframe eenmaal wanneer de app wordt gestart. Dit is vergelijkbaar met het definiëren van een wereldcoördinaatsysteem, met de oorsprong op de positie van het apparaat wanneer de app wordt gestart. Dit referentieframe wordt niet verplaatst met het apparaat.

Vanuit AppMain::SetOloographicSpace:

m_stationaryReferenceFrame =
    m_spatialLocator.CreateStationaryFrameOfReferenceAtCurrentLocation();

Alle referentieframes zijn uitgelijnd met de ernst, wat betekent dat de y-as omhoog wijst in relatie tot de omgeving van de gebruiker. Omdat Windows gebruikmaakt van 'rechtshandige' coördinatensystemen, valt de richting van de –z-as samen met de 'forward'-richting die het apparaat heeft wanneer het referentieframe wordt gemaakt.

Notitie

Wanneer voor uw app nauwkeurige plaatsing van afzonderlijke hologrammen is vereist, gebruikt u een SpatialAnchor om het afzonderlijke hologram te ankeren op een positie in de echte wereld. Gebruik bijvoorbeeld een ruimtelijk anker wanneer de gebruiker aangeeft dat een punt van speciale interesse is. Ankerposities worden niet gewijzigd, maar kunnen wel worden aangepast. Wanneer een anker wordt aangepast, vereengemakt het standaard de positie in de volgende frames 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 meer wordt bekeken). De eigenschap RawCoordinateSystem en De gebeurtenissen RawCoordinateSystemAdjusted maken deze aanpassingen mogelijk.

Reageren op gebeurtenissen die zijn gewijzigd door de locatability

Voor het weergeven van wereldwijd vergrendelde hologrammen moet het apparaat zich in de wereld kunnen vinden. Dit is mogelijk niet altijd mogelijk vanwege omgevingsomstandigheden, en als dat het zo is, verwacht de gebruiker mogelijk een visuele indicatie van de onderbreking van het bijhouden. Deze visuele indicatie moet worden weergegeven met behulp van referentieframes die zijn gekoppeld aan het apparaat, in plaats van stationair voor de wereld.

Uw app kan een aanvraag indienen om een melding te ontvangen als het bijhouden om een of andere reden wordt onderbroken. Registreer u voor de locatabilityChanged-gebeurtenis om te detecteren wanneer de mogelijkheid van het apparaat om zichzelf te vinden in de wereld verandert. Vanuit AppMain::SetOloographicSpace:

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