Obtention d’un HolographicSpace

  • Article

Notes

Cet article concerne les API natives WinRT héritées. Pour les nouveaux projets d’application native, nous vous recommandons d’utiliser l’API OpenXR.

La classe HolographicSpace est votre portail dans le monde holographique. Il contrôle le rendu immersif, fournit des données de caméra et donne accès aux API de raisonnement spatial. Vous allez en créer 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 vue d’application. Cette chaîne d’échange s’affiche sur une ardoise dans l’interface utilisateur holographique. Pour que votre application affiche une vue holographique 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 plein écran.

Pour une application UWPà partir du modèle Application Holographic DirectX 11 (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, consultez App::CreateWindowAndHolographicSpace pour obtenir 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 l’appareil, telles que les mémoires tampons arrière pour chaque caméra holographique. Si vous souhaitez voir ce que cette fonction fait sous le capot, vous la trouverez dans DeviceResources.cpp.
  • La fonction DeviceResources::InitializeUsingHolographicSpace montre comment obtenir l’adaptateur en recherchant l’adaptateur LUID et comment choisir une carte par défaut lorsqu’aucun adaptateur préféré n’est spécifié.
  • La classe main de l’application utilise l’espace holographique de AppView::SetWindow ou App::CreateWindowAndHolographicSpace pour les mises à jour et le rendu.

Notes

Bien que les sections ci-dessous mention des noms de fonction à partir du modèle comme AppView::SetWindow qui supposent que vous avez commencé à partir du modèle d’application UWP holographique, les extraits de code que vous voyez s’appliquent également entre les applications UWP et Win32.

Ensuite, nous allons examiner le processus d’installation dont SetHolographicSpace est responsable dans la classe AppMain.

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

Le contenu holographique de votre application vit dans son espace holographique et est visualisé 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 des ressources spécifiques à cette caméra. Un exemple d’une telle ressource est votre vue cible de rendu de mémoire tampon arrière. Vous pouvez voir ce code dans la fonction DeviceResources::SetHolographicSpace , appelée par AppView::SetWindow avant que l’application ne 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 qui ont été 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 assurer le bon déroulement du rendu holographique et le rendu de votre application. Lisez le code et les commentaires pour plus d’informations : vous pouvez rechercher OnCameraAdded et OnCameraRemoved dans votre classe main 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’il effectue pour permettre à votre application de connaître les caméras holographiques. Dans cette optique, il est important de prendre note des deux exigences suivantes :

  1. Pour le gestionnaire d’événements CameraAdded , l’application peut travailler 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 effectuer ce travail doivent demander un report et effectuer 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 affichée sur cette caméra immédiatement lorsqu’elle quitte le gestionnaire d’événements ou lorsqu’elle termine le report. Le fait de quitter le gestionnaire d’événements ou d’effectuer 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 arrière et quitter la fonction immédiatement. Cela inclut les vues cibles de rendu et toute autre ressource qui peut contenir une référence à l’IDXGIResource. L’application doit également s’assurer que la mémoire tampon d’arrière-plan 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 effectuer de manière asynchrone tout autre travail de démontage pour l’appareil photo. Le modèle d’application holographique inclut une tâche PPL que vous pouvez utiliser à cet effet.

Notes

Si vous souhaitez déterminer quand une caméra ajoutée ou supprimée apparaît sur le cadre, utilisez les propriétés HolographicFrameAddedCameras et RemovedCameras .

Créer un cadre de référence pour votre contenu holographique

Le contenu de votre application doit être positionné dans un système de coordonnées spatiales pour être rendu 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 cadres de référence dans Windows Holographic : les cadres de référence attachés à l’appareil et les cadres de référence qui restent stationnaires lorsque l’appareil se déplace dans l’environnement de l’utilisateur. Le modèle d’application holographique utilise un cadre de référence fixe par défaut ; il s’agit de l’un des moyens les plus simples de restituer des hologrammes verrouillés dans le monde.

Les cadres de référence fixes sont conçus pour stabiliser les positions près de l’emplacement actuel de l’appareil. Cela signifie que les coordonnées plus loin de l’appareil peuvent dériver légèrement par rapport à l’environnement de l’utilisateur à mesure que l’appareil en apprend davantage sur l’espace qui l’entoure. Il existe deux façons de créer un cadre de référence fixe : 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. La phase spatiale fournit également des informations sur les capacité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, suit le mouvement de l’appareil et fournit des systèmes de coordonnées qui peuvent être compris par rapport à son emplacement.

À partir de AppMain::OnholographicDisplayIsAvailableChanged :

spatialLocator = SpatialLocator::GetDefault();

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

À partir d’AppMain::SetHolographicSpace :

m_stationaryReferenceFrame =
    m_spatialLocator.CreateStationaryFrameOfReferenceAtCurrentLocation();

Toutes les images 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 » de l’appareil lorsque le cadre de référence est créé.

Notes

Lorsque votre application nécessite un positionnement précis d’hologrammes individuels, utilisez un SpatialAnchor pour ancrer l’hologramme individuel à une position dans le monde réel. Par exemple, utilisez une ancre spatiale lorsque l’utilisateur indique qu’un point est particulièrement intéressant. Les positions d’ancre ne dérivent pas, mais elles peuvent être ajustées. Par défaut, lorsqu’une ancre est ajustée, elle facilite sa position sur les images suivantes après la correction. Selon votre application, lorsque cela se produit, vous pouvez gérer l’ajustement d’une autre manière (par exemple, en le reportant jusqu’à ce que l’hologramme soit hors vue). La propriété RawCoordinateSystem et les événements RawCoordinateSystemAdjusted permettent ces personnalisations.

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 si c’est le cas, l’utilisateur peut s’attendre à une indication visuelle de l’interruption du suivi. Cette indication visuelle doit être rendue à l’aide d’images de référence attachées à l’appareil, au lieu d’être stationnaires au monde.

Votre application peut demander à ê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