Technologie interop DirectX et XAML (applications Windows Runtime en C++ avec DirectX)

Applies to Windows and Windows Phone

Avec la version Windows 8, vous pouvez désormais utiliser XAML (Extensible Application Markup Language) et Microsoft DirectX conjointement dans votre application du Windows Store. En combinant les langages XAML et DirectX, vous pouvez générer des infrastructures d’interface utilisateur flexibles qui interopèrent avec votre contenu DirectX, ce qui s’avère particulièrement utile dans le cas d’applications qui utilisent beaucoup de ressources graphiques. Cette rubrique décrit la structure d’une application du Windows Store qui utilise DirectX et identifie les types qu’il est important d’utiliser au moment de générer votre application du Windows Store pour la faire fonctionner avec DirectX.

Remarque  Les API DirectX n’étant pas définies en tant que types Windows Runtime, il est d’usage d’utiliser des extensions de composant Visual C++ (C++/CX) pour développer des composants d’application du Windows Store XAML qui interopèrent avec DirectX. De plus, vous pouvez créer une application du Windows Store en XAML et C# qui utilise DirectX, à condition d’inclure les appels DirectX dans un wrapper au sein d’un fichier de métadonnées Windows Runtime distincte.

XAML et DirectX

DirectX fournit deux bibliothèques complètes pour les graphismes 2D et 3D : Direct2D et Microsoft Direct3D. Bien que XAML assure une prise en charge des primitives et des effets 2D de base, nombreuses sont les applications, notamment de modélisation et de jeux, qui nécessitent une prise en charge de graphismes plus complexes. Pour celles-ci, vous pouvez utiliser Direct2D et Direct3D pour restituer tout ou partie des graphismes et utiliser XAML pour tout le reste.

Dans le scénario d’interopérabilité de XAML et DirectX, vous devez connaître les deux concepts suivants :

  • Les surfaces partagées sont des régions dimensionnées de l’affichage, définies par XAML, dans lesquelles vous pouvez dessiner indirectement à l’aide de DirectX en utilisant les types Windows::UI::Xaml::Media::Brush. Pour les surfaces partagées, vous ne contrôlez pas les appels à présentation des chaînes de permutation. Les mises à jour appliquées à une surface partagée sont synchronisées avec les mises à jour de l’infrastructure XAML.
  • La chaîne de permutation proprement dite. Celle-ci fournit la mémoire tampon d’arrière-plan du pipeline de rendu DirectX, la zone de mémoire présentée à l’affichage, une fois la cible de rendu complète.

Déterminez ce pour quoi vous utilisez DirectX. Voulez-vous l’utiliser pour composer ou animer un contrôle unique qui doit tenir dans les dimensions de la fenêtre d’affichage ? La surface composite créée peut-elle être masquée par d’autres surfaces ou par les bords de l’écran ? Contiendra-t-elle la sortie qui doit être rendue et contrôlée en temps réel, comme dans un jeu ?

