Obtention d’un HolographicSpace

La classe HolographicSpace est votre portail dans le monde holographique. Il contrôle le rendu immersif, fournit des données de caméra et permet d’accéder aux API de raisonnement spatial. Vous en créerez un pour coreWindow de votre application UWP ou le HWND de votre application Win32.

Configurer l’espace holographique

La création de l’objet d’espace holographique est la première étape de la création de votre application Windows Mixed Reality. Les applications Windows traditionnelles s’affichent sur une chaîne d’échange Direct3D créée pour la fenêtre principale de leur affichage d’application. Cette chaîne d’échange s’affiche sur une ardoise dans l’interface utilisateur holographique. Pour rendre l’affichage holographique de votre application plutôt qu’une ardoise 2D, créez un espace holographique pour sa fenêtre principale au lieu d’une chaîne d’échange. La présentation d’images holographiques créées par cet espace holographique place votre application en mode de rendu plein écran.

Pour une application UWP à partir du modèle Holographic DirectX 11 App (Windows universel), recherchez ce code dans la méthode SetWindow dans AppView.cpp :

m_holographicSpace = HolographicSpace::CreateForCoreWindow(window);

Si vous créez une application Win32 à partir de l’exemple BasicHologram Win32, examinez App ::CreateWindowAndHolographicSpace pour un exemple HWND. Vous pouvez ensuite le convertir en HWND immersif en créant un HolographicSpace associé :

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

Une fois que vous avez obtenu un HolographicSpace pour votre UWP CoreWindow ou Win32 HWND, holographicSpace peut gérer des caméras holographiques, créer des systèmes de coordonnées et effectuer un rendu holographique. L’espace holographique actuel est utilisé à plusieurs emplacements dans le modèle DirectX :

• La classe DeviceResources doit obtenir des informations à partir de l’objet HolographicSpace pour créer l’appareil Direct3D. Il s’agit de l’ID d’adaptateur DXGI associé à l’affichage holographique. La classe HolographicSpace utilise l’appareil Direct3D 11 de votre application pour créer et gérer des ressources basées sur des appareils, telles que les mémoires tampons arrière pour chaque caméra holographique. Si vous souhaitez voir ce que fait cette fonction sous le capot, vous le trouverez dans DeviceResources.cpp.
• La fonction DeviceResources ::InitializeUsingHolographicSpace montre comment obtenir l’adaptateur en recherchant luiD et en choisissant un adaptateur par défaut lorsqu’aucun adaptateur préféré n’est spécifié.
• La classe principale de l’application utilise l’espace holographique d’AppView ::SetWindow ou App ::CreateWindowAndHolographicSpace pour les mises à jour et le rendu.

Ensuite, nous allons examiner le processus d’installation pour lequel SetHolographicSpace est responsable de la classe AppMain.

S’abonner aux événements de caméra, créer et supprimer des ressources de caméra

Le contenu holographique de votre application réside dans son espace holographique et est affiché via une ou plusieurs caméras holographiques, qui représentent différentes perspectives sur la scène. Maintenant que vous disposez de l’espace holographique, vous pouvez recevoir des données pour les caméras holographiques.

Votre application doit répondre aux événements CameraAdded en créant toutes les ressources spécifiques à cette caméra. Par exemple, une telle ressource est votre vue cible de rendu de la mémoire tampon back-tampon. Vous pouvez voir ce code dans la fonction DeviceResources ::SetHolographicSpace , appelée par AppView ::SetWindow avant que l’application crée des images holographiques :

m_cameraAddedToken = m_holographicSpace.CameraAdded(
    std::bind(&AppMain::OnCameraAdded, this, _1, _2));

Votre application doit également répondre aux événements CameraRemoved en libérant les ressources créées pour cette caméra.

À partir de DeviceResources ::SetHolographicSpace :

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

Les gestionnaires d’événements doivent effectuer un certain travail pour maintenir le rendu holographique fluide et le rendu de votre application. Lisez le code et les commentaires des détails : vous pouvez rechercher OnCameraAdded et OnCameraRemoved dans votre classe principale pour comprendre comment la carte m_cameraResources est gérée par DeviceResources.

À l’heure actuelle, nous nous concentrons sur AppMain et la configuration qu’elle effectue pour permettre à votre application de connaître les caméras holographiques. À l’esprit, il est important de prendre note des deux exigences suivantes :

