Hämta en HolographicSpace

  • Artikel

Anteckning

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 göra 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. Om du vill göra din programvy holografisk snarare än en 2D-skiffer skapar du ett holografiskt utrymme för dess kärnfönster i stället för en växlingskedja. Om du presenterar holografiska ramar som skapas av det här holografiska utrymmet försätts din app i helskärmsläge för återgivning.

Om du vill ha en UWP-appfrå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-appfrån Exemplet BasicHologram Win32 kan du titta på App::CreateWindowAndHolographicSpace för ett HWND-exempel. Du kan sedan konvertera den till en avancerad 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 DXGI-adapterns ID som är associerat med den holografiska skärmen. Klassen HolographicSpace använder appens Direct3D 11-enhet för att skapa och hantera enhetsbaserade resurser, till exempel de bakre buffertarna 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 önskat kort har angetts.
  • Appens huvudklass använder det holografiska utrymmet från AppView::SetWindow eller App::CreateWindowAndHolographicSpace för uppdateringar och återgivning.

Anteckning

Medan avsnitten nedan nämner funktionsnamn från mallen som AppView::SetWindow som förutsätter att du startade från den holografiska UWP-appmallen, tillämpas kodfragmenten som du ser lika mellan UWP- och Win32-appar.

Nu ska vi gå in på den konfigurationsprocess 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 den kameran. Ett exempel på en sådan resurs är målvyn för återgivning av serverbufferten. 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));

Appen 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 mer information: 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:

  1. För händelsehanteraren CameraAdded 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 uppskjutning och slutföra uppskjutningen när de har inläsningen 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. Om du avslutar händelsehanteraren eller slutför uppskjutningssteget meddelar du systemet att din app nu är redo att ta emot holografiska ramar med kameran inkluderad.

  2. När appen tar emot en CameraRemoved-händelse måste den släppa alla referenser till den bakre bufferten och avsluta funktionen direkt. Detta inkluderar återgivning av målvyer och andra resurser som kan innehålla en referens till IDXGIResource. Appen måste också se till att den bakre bufferten 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 den bakre bufferten 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.

Anteckning

Om du vill avgöra när en tillagd eller borttagen kamera visas på ramen använder du egenskaperna HolographicFrameAddedCameras 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 tillhandahå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 kopplade till enheten och referensramar som förblir stationära när enheten rör sig genom användarens miljö. Den holografiska appmallen använder som standard en stationär referensram. 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 koordinater 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 standard-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 bärs av spelaren. Här visar vi hur du använder standardinställningen SpatialLocator.

Den rumsliga lokaliseraren representerar den 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 världskoordinatsystem, 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.

Anteckning

När din app kräver exakt placering av enskilda hologram använder du en SpatialAnchor för att fästa det enskilda hologrammet på en position i den verkliga världen. 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 som standard underlättar det sin position på plats under de kommande flera bildrutorna efter att korrigeringen har inträffat. Beroende på ditt program kan det hända att du vill hantera justeringen på ett annat sätt (t.ex. genom att skjuta upp den tills hologrammet inte visas). RawCoordinateSystem-egenskapen och RawCoordinateSystemAdjusted-händelserna 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 indikationen måste återges med 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.

Se även