Ajouter la communication à distance holographique (HoloLens 1ère génération)

  • Article

Si vous débutez avec la communication à distance holographique, vous pouvez lire notre vue d’ensemble.

Important

Ce document décrit la création d’une application hôte pour HoloLens 1. L’application hôte pour HoloLens (1ère génération) doit utiliser le package NuGet version 1.x.x. Cela implique que les applications hôtes écrites pour HoloLens 1 ne sont pas compatibles avec HoloLens 2 et vice versa.

HoloLens 2

Les développeurs HoloLens qui utilisent la communication à distance holographique devront mettre à jour leurs applications pour les rendre compatibles avec HoloLens 2. Cela nécessite une nouvelle version du package NuGet de communication à distance holographique. Veillez à utiliser la version 2.0.0.0 ou ultérieure du package NuGet Holographic Remoting lors de la connexion au Lecteur de communication à distance Holographique sur HoloLens 2. À défaut, la connexion échouera.

Notes

Vous trouverez des conseils spécifiques à HoloLens 2 ici.

Ajouter la communication à distance holographique à votre application de bureau ou UWP

Cette page explique comment ajouter la communication à distance holographique à une application de bureau ou UWP.

La communication à distance holographique permet à votre application de cibler un HoloLens avec du contenu holographique hébergé sur un PC de bureau ou sur un appareil UWP tel que Xbox One. Vous avez également accès à davantage de ressources système, ce qui permet d’intégrer des vues immersives à distance dans des logiciels PC de bureau existants. Une application hôte de communication à distance reçoit un flux de données d’entrée à partir d’un HoloLens, restitue le contenu dans une vue immersive virtuelle et diffuse en continu des images de contenu vers HoloLens. La connexion est établie à l’aide du Wi-Fi standard. Pour utiliser la communication à distance, utilisez un package NuGet pour ajouter la communication à distance holographique à votre application de bureau ou UWP, puis écrivez du code pour gérer la connexion et afficher une vue immersive. Les bibliothèques d’assistance sont incluses dans l’exemple de code qui simplifient la gestion de la connexion de l’appareil.

Une connexion à distance classique a une latence de 50 ms. L’application lecteur peut signaler la latence en temps réel.

Notes

Les extraits de code de cet article illustrent actuellement l’utilisation de C++/CX plutôt que C++/WinRT conforme À C++/WinRT, tel qu’il est utilisé dans le modèle de projet holographique C++. Les concepts sont équivalents pour un projet C++/WinRT, mais vous devez traduire le code.

Obtenir les packages NuGet de communication à distance

Procédez comme suit pour obtenir le package NuGet pour la communication à distance holographique et ajouter une référence à partir de votre projet :

  1. Accédez à votre projet dans Visual Studio.
  2. Cliquez avec le bouton droit sur le nœud du projet et sélectionnez Gérer les packages NuGet...
  3. Dans le panneau qui s’affiche, sélectionnez Parcourir , puis recherchez « Communication à distance holographique ».
  4. Sélectionnez Microsoft.Holographic.Remoting , puis Sélectionnez Installer.
  5. Si la boîte de dialogue Aperçu s’affiche, sélectionnez OK.
  6. Sélectionnez J’accepte lorsque la boîte de dialogue contrat de licence s’affiche.

Créer holographicStreamerHelpers

Tout d’abord, nous devons ajouter un instance de HolographicStreamerHelpers à la classe qui gérera la communication à distance.

#include <HolographicStreamerHelpers.h>

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

Vous devez également suivre l’état de la connexion. Si vous souhaitez afficher l’aperçu, vous devez avoir une texture vers laquelle la copier. Vous avez également besoin de quelques éléments tels qu’un verrou d’état de connexion, un moyen de stocker l’adresse IP de HoloLens, etc.

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;

Initialiser HolographicStreamerHelpers et se connecter à HoloLens

Pour vous connecter à un appareil HoloLens, créez un instance holographicStreamerHelpers et connectez-vous à l’adresse IP cible. Vous devez définir la taille de l’image vidéo pour qu’elle corresponde à la largeur et à la hauteur de l’affichage HoloLens, car la bibliothèque holographique de communication à distance s’attend à ce que les résolutions de l’encodeur et du décodeur correspondent exactement.

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);
       }

