Lägg till Holographic Remoting (HoloLens 1:a gen)

  • Artikel

Om du inte har använt Holographic Remoting tidigare kanske du vill läsa vår översikt.

Viktigt

Det här dokumentet beskriver hur du skapar ett värdprogram för HoloLens 1. Värdprogrammet för HoloLens (första generationen) måste använda NuGet-paketversion 1.x.x. Detta innebär att värdprogram som skrivits för HoloLens 1 inte är kompatibla med HoloLens 2 och vice versa.

HoloLens 2

HoloLens-utvecklare som använder Holographic Remoting måste uppdatera sina appar för att göra dem kompatibla med HoloLens 2. Detta kräver en ny version av NuGet-paketet Holographic Remoting. Se till att använda version 2.0.0.0 eller senare av NuGet-paketet Holographic Remoting när du ansluter till Holographic Remoting Player på HoloLens 2. Annars misslyckas anslutningen.

Anteckning

Vägledning som är specifik för HoloLens 2 finns här.

Lägga till holografisk fjärrkommunikation till skrivbordet eller UWP-appen

Den här sidan beskriver hur du lägger till Holographic Remoting i en skrivbords- eller UWP-app.

Med holografisk fjärrkommunikation kan din app rikta in sig på en HoloLens med holografiskt innehåll på en stationär dator eller på en UWP-enhet, till exempel Xbox One. Du har också åtkomst till fler systemresurser, vilket gör det möjligt att integrera avancerade fjärrvyer i befintlig programvara för stationära datorer. En värdapp för fjärrkommunikation tar emot en indataström från en HoloLens, återger innehåll i en virtuell fördjupad vy och strömmar tillbaka innehållsramar till HoloLens. Anslutningen upprättas med standard wi-fi. Om du vill använda fjärrkommunikation använder du ett NuGet-paket för att lägga till holografisk fjärrkommunikation till skrivbordet eller UWP-appen och skriver sedan kod för att hantera anslutningen och rendera en fördjupad vy. Hjälpbibliotek ingår i kodexemplet som förenklar uppgiften att hantera enhetsanslutningen.

En typisk fjärranslutning har så låg svarstid som 50 ms. Spelarappen kan rapportera svarstiden i realtid.

Anteckning

Kodfragmenten i den här artikeln visar för närvarande användningen av C++/CX i stället för C++17-kompatibel C++/WinRT som används i C++-holografisk projektmall. Begreppen motsvarar ett C++/WinRT-projekt, men du måste översätta koden.

Hämta NuGet-paketen för fjärrkommunikation

Följ dessa steg för att hämta NuGet-paketet för holografisk fjärrkommunikation och lägg till en referens från projektet:

  1. Gå till projektet i Visual Studio.
  2. Högerklicka på projektnoden och välj Hantera NuGet-paket...
  3. I panelen som visas väljer du Bläddra och söker sedan efter "Holographic Remoting".
  4. Välj Microsoft.Holographic.Remoting och välj Installera.
  5. Om dialogrutan Förhandsgranska visas väljer du OK.
  6. Välj Jag accepterar när dialogrutan licensavtal visas.

Skapa HolographicStreamerHelpers

Först måste vi lägga till en instans av HolographicStreamerHelpers till klassen som ska hantera fjärrkommunikation.

#include <HolographicStreamerHelpers.h>

   private:
       Microsoft::Holographic::HolographicStreamerHelpers^ m_streamerHelpers;

Du måste också spåra anslutningstillståndet. Om du vill återge förhandsgranskningen måste du ha en struktur att kopiera den till. Du behöver också några saker som ett anslutningstillståndslås, ett sätt att lagra IP-adressen för HoloLens och så vidare.

private:
       Microsoft::Holographic::HolographicStreamerHelpers^ m_streamerHelpers;

       Microsoft::WRL::Wrappers::SRWLock                   m_connectionStateLock;

       RemotingHostSample::AppView^                        m_appView;
       Platform::String^                                   m_ipAddress;
       Microsoft::Holographic::HolographicStreamerHelpers^ m_streamerHelpers;

       Microsoft::WRL::Wrappers::CriticalSection           m_deviceLock;
       Microsoft::WRL::ComPtr<IDXGISwapChain1>             m_swapChain;
       Microsoft::WRL::ComPtr<ID3D11Texture2D>             m_spTexture;