Une fois que vous avez déterminé comment vous envisagez d’utiliser DirectX, utilisez l’un de ces types Windows Runtime pour incorporer le rendu DirectX dans votre application du Windows Store :

  • Si vous voulez composer une image statique ou dessiner une image complexe selon des intervalles basés sur des événements, dessinez sur une surface partagée avec Windows::UI::Xaml::Media::Imaging::SurfaceImageSource. Ce type gère une surface de dessin DirectX dimensionnée. En général, ce type est utilisé pour composer une image ou une texture sous forme d’image bitmap à afficher dans un document ou un élément d’interface. En revanche, il s’avère peu efficace dans un contexte d’interactivité en temps réel, comme les jeux élaborés. Cela s’explique par le fait que les mises à jour appliquées à un objet SurfaceImageSource sont synchronisées avec les mises à jour de l’interface utilisateur XAML, ce qui peut introduire un temps de latence dans la rétroaction visuelle à l’utilisateur avec, par exemple, une fréquence d’images fluctuante ou un sentiment de faible réactivité aux entrées en temps réel. Les mises à jour restent néanmoins suffisamment rapides pour les contrôles dynamiques ou les simulations de données.

    Les objets graphiques SurfaceImageSource peuvent être composés avec d’autres éléments d’interface XAML. Vous pouvez les transformer ou les projeter et l’infrastructure XAML respecte les valeurs d’opacité ou d’index-z.

  • Si l’image est plus grande que l’espace fourni par l’écran et si elle peut être recentrée ou zoomée par l’utilisateur, utilisez Windows::UI::Xaml::Media::Imaging::VirtualSurfaceImageSource. Ce type gère une surface de dessin DirectX dimensionnée de format supérieur à l’écran. Tout comme SurfaceImageSource, il s’avère utile pour composer dynamiquement une image ou un contrôle complexe. De même, à la manière de SurfaceImageSource, il s’avère peu efficace pour les jeux élaborés. Parmi les éléments XAML susceptibles d’utiliser un VirtualSurfaceImageSource, citons les contrôles de carte ou une visionneuse de documents volumineux et riches en images.

  • Si vous utilisez DirectX pour présenter des graphismes mis à jour en temps réel ou dans un contexte où les mises à jour doivent se produire à intervalles réguliers et avec peu de latence, utilisez la classe SwapChainPanel. Les graphismes seront ainsi actualisés sans être synchronisés avec le minuteur d’actualisation de l’infrastructure XAML. Ce type vous permet d’accéder directement à la chaîne de permutation du périphérique graphique (IDXGISwapChain1) et de disposer la couche XAML sur la cible de rendu. Ce type est tout indiqué pour les jeux et autres applications DirectX plein écran qui nécessitent une interface utilisateur XAML. Pour utiliser cette approche, vous devez bien connaître DirectX, notamment les technologies Microsoft DXGI (DirectX Graphics Infrastructure), Direct2D et Direct3D. Pour plus d’informations, voir Guide de programmation pour Direct3D 11.

SurfaceImageSource

SurfaceImageSource propose des surfaces partagées DirectX dans lesquelles il est possible de dessiner et compose les éléments de contenu de l’application.

Voici le processus de base de création et de mise à jour d’un objet SurfaceImageSource dans le code-behind :

  1. Définissez la taille de la surface partagée en passant la hauteur et la largeur au constructeur SurfaceImageSource. Vous pouvez également indiquer si la surface a besoin d’une prise en charge alpha (opacité).

    Par exemple :

    SurfaceImageSource^ surfaceImageSource = ref new SurfaceImageSource(400, 300);

  2. Obtenez un pointeur vers ISurfaceImageSourceNative. Effectuez un cast de l’objet SurfaceImageSource en tant qu’IInspectable (ou IUnknown), puis appelez QueryInterface dessus pour obtenir l’implémentation d’ISurfaceImageSourceNative sous-jacente. Les méthodes définies dans cette implémentation permettent de définir le périphérique et d’exécuter les opérations de dessin.

    
    
    Microsoft::WRL::ComPtr<ISurfaceImageSourceNative>	m_sisNative;
    // ...
    IInspectable* sisInspectable = (IInspectable*) reinterpret_cast<IInspectable*>(surfaceImageSource);
    sisInspectable->QueryInterface(__uuidof(ISurfaceImageSourceNative), (void **)&m_sisNative);
    	
    
    
  3. Définissez le périphérique DXGI en appelant d’abord D3D11CreateDevice, puis en passant le périphérique et le contexte à ISurfaceImageSourceNative::SetDevice. Par exemple :

    
    
    Microsoft::WRL::ComPtr<ID3D11Device>				m_d3dDevice;
    Microsoft::WRL::ComPtr<ID3D11DeviceContext>			m_d3dContext;
    // ...
    D3D11CreateDevice(
    		NULL,
    		D3D_DRIVER_TYPE_HARDWARE,
    		NULL,
    		flags,
    		featureLevels,
    		ARRAYSIZE(featureLevels),
    		D3D11_SDK_VERSION,
    		&m_d3dDevice,
    		NULL,
    		&m_d3dContext
    		)
    	);	
    Microsoft::WRL::ComPtr<IDXGIDevice> dxgiDevice;
    m_d3dDevice.As(&dxgiDevice);
    // ...
    m_sisNative->SetDevice(dxgiDevice.Get());
    
    
  4. Fournissez un pointeur vers l’objet IDXGISurface à ISurfaceImageSourceNative::BeginDraw et dessinez dans cette surface à l’aide de DirectX. Seule est dessinée la zone désignée pour la mise à jour dans le paramètre updateRect.

    Remarque  Vous pouvez avoir une seule opération BeginDraw en attente active à la fois par IDXGIDevice.

    Cette méthode retourne le décalage de points (x,y) du rectangle cible mis à jour dans le paramètre offset. Ce décalage permet de déterminer où dessiner à l’intérieur de l’objet IDXGISurface.

    
    ComPtr<IDXGISurface> surface;
    
    HRESULT beginDrawHR = m_sisNative->BeginDraw(updateRect, &surface, &offset);
    if (beginDrawHR == DXGI_ERROR_DEVICE_REMOVED || beginDrawHR == DXGI_ERROR_DEVICE_RESET)
    {
    		  // device changed
    }
    else
    {
        // draw to IDXGISurface (the surface paramater)
    }
    
    
    
  5. Appelez ISurfaceImageSourceNative::EndDraw pour compléter l’image bitmap. Passez cette image bitmap à un ImageBrush.

    
    m_sisNative->EndDraw();
    // ...
    // The SurfaceImageSource object's underlying ISurfaceImageSourceNative object contains the completed bitmap.
    ImageBrush^ brush = ref new ImageBrush();
    brush->ImageSource = surfaceImageSource;
    
    
    
  6. Utilisez ImageBrush pour dessiner l’image bitmap.

