Rendre des cibles, des appareils et des ressources

  • Article

Une cible de rendu est simplement l’emplacement où votre programme dessinera. En règle générale, la cible de rendu est une fenêtre (plus précisément, la zone cliente de la fenêtre). Il peut également s’agir d’une bitmap en mémoire qui n’est pas affichée. Une cible de rendu est représentée par l’interface ID2D1RenderTarget .

Un appareil est une abstraction qui représente ce qui dessine réellement les pixels. Un appareil matériel utilise le GPU pour des performances plus rapides, tandis qu’un appareil logiciel utilise le processeur. L’application ne crée pas l’appareil. Au lieu de cela, l’appareil est créé implicitement lorsque l’application crée la cible de rendu. Chaque cible de rendu est associée à un appareil particulier, matériel ou logiciel.

diagramme qui montre la relation entre une cible de rendu et un appareil.

Une ressource est un objet que le programme utilise pour dessiner. Voici quelques exemples de ressources définies dans Direct2D :

  • Pinceau. Contrôle la façon dont les lignes et les régions sont peintes. Les types de pinceaux incluent les pinceaux de couleur unie et les pinceaux dégradés.
  • Style de trait. Contrôle l’apparence d’une ligne, par exemple, pointillée ou pleine.
  • Géométrie. Représente une collection de lignes et de courbes.
  • Maillage. Forme formée de triangles. Les données de maillage peuvent être consommées directement par le GPU, contrairement aux données geometry, qui doivent être converties avant le rendu.

Les cibles de rendu sont également considérées comme un type de ressource.

Certaines ressources bénéficient de l’accélération matérielle. Une ressource de ce type est toujours associée à un appareil particulier, matériel (GPU) ou logiciel (UC). Ce type de ressource est appelé dépendant de l’appareil. Les pinceaux et les maillages sont des exemples de ressources dépendantes de l’appareil. Si l’appareil devient indisponible, la ressource doit être recréé pour un nouvel appareil.

Les autres ressources sont conservées dans la mémoire du processeur, quel que soit l’appareil utilisé. Ces ressources sont indépendantes de l’appareil, car elles ne sont pas associées à un appareil particulier. Il n’est pas nécessaire de recréer des ressources indépendantes de l’appareil lorsque l’appareil change. Les styles de traits et les géométries sont des ressources indépendantes de l’appareil.

La documentation MSDN de chaque ressource indique si la ressource dépend de l’appareil ou est indépendante de l’appareil. Chaque type de ressource est représenté par une interface qui dérive de ID2D1Resource. Par exemple, les pinceaux sont représentés par l’interface ID2D1Brush .

Objet De fabrique Direct2D

La première étape lors de l’utilisation de Direct2D consiste à créer un instance de l’objet de fabrique Direct2D. En programmation informatique, une fabrique est un objet qui crée d’autres objets. La fabrique Direct2D crée les types d’objets suivants :

  • Afficher les cibles.
  • Ressources indépendantes de l’appareil, telles que les styles de traits et les géométries.

Les ressources dépendantes de l’appareil, telles que les pinceaux et les bitmaps, sont créées par l’objet cible de rendu.

diagramme montrant la fabrique direct2d.

Pour créer l’objet de fabrique Direct2D, appelez la fonction D2D1CreateFactory .

ID2D1Factory *pFactory = NULL;

HRESULT hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &pFactory);

Le premier paramètre est un indicateur qui spécifie les options de création. L’indicateur D2D1_FACTORY_TYPE_SINGLE_THREADED signifie que vous n’appelez pas Direct2D à partir de plusieurs threads. Pour prendre en charge les appels de plusieurs threads, spécifiez D2D1_FACTORY_TYPE_MULTI_THREADED. Si votre programme utilise un thread unique pour appeler Direct2D, l’option à thread unique est plus efficace.

Le deuxième paramètre de la fonction D2D1CreateFactory reçoit un pointeur vers l’interface ID2D1Factory .

Vous devez créer l’objet de fabrique Direct2D avant le premier message WM_PAINT . Le gestionnaire de messages WM_CREATE est un bon endroit pour créer la fabrique :

    case WM_CREATE:
        if (FAILED(D2D1CreateFactory(
                D2D1_FACTORY_TYPE_SINGLE_THREADED, &pFactory)))
        {
            return -1;  // Fail CreateWindowEx.
        }
        return 0;

Création de ressources Direct2D

Le programme Circle utilise les ressources dépendantes de l’appareil suivantes :

  • Cible de rendu associée à la fenêtre d’application.
  • Pinceau unie pour peindre le cercle.

Chacune de ces ressources est représentée par une interface COM :

Le programme Circle stocke les pointeurs vers ces interfaces en tant que variables membres de la MainWindow classe :

ID2D1HwndRenderTarget   *pRenderTarget;
ID2D1SolidColorBrush    *pBrush;

Le code suivant crée ces deux ressources.

HRESULT MainWindow::CreateGraphicsResources()
{
    HRESULT hr = S_OK;
    if (pRenderTarget == NULL)
    {
        RECT rc;
        GetClientRect(m_hwnd, &rc);

        D2D1_SIZE_U size = D2D1::SizeU(rc.right, rc.bottom);

        hr = pFactory->CreateHwndRenderTarget(
            D2D1::RenderTargetProperties(),
            D2D1::HwndRenderTargetProperties(m_hwnd, size),
            &pRenderTarget);

        if (SUCCEEDED(hr))
        {
            const D2D1_COLOR_F color = D2D1::ColorF(1.0f, 1.0f, 0);
            hr = pRenderTarget->CreateSolidColorBrush(color, &pBrush);

            if (SUCCEEDED(hr))
            {
                CalculateLayout();
            }
        }
    }
    return hr;
}

Pour créer une cible de rendu pour une fenêtre, appelez la méthode ID2D1Factory::CreateHwndRenderTarget sur la fabrique Direct2D.

  • Le premier paramètre spécifie les options communes à tout type de cible de rendu. Ici, nous transmettons les options par défaut en appelant la fonction d’assistance D2D1::RenderTargetProperties.
  • Le deuxième paramètre spécifie le handle de la fenêtre plus la taille de la cible de rendu, en pixels.
  • Le troisième paramètre reçoit un pointeur ID2D1HwndRenderTarget .

Pour créer le pinceau uni, appelez la méthode ID2D1RenderTarget::CreateSolidColorBrush sur la cible de rendu. La couleur est donnée sous forme de valeur D2D1_COLOR_F . Pour plus d’informations sur les couleurs dans Direct2D, consultez Utilisation de la couleur dans Direct2D.

Notez également que si la cible de rendu existe déjà, la CreateGraphicsResources méthode retourne S_OK sans rien faire. La raison de cette conception sera claire dans la rubrique suivante.

Suivant

Dessiner avec Direct2D