Initiera HolographicStreamerHelpers och anslut till HoloLens

Om du vill ansluta till en HoloLens-enhet skapar du en instans av HolographicStreamerHelpers och ansluter till mål-IP-adressen. Du måste ange videoramens storlek så att den matchar HoloLens-skärmens bredd och höjd, eftersom Holographic Remoting-biblioteket förväntar sig att kodarens och avkodarens upplösningar matchar exakt.

m_streamerHelpers = ref new HolographicStreamerHelpers();
       m_streamerHelpers->CreateStreamer(m_d3dDevice);

       // We currently need to stream at 720p because that's the resolution of our remote display.
       // There is a check in the holographic streamer that makes sure the remote and local
       // resolutions match. The default streamer resolution is 1080p.
       m_streamerHelpers->SetVideoFrameSize(1280, 720);

       try
       {
           m_streamerHelpers->Connect(m_ipAddress->Data(), 8001);
       }
       catch (Platform::Exception^ ex)
       {
           DebugLog(L"Connect failed with hr = 0x%08X", ex->HResult);
       }

Enhetsanslutningen är asynkron. Din app måste tillhandahålla händelsehanterare för att ansluta, koppla från och rama in sändningshändelser.

Händelsen OnConnected kan uppdatera användargränssnittet, börja återge och så vidare. I vårt kodexempel för skrivbordet uppdaterar vi fönsterrubriken med ett "anslutet" meddelande.

m_streamerHelpers->OnConnected += ref new ConnectedEvent(
           [this]()
           {
               UpdateWindowTitle();
           });

Händelsen OnDisconnected kan hantera återanslutning, uppdateringar av användargränssnittet och så vidare. I det här exemplet återansluter vi om det uppstår ett tillfälligt fel.

Platform::WeakReference streamerHelpersWeakRef = Platform::WeakReference(m_streamerHelpers);
       m_streamerHelpers->OnDisconnected += ref new DisconnectedEvent(
           [this, streamerHelpersWeakRef](_In_ HolographicStreamerConnectionFailureReason failureReason)
           {
               DebugLog(L"Disconnected with reason %d", failureReason);
               UpdateWindowTitle();

               // Reconnect if this is a transient failure.
               if (failureReason == HolographicStreamerConnectionFailureReason::Unreachable ||
                   failureReason == HolographicStreamerConnectionFailureReason::ConnectionLost)
               {
                   DebugLog(L"Reconnecting...");

                   try
                   {
                       auto helpersResolved = streamerHelpersWeakRef.Resolve<HolographicStreamerHelpers>();
                       if (helpersResolved)
                       {
                           helpersResolved->Connect(m_ipAddress->Data(), 8001);
                       }
                       else
                       {
                           DebugLog(L"Failed to reconnect because a disconnect has already occurred.\n");
                       }
                   }
                   catch (Platform::Exception^ ex)
                   {
                       DebugLog(L"Connect failed with hr = 0x%08X", ex->HResult);
                   }
               }
               else
               {
                   DebugLog(L"Disconnected with unrecoverable error, not attempting to reconnect.");
               }
           });

När fjärrkommunikationskomponenten är redo att skicka en ram får din app möjlighet att göra en kopia av den i SendFrameEvent. Här kopierar vi ramen till en växlingskedja så att vi kan visa den i ett förhandsgranskningsfönster.

m_streamerHelpers->OnSendFrame += ref new SendFrameEvent(
           [this](_In_ const ComPtr<ID3D11Texture2D>& spTexture, _In_ FrameMetadata metadata)
           {
               if (m_showPreview)
               {
                   ComPtr<ID3D11Device1> spDevice = m_appView->GetDeviceResources()->GetD3DDevice();
                   ComPtr<ID3D11DeviceContext> spContext = m_appView->GetDeviceResources()->GetD3DDeviceContext();

                   ComPtr<ID3D11Texture2D> spBackBuffer;
                   ThrowIfFailed(m_swapChain->GetBuffer(0, IID_PPV_ARGS(&spBackBuffer)));

                   spContext->CopySubresourceRegion(
                       spBackBuffer.Get(), // dest
                       0,                  // dest subresource
                       0, 0, 0,            // dest x, y, z
                       spTexture.Get(),    // source
                       0,                  // source subresource
                       nullptr);           // source box, null means the entire resource

                   DXGI_PRESENT_PARAMETERS parameters = { 0 };
                   ThrowIfFailed(m_swapChain->Present1(1, 0, &parameters));
               }
           });

