Partager via

Vue d’ensemble des ressources

  • Article

Une ressource Direct2D est un objet utilisé pour le dessin et représenté par une interface Direct2D, telle que ID2D1Geometry ou ID2D1RenderTarget. Cette rubrique décrit les types de ressources Direct2D et la façon dont elles peuvent être partagées.

Cette rubrique contient les sections suivantes :

À propos des ressources Direct2D

De nombreuses API 2D à accélération matérielle sont conçues autour d’un modèle de ressources axé sur le processeur et d’un ensemble d’opérations de rendu qui fonctionnent bien sur les processeurs. Ensuite, une partie de l’API est accélérée matériellement. L’implémentation de ces API nécessite un gestionnaire de ressources pour mapper les ressources du processeur à des ressources sur le GPU. En raison des limitations gpu, certaines opérations peuvent ne pas être accélérées en toutes circonstances. Dans ce cas, le gestionnaire de ressources doit communiquer entre le processeur et le GPU (ce qui est coûteux) afin qu’il puisse passer au rendu du processeur. Dans certains cas, cela peut forcer de façon imprévisible le rendu à revenir complètement à l’UC. En outre, les opérations de rendu qui semblent simples peuvent nécessiter des étapes de rendu intermédiaires temporaires qui ne sont pas exposées dans l’API et qui nécessitent des ressources GPU supplémentaires.

Direct2D fournit un mappage plus direct pour utiliser pleinement le GPU. Il fournit deux catégories de ressources : indépendantes de l’appareil et dépendantes de l’appareil.

  • Les ressources indépendantes de l’appareil, telles que ID2D1Geometry, sont conservées sur le processeur.
  • Les ressources dépendantes de l’appareil, telles que ID2D1RenderTarget et ID2D1LinearGradientBrush, correspondent directement aux ressources sur le GPU (lorsque l’accélération matérielle est disponible). Les appels de rendu sont effectués en combinant les informations de vertex et de couverture d’une géométrie avec des informations de texturation produites par les ressources dépendantes de l’appareil.

Lorsque vous créez des ressources dépendantes de l’appareil, les ressources système (le GPU, le cas échéant, ou l’UC) sont allouées lors de la création de l’appareil et ne changent pas d’une opération de rendu à une autre. Cette situation élimine le besoin d’un gestionnaire de ressources. Outre les améliorations générales des performances fournies par l’élimination d’un gestionnaire de ressources, ce modèle vous permet de contrôler directement tout rendu intermédiaire.

Étant donné que Direct2D offre un tel contrôle sur les ressources, vous devez comprendre les différents types de ressources et quand elles peuvent être utilisées ensemble.

ressources Device-Independent

Comme décrit dans la section précédente, les ressources indépendantes de l’appareil résident toujours sur le processeur et ne sont jamais associées à un appareil de rendu matériel. Les ressources indépendantes de l’appareil sont les suivantes :

Utilisez un ID2D1Factory, lui-même une ressource indépendante de l’appareil, pour créer des ressources indépendantes de l’appareil. (Pour créer une fabrique, utilisez la fonction CreateFactory .)

À l’exception des cibles de rendu, toutes les ressources créées par une fabrique sont indépendantes de l’appareil. Une cible de rendu est une ressource dépendante de l’appareil.

ressources Device-Dependent

Toute ressource qui n’est pas nommée dans la liste précédente est une ressource dépendante de l’appareil. Les ressources dépendantes de l’appareil sont associées à un appareil de rendu particulier. Lorsque l’accélération matérielle est disponible, cet appareil est le GPU. Dans d’autres cas, il s’agit du processeur.

Pour créer la plupart des ressources dépendantes de l’appareil, utilisez une cible de rendu. Dans la plupart des cas, utilisez une fabrique pour créer une cible de rendu.

Voici des exemples de ressources dépendantes de l’appareil :

  • ID2D1Brush et les interfaces qui en héritent. Utilisez une cible de rendu pour créer des pinceaux.
  • ID2D1Layer. Utilisez une cible de rendu pour créer des couches.
  • ID2D1RenderTarget et les interfaces qui en héritent. Pour créer une cible de rendu, utilisez une fabrique ou une autre cible de rendu.

Notes