La connexion de l’appareil est asynchrone. Votre application doit fournir des gestionnaires d’événements pour les événements de connexion, de déconnexion et d’envoi de frame.

L’événement OnConnected peut mettre à jour l’interface utilisateur, démarrer le rendu, etc. Dans notre exemple de code de bureau, nous mettons à jour le titre de la fenêtre avec un message « connecté ».

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

L’événement OnDisconnected peut gérer la reconnexion, les mises à jour de l’interface utilisateur, etc. Dans cet exemple, nous nous reconnectons en cas d’échec temporaire.

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.");
               }
           });

Lorsque le composant de communication à distance est prêt à envoyer un frame, votre application a la possibilité d’en faire une copie dans SendFrameEvent. Ici, nous copieons le cadre dans une chaîne d’échange afin de pouvoir l’afficher dans une fenêtre d’aperçu.

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));
               }
           });

Afficher le contenu holographique

Pour afficher du contenu à l’aide de la communication à distance, vous configurez un IFrameworkView virtuel dans votre application de bureau ou UWP et vous traitez les images holographiques à partir de la communication à distance. Toutes les API Holographiques Windows sont utilisées de la même façon par cette vue, mais elle est configurée légèrement différemment.

Au lieu de les créer vous-même, l’espace holographique et les composants vocaux proviennent de votre classe HolographicRemotingHelpers :

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

Au lieu d’utiliser une boucle de mise à jour dans une méthode Run, vous fournissez des mises à jour de graduation à partir de la boucle main de votre bureau ou de votre application UWP. Cela permet à votre application de bureau ou UWP de garder le contrôle du traitement des messages.

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

       // display preview, etc.
   }

La méthode Tick() de l’affichage d’application holographique effectue une itération de la boucle de mise à jour, dessin, présent.

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);
           }
       }
   }

La mise à jour, le rendu et la boucle actuelle de l’affichage de l’application holographique sont exactement les mêmes que lors de l’exécution sur HoloLens, sauf que vous avez accès à une quantité beaucoup plus importante de ressources système sur votre PC de bureau. Vous pouvez afficher beaucoup plus de triangles, avoir plus de passes de dessin, faire plus de physique et utiliser des processus x64 pour charger du contenu qui nécessite plus de 2 Go de RAM.

Déconnecter et mettre fin à la session à distance

Pour se déconnecter , par exemple, lorsque l’utilisateur clique sur un bouton d’interface utilisateur pour se déconnecter, appelez Disconnect() sur HolographicStreamerHelpers, puis relâchez l’objet.

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;
       }
   }

Obtenir le lecteur de communication à distance

Le lecteur de communication à distance Holographique Windows est proposé dans l’App Store Windows en tant que point de terminaison pour la communication à distance des applications hôtes auxquelles se connecter. Pour obtenir le lecteur de communication à distance Holographique Windows, visitez l’App Store Windows à partir de votre HoloLens, recherchez Communication à distance et téléchargez l’application. Le lecteur de communication à distance inclut une fonctionnalité permettant d’afficher des statistiques à l’écran, ce qui peut être utile lors du débogage des applications hôtes de communication à distance.

Notes et ressources

L’affichage de l’application holographique a besoin d’un moyen de fournir à votre application l’appareil Direct3D, qui doit être utilisé pour initialiser l’espace holographique. Votre application doit utiliser cet appareil Direct3D pour copier et afficher le cadre d’aperçu.

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

Exemple de code : Un exemple de code de communication à distance holographique complet est disponible, qui inclut une vue d’application holographique compatible avec les projets hôtes de communication à distance et de communication à distance pour les ordinateurs de bureau Win32, UWP DirectX et UWP avec XAML.

Remarque sur le débogage : La bibliothèque de communication à distance holographique peut lever des exceptions de première chance. Ces exceptions peuvent être visibles dans les sessions de débogage, en fonction des paramètres d’exception Visual Studio actifs à ce moment-là. Ces exceptions sont interceptées en interne par la bibliothèque holographique à distance et peuvent être ignorées.

Voir aussi