Rendera holografiskt innehåll

Om du vill rendera innehåll med hjälp av fjärrkommunikation konfigurerar du en virtuell IFrameworkView i din skrivbords- eller UWP-app och bearbetar holografiska ramar från fjärrkommunikation. Alla Windows Holographic API:er används på samma sätt av den här vyn, men de har konfigurerats lite annorlunda.

I stället för att skapa dem själv kommer de holografiska utrymmes- och talkomponenterna från klassen HolographicRemotingHelpers:

m_appView->Initialize(m_streamerHelpers->HolographicSpace, m_streamerHelpers->RemoteSpeech);

I stället för att använda en uppdateringsloop i en Kör-metod tillhandahåller du tickuppdateringar från huvudslingan för skrivbordet eller UWP-appen. På så sätt kan skrivbordet eller UWP-appen behålla kontrollen över meddelandebearbetningen.

void DesktopWindow::Tick()
   {
       auto lock = m_deviceLock.Lock();
       m_appView->Tick();

       // display preview, etc.
   }

Metoden Tick() för den holografiska appvyn slutför en iteration av uppdaterings-, draw-, present-loopen.

void AppView::Tick()
   {
       if (m_main)
       {
           // When running on Windows Holographic, we can use the holographic rendering system.
           HolographicFrame^ holographicFrame = m_main->Update();

           if (holographicFrame && m_main->Render(holographicFrame))
           {
               // The holographic frame has an API that presents the swap chain for each
               // holographic camera.
               m_deviceResources->Present(holographicFrame);
           }
       }
   }

Den holografiska appvyns uppdaterings-, återgivnings- och nutidsloop är exakt samma som när den körs på HoloLens – förutom att du har åtkomst till en mycket större mängd systemresurser på din stationära dator. Du kan rendera många fler trianglar, ha fler ritningspass, göra mer fysik och använda x64-processer för att läsa in innehåll som kräver mer än 2 GB RAM-minne.

Koppla från och avsluta fjärrsessionen

Om du vill koppla från – till exempel när användaren klickar på en UI-knapp för att koppla från – anropar du Disconnect() på HolographicStreamerHelpers och släpper sedan objektet.

void DesktopWindow::DisconnectFromRemoteDevice()
   {
       // Disconnecting from the remote device can change the connection state.
       auto exclusiveLock = m_connectionStateLock.LockExclusive();

       if (m_streamerHelpers != nullptr)
       {
           m_streamerHelpers->Disconnect();

           // Reset state
           m_streamerHelpers = nullptr;
       }
   }

Hämta fjärrkommunikationsspelaren

Windows Holographic remoting player erbjuds i Windows App Store som en slutpunkt för fjärrkommunikation av värdappar att ansluta till. Om du vill hämta Windows Holographic remoting player går du till Windows App Store från Din HoloLens, söker efter Fjärrkommunikation och laddar ned appen. Fjärrkommunikationsspelaren innehåller en funktion för att visa statistik på skärmen, vilket kan vara användbart vid felsökning av värdappar för fjärrkommunikation.

Anteckningar och resurser

Den holografiska appvyn behöver ett sätt att förse din app med Direct3D-enheten, som måste användas för att initiera det holografiska utrymmet. Appen bör använda den här Direct3D-enheten för att kopiera och visa förhandsgranskningsramen.

internal:
       const std::shared_ptr<DX::DeviceResources>& GetDeviceResources()
       {
           return m_deviceResources;
       }

Kodexempel: Det finns ett komplett kodexempel för Holographic Remoting , som innehåller en holografisk programvy som är kompatibel med värdprojekt för fjärrkommunikation och fjärrkommunikation för Win32, UWP DirectX och UWP med XAML.

Felsökningsanteckning: Holographic Remoting-biblioteket kan utlösa undantag med första chansen. De här undantagen kan visas i felsökningssessioner, beroende på vilka Inställningar för Visual Studio-undantag som är aktiva vid den tidpunkten. Dessa undantag fångas internt av biblioteket Holographic Remoting och kan ignoreras.

Se även