À compter de Windows 8, de nouvelles interfaces créent des ressources dépendantes de l’appareil. Un ID2D1Device et un ID2D1DeviceContext peuvent partager une ressource si le contexte de l’appareil et la ressource sont créés à partir du même ID2D1Device.

 

Les ressources dépendantes de l’appareil deviennent inutilisables lorsque les appareils de rendu associés deviennent indisponibles. Cela signifie que lorsque vous recevez l’erreur D2DERR_RECREATE_TARGET pour une cible de rendu, vous devez recréer la cible de rendu et toutes ses ressources.

Partage des ressources d’usine

Vous pouvez partager toutes les ressources indépendantes de l’appareil créées par une fabrique avec toutes les autres ressources (indépendantes de l’appareil ou dépendantes de l’appareil) créées par la même fabrique. Par exemple, vous pouvez utiliser deux objets ID2D1RenderTarget pour dessiner le même ID2D1RectangleGeometry si ces deux objets ID2D1RenderTarget ont été créés par la même fabrique.

Les interfaces de récepteur (ID2D1SimplifiedGeometrySink, ID2D1GeometrySink et ID2D1TessellationSink) peuvent être partagées avec des ressources créées par n’importe quelle fabrique. Contrairement à d’autres interfaces dans Direct2D, toute implémentation d’une interface récepteur peut être utilisée. Par exemple, vous pouvez utiliser votre propre implémentation de ID2D1SimplifiedGeometrySink.

Partage des ressources de la cible de rendu

Votre capacité à partager des ressources créées par une cible de rendu dépend du type de cible de rendu. Lorsque vous créez une cible de rendu de type D2D1_RENDER_TARGET_TYPE_DEFAULT, les ressources créées par cette cible de rendu ne peuvent être utilisées que par cette cible de rendu (sauf si la cible de rendu correspond à l’une des catégories décrites dans les sections suivantes). Cela se produit parce que vous ne savez pas quel appareil la cible de rendu finira par utiliser. Elle peut finir par être rendue sur le matériel local, les logiciels ou le matériel d’un client distant. Par exemple, vous pouvez écrire un programme qui cesse de fonctionner lorsqu’il est affiché à distance ou lorsque la taille de la cible de rendu dépasse la taille maximale prise en charge par le matériel de rendu.

Les sections suivantes décrivent les circonstances dans lesquelles une ressource créée par une cible de rendu peut être partagée avec une autre cible de rendu.

Cibles de rendu matérielles

Vous pouvez partager des ressources entre n’importe quelle cible de rendu qui utilise explicitement du matériel, tant que le mode de communication à distance est compatible. La compatibilité du mode de communication à distance n’est garantie que lorsque les deux cibles de rendu utilisent l’indicateur d’utilisation D2D1_RENDER_TARGET_USAGE_FORCE_BITMAP_REMOTING ou D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE , ou si aucun indicateur n’est spécifié. Ces paramètres garantissent que les ressources seront toujours situées sur le même ordinateur. Pour spécifier un mode d’utilisation, définissez le champ d’utilisation de la structure D2D1_RENDER_TARGET_PROPERTIES que vous avez utilisée pour créer la cible de rendu avec un ou plusieurs indicateurs D2D1_RENDER_TARGET_USAGE .

Pour créer une cible de rendu qui utilise explicitement le rendu matériel, définissez le champ de type de la structure D2D1_RENDER_TARGET_PROPERTIES que vous avez utilisée pour créer la cible de rendu sur D2D1_RENDER_TARGET_TYPE_HARDWARE.

Cibles de rendu surface DXGI

Vous pouvez partager des ressources créées par une cible de rendu de surface DXGI avec n’importe quelle autre cible de rendu de surface DXGI qui utilise le même appareil Direct3D sous-jacent.

Cibles de rendu compatibles et bitmaps partagées

Vous pouvez partager des ressources entre une cible de rendu et des cibles de rendu compatibles créées par cette cible de rendu. Pour créer une cible de rendu compatible, utilisez la méthode ID2D1RenderTarget::CreateCompatibleRenderTarget .

Vous pouvez utiliser la méthode ID2D1RenderTarget::CreateSharedBitmap pour créer un ID2D1Bitmap qui peut être partagé entre les deux cibles de rendu spécifiées dans l’appel de méthode, si la méthode réussit. Cette méthode réussit tant que les deux cibles de rendu utilisent le même appareil sous-jacent pour le rendu.