Dessiner avec Direct2D

Après avoir créé vos ressources graphiques, vous êtes prêt à dessiner.

Dessin d’une ellipse

Le programme Circle effectue une logique de dessin très simple :

1. Remplissez l’arrière-plan d’une couleur unie.
2. Dessinez un cercle rempli.

Étant donné que la cible de rendu est une fenêtre (par opposition à une bitmap ou à une autre surface hors écran), le dessin est effectué en réponse à WM_PAINT messages. Le code suivant montre la procédure de fenêtre pour le programme Circle.

LRESULT MainWindow::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
        case WM_PAINT:
            OnPaint();
            return 0;

         // Other messages not shown...
    }
    return DefWindowProc(m_hwnd, uMsg, wParam, lParam);
}

Voici le code qui dessine le cercle.

void MainWindow::OnPaint()
{
    HRESULT hr = CreateGraphicsResources();
    if (SUCCEEDED(hr))
    {
        PAINTSTRUCT ps;
        BeginPaint(m_hwnd, &ps);
     
        pRenderTarget->BeginDraw();

        pRenderTarget->Clear( D2D1::ColorF(D2D1::ColorF::SkyBlue) );
        pRenderTarget->FillEllipse(ellipse, pBrush);

        hr = pRenderTarget->EndDraw();
        if (FAILED(hr) || hr == D2DERR_RECREATE_TARGET)
        {
            DiscardGraphicsResources();
        }
        EndPaint(m_hwnd, &ps);
    }
}

L’interface ID2D1RenderTarget est utilisée pour toutes les opérations de dessin. La méthode du OnPaint programme effectue les opérations suivantes :

1. La méthode ID2D1RenderTarget::BeginDraw signale le début du dessin.
2. La méthode ID2D1RenderTarget::Clear remplit la cible de rendu entière avec une couleur unie. La couleur est donnée sous forme de structure D2D1_COLOR_F . Vous pouvez utiliser la classe D2D1::ColorF pour initialiser la structure. Pour plus d’informations, consultez Utilisation de la couleur dans Direct2D.
3. La méthode ID2D1RenderTarget::FillEllipse dessine une ellipse remplie, à l’aide du pinceau spécifié pour le remplissage. Une ellipse est spécifiée par un point central et les rayons x et y. Si les rayons x et y sont identiques, le résultat est un cercle.
4. La méthode ID2D1RenderTarget::EndDraw signale la fin du dessin pour ce cadre. Toutes les opérations de dessin doivent être placées entre les appels à BeginDraw et EndDraw.

Les méthodes BeginDraw, Clear et FillEllipse ont toutes un type de retour void . Si une erreur se produit pendant l’exécution de l’une de ces méthodes, l’erreur est signalée via la valeur de retour de la méthode EndDraw . La CreateGraphicsResources méthode est indiquée dans la rubrique Création de ressources Direct2D. Cette méthode crée la cible de rendu et le pinceau de couleur unie.

L’appareil peut mettre en mémoire tampon les commandes de dessin et différer leur exécution jusqu’à ce que EndDraw soit appelé. Vous pouvez forcer l’appareil à exécuter toutes les commandes de dessin en attente en appelant ID2D1RenderTarget::Flush. Toutefois, la vidage peut réduire les performances.

Gestion de la perte d’appareil

Pendant l’exécution de votre programme, le périphérique graphique que vous utilisez peut devenir indisponible. Par exemple, l’appareil peut être perdu si la résolution d’affichage change ou si l’utilisateur supprime l’adaptateur d’affichage. Si l’appareil est perdu, la cible de rendu devient également non valide, ainsi que toutes les ressources dépendantes de l’appareil qui ont été associées à l’appareil. Direct2D signale la perte d’un appareil en retournant le code d’erreur D2DERR_RECREATE_TARGET à partir de la méthode EndDraw . Si vous recevez ce code d’erreur, vous devez recréer la cible de rendu et toutes les ressources dépendantes de l’appareil.

Pour ignorer une ressource, il vous suffit de libérer l’interface de cette ressource.

void MainWindow::DiscardGraphicsResources()
{
    SafeRelease(&pRenderTarget);
    SafeRelease(&pBrush);
}

La création d’une ressource peut être une opération coûteuse. Par conséquent, ne recréez pas vos ressources pour chaque message WM_PAINT . Créez une ressource une fois, puis mettez en cache le pointeur de ressource jusqu’à ce que la ressource ne devienne pas valide en raison d’une perte d’appareil ou jusqu’à ce que vous n’en ayez plus besoin.

Boucle de rendu Direct2D

Quel que soit ce que vous dessinez, votre programme doit effectuer une boucle similaire à la suivante.

1. Créez des ressources indépendantes de l’appareil.
2. Affichez la scène.
   1. Vérifiez si une cible de rendu valide existe. Si ce n’est pas le cas, créez la cible de rendu et les ressources dépendantes de l’appareil.
   2. Appelez ID2D1RenderTarget::BeginDraw.
   3. Émettre des commandes de dessin.
   4. Appelez ID2D1RenderTarget::EndDraw.
   5. Si EndDraw retourne D2DERR_RECREATE_TARGET, ignorez la cible de rendu et les ressources dépendantes de l’appareil.
3. Répétez l’étape 2 chaque fois que vous devez mettre à jour ou redessiner la scène.

Si la cible de rendu est une fenêtre, l’étape 2 se produit chaque fois que la fenêtre reçoit un message WM_PAINT .

La boucle illustrée ici gère la perte d’appareil en ignorant les ressources dépendantes de l’appareil et en les recréant au début de la boucle suivante (étape 2a).

Suivant

Ppp et pixels Device-Independent