Remarque  L’appel de SurfaceImageSource::SetSource (hérité de IBitmapSource::SetSource) lève actuellement une exception. Ne l’appelez pas à partir de votre objet SurfaceImageSource.

VirtualSurfaceImageSource

VirtualSurfaceImageSource étend SurfaceImageSource lorsque le contenu est potentiellement plus volumineux pour l’écran et donc que le contenu doit être virtualisé pour un rendu optimal.

VirtualSurfaceImageSource est différent de SurfaceImageSource dans le sens où il utilise un rappel, IVirtualSurfaceImageSourceCallbacksNative::UpdatesNeeded, que vous implémentez pour mettre à jour des régions de la surface à mesure qu’elles s’affichent à l’écran. Vous n’avez pas besoin d’effacer les régions masquées, car l’infrastructure XAML s’en charge à votre place.

Voici le processus de base de création et de mise à jour d’un objet VirtualSurfaceImageSource dans le code-behind :

  1. Créez une instance de VirtualSurfaceImageSource avec la taille que vous voulez. Par exemple :

    VirtualSurfaceImageSource^ virtualSIS = ref new VirtualSurfaceImageSource(2000, 2000);

  2. Obtenez un pointeur vers IVirtualSurfaceImageSourceNative. Effectuez un cast de l’objet VirtualSurfaceImageSource en tant qu’IInspectable ou IUnknown, puis appelez QueryInterface dessus pour obtenir l’implémentation d’IVirtualSurfaceImageSourceNative sous-jacente. Les méthodes définies dans cette implémentation permettent de définir le périphérique et d’exécuter les opérations de dessin.

    
    
    Microsoft::WRL::ComPtr<IVirtualSurfaceImageSourceNative>	m_vsisNative;
    // ...
    IInspectable* vsisInspectable = (IInspectable*) reinterpret_cast<IInspectable*>(virtualSIS);
    vsisInspectable->QueryInterface(__uuidof(IVirtualSurfaceImageSourceNative), (void **)&m_vsisNative);
    	
    
    
  3. Définissez le périphérique DXGI en appelant IVirtualSurfaceImageSourceNative::SetDevice. Par exemple :

    
    
    Microsoft::WRL::ComPtr<ID3D11Device>				m_d3dDevice;
    Microsoft::WRL::ComPtr<ID3D11DeviceContext>			m_d3dContext;
    // ...
    D3D11CreateDevice(
    		NULL,
    		D3D_DRIVER_TYPE_HARDWARE,
    		NULL,
    		flags,
    		featureLevels,
    		ARRAYSIZE(featureLevels),
    		D3D11_SDK_VERSION,
    		&m_d3dDevice,
    		NULL,
    		&m_d3dContext
    		)
    	);	
    Microsoft::WRL::ComPtr<IDXGIDevice> dxgiDevice;
    m_d3dDevice.As(&dxgiDevice);
    // ...
    m_vsisNative->SetDevice(dxgiDevice.Get());
    
    
  4. Appelez IVirtualSurfaceImageSourceNative::RegisterForUpdatesNeeded en passant une référence à votre implémentation de IVirtualSurfaceUpdatesCallbackNative.

    
    
    class MyContentImageSource : public IVirtualSurfaceUpdatesCallbackNative
    {
    // ...
      private:
         virtual HRESULT STDMETHODCALLTYPE UpdatesNeeded() override;
    }
    
    // ...
    
    HRESULT STDMETHODCALLTYPE MyContentImageSource::UpdatesNeeded()
    {
      // .. perform drawing here ...
    }
    void MyContentImageSource::Initialize()
    {
      // ...
      m_vsisNative->RegisterForUpdatesNeeded(this);
      // ...
    }
    
    
    

    L’infrastructure appelle votre implémentation de IVirtualSurfaceUpdatesCallbackNative::UpdatesNeeded lorsqu’une région de VirtualSurfaceImageSource doit être mise à jour.

    Cela se produit lorsque l’infrastructure détermine que la région doit être dessinée (par exemple, lorsque l’utilisateur recentre ou zoome la vue de la surface) ou après que l’application a appelé IVirtualSurfaceImageSourceNative::Invalidate sur cette région.

  5. Dans IVirtualSurfaceImageSourceNative::UpdatesNeeded, utilisez les méthodes IVirtualSurfaceImageSourceNative::GetUpdateRectCount et IVirtualSurfaceImageSourceNative::GetUpdateRects pour déterminer la ou les régions de la surface à dessiner.

    
    
    
    
    HRESULT STDMETHODCALLTYPE MyContentImageSource::UpdatesNeeded()
    {
        HRESULT hr = S_OK;
    
        try
        {
            ULONG drawingBoundsCount = 0;  
    
    		      m_vsisNative->GetUpdateRectCount(&drawingBoundsCount);
            std::unique_ptr<RECT[]> drawingBounds(new RECT[drawingBoundsCount]);
            m_vsisNative->GetUpdateRects(drawingBounds.get(), drawingBoundsCount);
            
            for (ULONG i = 0; i < drawingBoundsCount; ++i)
            {
                // Drawing code here ...
            }
        }
        catch (Platform::Exception^ exception)
        {
            hr = exception->HResult;
        }
    
        return hr;
    }
    
    
  6. Enfin, pour chaque région à mettre à jour :

    1. Fournissez un pointeur vers l’objet IDXGISurface à IVirtualSurfaceImageSourceNative::BeginDraw et dessinez dans cette surface à l’aide de DirectX. Seule sera dessinée la zone désignée pour la mise à jour dans le paramètre updateRect.

      Comme dans le cas de la méthode IlSurfaceImageSourceNative::BeginDraw, cette méthode retourne le décalage de points (x,y) du rectangle cible mis à jour dans le paramètre offset. Ce décalage permet de déterminer où dessiner à l’intérieur de l’objet IDXGISurface.

      Remarque  Vous pouvez avoir une seule opération BeginDraw en attente active à la fois par IDXGIDevice.

      
      ComPtr<IDXGISurface> bigSurface;
      
      HRESULT beginDrawHR = m_vsisNative->BeginDraw(updateRect, &bigSurface, &offset);
      if (beginDrawHR == DXGI_ERROR_DEVICE_REMOVED || beginDrawHR == DXGI_ERROR_DEVICE_RESET)
      {
      		  // device changed
      }
      else
      {
          // draw to IDXGISurface
      }
      
      
      
    2. Dessinez le contenu spécifique dans cette région mais, pour des performances optimales, laissez votre dessin dans les limites de la région.

    3. Appelez IVirtualSurfaceImageSourceNative::EndDraw. Le résultat est une image bitmap.