1. Pour le gestionnaire d’événements CameraAdded , l’application peut fonctionner de manière asynchrone pour terminer la création de ressources et le chargement des ressources pour la nouvelle caméra holographique. Les applications qui prennent plusieurs images pour terminer ce travail doivent demander un report et terminer le report après le chargement asynchrone. Une tâche PPL peut être utilisée pour effectuer un travail asynchrone. Votre application doit s’assurer qu’elle est prête à être rendue à cette caméra immédiatement lorsqu’elle quitte le gestionnaire d’événements ou lorsqu’elle termine le report. Quitter le gestionnaire d’événements ou terminer le report indique au système que votre application est maintenant prête à recevoir des images holographiques avec cette caméra incluse.

2. Lorsque l’application reçoit un événement CameraRemoved , elle doit libérer toutes les références à la mémoire tampon back et quitter la fonction immédiatement. Cela inclut les affichages cibles de rendu et toute autre ressource qui peut contenir une référence à IDXGIResource. L’application doit également s’assurer que la mémoire tampon de retour n’est pas attachée en tant que cible de rendu, comme indiqué dans CameraResources ::ReleaseResourcesForBackBuffer. Pour accélérer les choses, votre application peut libérer la mémoire tampon arrière, puis lancer une tâche pour terminer de manière asynchrone tout autre travail de destruction pour la caméra. Le modèle d’application holographique inclut une tâche PPL que vous pouvez utiliser à cet effet.

Créer une trame de référence pour votre contenu holographique

Le contenu de votre application doit être positionné dans un système de coordonnées spatiales à afficher dans HolographicSpace. Le système fournit deux images de référence principales, que vous pouvez utiliser pour établir un système de coordonnées pour vos hologrammes.

Il existe deux types de trames de référence dans Windows Holographic : les images de référence attachées à l’appareil et les images de référence qui restent stationnaires lorsque l’appareil passe par l’environnement de l’utilisateur. Le modèle d’application holographique utilise par défaut une trame de référence stationnaire ; il s’agit de l’une des façons les plus simples de restituer des hologrammes verrouillés dans le monde.

Les trames de référence stationnaires sont conçues pour stabiliser les positions près de l’emplacement actuel de l’appareil. Cela signifie que les coordonnées supplémentaires de l’appareil peuvent dériver légèrement par rapport à l’environnement de l’utilisateur, car l’appareil en apprend davantage sur l’espace autour de celui-ci. Il existe deux façons de créer une trame stationnaire de référence : acquérir le système de coordonnées à partir de l’étape spatiale ou utiliser le SpatialLocator par défaut. Si vous créez une application Windows Mixed Reality pour les casques immersifs, le point de départ recommandé est l’étape spatiale. L’étape spatiale fournit également des informations sur les fonctionnalités du casque immersif porté par le joueur. Ici, nous montrons comment utiliser le SpatialLocator par défaut.

Le localisateur spatial représente l’appareil Windows Mixed Reality et suit le mouvement de l’appareil et fournit des systèmes de coordonnées qui peuvent être compris par rapport à son emplacement.

À partir d’AppMain  ::OnHolographicDisplayIsAvailableChanged :

spatialLocator = SpatialLocator::GetDefault();

Créez le cadre de référence stationnaire une fois que l’application est lancée. Cela est analogue à la définition d’un système de coordonnées mondial, avec l’origine placée à la position de l’appareil lors du lancement de l’application. Cette trame de référence ne se déplace pas avec l’appareil.

À partir d’AppMain  ::SetHolographicSpace :

m_stationaryReferenceFrame =
    m_spatialLocator.CreateStationaryFrameOfReferenceAtCurrentLocation();

Toutes les trames de référence sont alignées sur la gravité, ce qui signifie que l’axe y pointe « vers le haut » par rapport à l’environnement de l’utilisateur. Étant donné que Windows utilise des systèmes de coordonnées « droitier », la direction de l’axe –z coïncide avec la direction « vers l’avant » que l’appareil est confronté lorsque le cadre de référence est créé.

Répondre aux événements modifiés de locatabilité

Le rendu des hologrammes verrouillés dans le monde nécessite que l’appareil se trouve dans le monde. Cela peut ne pas toujours être possible en raison de conditions environnementales et, le cas échéant, l’utilisateur peut s’attendre à une indication visuelle de l’interruption de suivi. Cette indication visuelle doit être rendue à l’aide de trames de référence attachées à l’appareil, au lieu de stationnaires au monde.

Votre application peut demander d’être avertie si le suivi est interrompu pour une raison quelconque. Inscrivez-vous à l’événement LocatabilityChanged pour détecter quand la capacité de l’appareil à se localiser dans le monde change. À partir d’AppMain  ::SetHolographicSpace :

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

Utilisez ensuite cet événement pour déterminer quand les hologrammes ne peuvent pas être rendus stationnaires au monde.

Voir aussi

• Rendu dans DirectX
• Systèmes de coordonnées dans DirectX