Partager via

Rendre des cibles, des appareils et des ressources

  • Article

Une cible de rendu est simplement l’emplacement où votre programme dessinera. Typiquement, la cible de rendu est une fenêtre (plus précisément, la zone cliente de la fenêtre). Il pourrait aussi 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 une performance plus rapide, tandis qu’un appareil logiciel utilise le CPU. 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, soit matériel soit logiciel.

un 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 :

  • Brush. Contrôle la façon dont les lignes et les régions sont peintes. Les types de pinceaux incluent des pinceaux de couleur unie et des pinceaux dégradés.
  • Stroke style. Contrôle l’apparence d’une ligne - par exemple, en pointillé ou en solide.
  • Geometry. Représente une collection de lignes et de courbes.
  • Mesh. Une forme à base de triangles. Les données de la maille peuvent être consommées directement par le GPU, contrairement aux données de géométrie, 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, soit matériel (GPU) soit logiciel (CPU). Ce type de ressource est appelé dépendante de l’appareil. Les pinceaux et les mailles sont des exemples de ressources dépendantes de l’appareil. Si l’appareil devient indisponible, la ressource doit être recréée pour un nouvel appareil.

D’autres ressources sont conservées dans la mémoire du CPU, 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 les ressources indépendantes de l’appareil lorsque l’appareil change. Les styles de trait et les géométries sont des ressources indépendantes de l’appareil.

La documentation de Windows pour chaque ressource indique si la ressource est dépendante ou 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ées par l’interface ID2D1Brush.

L’objet usine Direct2D

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

  • Cibles de rendu.
  • Ressources indépendantes de l’appareil, telles que les styles de trait 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.

un diagramme qui montre l’usine Direct2D.

Pour créer l’objet usine 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’appellerez 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 seul thread 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 devriez créer l’objet usine Direct2D avant le premier message WM_PAINT. Le gestionnaire de message WM_CREATE est un bon endroit pour créer l’usine :

    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 :

  • Une cible de rendu associée à la fenêtre de l’application.
  • Un pinceau de couleur 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 classe MainWindow :

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 l’usine Direct2D.

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

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

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

Next

Dessiner avec Direct2D