SwapChainPanel et jeux

SwapChainPanel est le type Windows Runtime conçu pour prendre en charge les graphismes et les jeux élaborés, où vous gérez directement la chaîne de permutation. Dans ce cas, vous créez votre propre chaîne de permutation DirectX et gérez la présentation de votre contenu rendu. Vous pouvez ensuite ajouter des éléments XAML à l’objet SwapChainPanel, tels que des menus, des affichages tête haute et autres superpositions d’interface.

Pour garantir les performances, le type SwapChainPanel impose certaines limitations :

  • Le nombre maximal d’instances de SwapChainPanel est de 4.
  • Les propriétés Opacity, RenderTransform, Projection et Clip héritées par SwapChainPanel ne sont pas prises en charge.
  • Vous devez attribuer à la chaîne de permutation DirectX une hauteur et une largeur (dans DXGI_SWAP_CHAIN_DESC1) correspondant aux dimensions actuelles de la fenêtre d’application. À défaut, le contenu à afficher est mis à l’échelle (à l’aide de DXGI_SCALING_STRETCH).
  • Vous devez affecter au mode d’ajustement de la chaîne de permutation DirectX (dans DXGI_SWAP_CHAIN_DESC1) la valeur DXGI_SCALING_STRETCH.
  • Vous ne pouvez pas affecter au mode alpha de la chaîne de permutation DirectX (dans DXGI_SWAP_CHAIN_DESC1) la valeur DXGI_ALPHA_MODE_PREMULTIPLIED.
  • Vous devez créer la chaîne de permutation DirectX en appelant IDXGIFactory2::CreateSwapChainForComposition.

Vous mettez à jour SwapChainPanel en fonction des besoins de votre application et non des mises à jour de l’infrastructure XAML. Si vous avez besoin de synchroniser les mises à jour de SwapChainPanel avec celles de l’infrastructure XAML, inscrivez-vous à l’événement Windows::UI::Xaml::Media::CompositionTarget::Rendering. Sinon, vous devez prévoir des problèmes inter-threads si vous essayez de mettre à jour les éléments XAML à partir d’un thread différent de celui qui met à jour SwapChainPanel.

Il existe par ailleurs des recommandations générales à suivre au moment de concevoir votre application pour qu’elle utilise SwapChainPanel.

  • SwapChainPanel hérite de Windows::UI::Xaml::Controls::Grid et prend en charge un comportement de mise en page similaire. Familiarisez-vous avec le type Grid et ses propriétés.

  • Une fois qu’une chaîne de permutation DirectX a été définie, tous les événements d’entrée déclenchés pour SwapChainPanel opèrent de la même manière que pour tout autre élément XAML. Vous ne définissez pas de pinceau d’arrière-plan pour SwapChainPanel et vous n’avez pas besoin de gérer directement les événements d’entrée de l’objet CoreWindow de l’application comme c’est le cas dans les applications DirectX qui n’utilisent pas SwapChainPanel.

  • • L’ensemble du contenu de l’arborescence visuelle d’éléments XAML située sous un enfant direct d’un SwapChainPanel est découpé à la taille de disposition de l’enfant immédiat de l’objet SwapChainPanel. Tout contenu transformé en dehors de ces limites de disposition n’est pas restitué. Par conséquent, placez le contenu XAML que vous animez à l’aide d’un élément Storyboard XAML dans l’arborescence visuelle située sous un élément dont les limites de disposition sont suffisamment étendues pour accueillir l’animation dans son ensemble.

  • Limitez le nombre d’éléments XAML visuels immédiats situés sous un SwapChainPanel. Si possible, regroupez les éléments qui se trouvent très près les uns des autres sous un parent commun. Mais vous devez trouver un compromis entre le nombre d’enfants visuels immédiats et la taille des enfants. En effet, les performances globales peuvent pâtir de la présence d’éléments XAML trop nombreux ou inutilement grands. De même, ne créez pas d’élément XAML enfant unique en plein écran pour le SwapChainPanel de votre application, car cela accroît l’« overdraw » dans l’application et nuit aux performances. En règle générale, ne créez pas plus de 8 enfants visuels XAML immédiats pour le SwapChainPanel de votre application et attribuez à chaque élément une taille de disposition juste nécessaire pour accueillir le contenu visuel de l’élément. Toutefois, l’arborescence visuelle d’éléments située sous un élément enfant du SwapChainPanel peut être suffisamment complexe sans pour autant grever lourdement les performances.

Remarque   En règle générale, vos applications DirectX doivent créer des chaînes de permutation dans l’orientation paysage et égales à la taille de la fenêtre d’affichage (qui correspond habituellement à la résolution d’écran native dans la plupart des jeux Windows Store). Cela garantit que votre application utilise l’implémentation de chaîne de permutation optimale lorsqu’elle ne possède aucune superposition XAML visible. Si l’application est pivotée en mode portrait, elle doit appeler IDXGISwapChain1::SetRotation sur la chaîne de permutation existante, appliquer une transformation au contenu, si nécessaire, puis appeler de nouveau SetSwapChain sur la même chaîne de permutation. De même, votre application doit appeler de nouveau SetSwapChain sur la même chaîne de permutation chaque fois que celle-ci est redimensionnée à la suite d’un appel de IDXGISwapChain::ResizeBuffers.

Voici le processus de base de création et de mise à jour d’un objet SwapChainPanel dans le code-behind :

  1. Obtenez une instance d’un panneau de chaîne de permutation pour votre application. Les instances sont indiquées dans votre code XAML par la balise <SwapChainPanel>.

    Windows::UI::Xaml::Controls::SwapChainPanel^ swapChainPanel;

    Voici un exemple de balise <SwapChainPanel>.

    
    <SwapChainPanel x:Name="swapChainPanel">
        <SwapChainPanel.ColumnDefinitions>
            <ColumnDefinition Width="300*"/>
            <ColumnDefinition Width="1069*"/>
        </SwapChainPanel.ColumnDefinitions></SwapChainPanel>
    
    
    
  2. Obtenez un pointeur vers ISwapChainPanelNative. Effectuez un cast de l’objet SwapChainPanel en tant qu’IInspectable (ou IUnknown), puis appelez QueryInterface dessus pour obtenir l’implémentation d’ISwapChainPanelNative sous-jacente.

    
    
    Microsoft::WRL::ComPtr<ISwapChainPanelNative>	m_swapChainNative;
    // ...
    IInspectable* panelInspectable = (IInspectable*) reinterpret_cast<IInspectable*>(swapChainPanel);
    panelInspectable->QueryInterface(__uuidof(ISwapChainPanelNative), (void **)&m_swapChainNative);
    	
    
    
  3. Créez le périphérique DXGI et la chaîne de permutation et attribuez à cette dernière la valeur ISwapChainPanelNative en la passant à SetSwapChain.

    
    
    Microsoft::WRL::ComPtr<IDXGISwapChain1>				m_swapChain;	
    // ...
    DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {0};
            swapChainDesc.Width = m_bounds.Width;
            swapChainDesc.Height = m_bounds.Height;
            swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;           // this is the most common swapchain format
            swapChainDesc.Stereo = false; 
            swapChainDesc.SampleDesc.Count = 1;                          // don't use multi-sampling
            swapChainDesc.SampleDesc.Quality = 0;
            swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
            swapChainDesc.BufferCount = 2;
            swapChainDesc.Scaling = DXGI_SCALING_STRETCH;
            swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; // we recommend using this swap effect for all applications
            swapChainDesc.Flags = 0;
            		
    // QI for DXGI device
    Microsoft::WRL::ComPtr<IDXGIDevice> dxgiDevice;
    m_d3dDevice.As(&dxgiDevice);
    
    // get the DXGI adapter
    Microsoft::WRL::ComPtr<IDXGIAdapter> dxgiAdapter;
    dxgiDevice->GetAdapter(&dxgiAdapter);
    
    // get the DXGI factory
    Microsoft::WRL::ComPtr<IDXGIFactory2> dxgiFactory;
    dxgiAdapter->GetParent(__uuidof(IDXGIFactory2), &dxgiFactory);
    // create swap chain by calling CreateSwapChainForComposition
    dxgiFactory->CreateSwapChainForComposition(
                m_d3dDevice.Get(),
                &swapChainDesc,
                nullptr,		// allow on any display 
                &m_swapChain
                );
    		
    m_swapChainNative->SetSwapChain(m_swapChain.Get());
    
    
  4. Dessinez sur la chaîne de permutation DirectX et présentez-la pour afficher le contenu.

    
    HRESULT hr = m_swapChain->Present(1, 0);
    
    

    Les éléments XAML sont actualisés lorsque la logique de disposition/rendu de Windows Runtime signale une mise à jour.

Rubriques associées

SurfaceImageSource
VirtualSurfaceImageSource
SwapChainPanel
ISwapChainPanelNative
Guide de programmation pour Direct3D 11
Exemples SwapChainPanel
Exemple interop DirectX XAML SwapChainPanel
Exemples SurfaceImageSource
Exemple interop DirectX XAML SurfaceImageSource
Exemple VirtualSurfaceImageSource
Exemple d’application de magazine Direct2D

 

 

Afficher:
© 2014 Microsoft