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. Remplir l’arrière-plan avec une couleur unie.
  2. Dessinez un cercle plein.

capture d’écran du programme Circle.

Étant donné que la cible de rendu est une fenêtre (par opposition à une image bitmap ou à une autre surface hors écran), le dessin s’effectue en réponse aux messages de _ peinture WM . Le code suivant illustre 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 programme OnPaint effectue les opérations suivantes :

  1. La méthode ID2D1RenderTarget :: BeginDraw signale le début du dessin.
  2. La méthode ID2D1RenderTarget :: Clear remplit l’intégralité de la cible de rendu avec une couleur unie. La couleur est donnée sous la forme d’une structure _ _ F de couleur d2d1 . Vous pouvez utiliser la classe d2d1 :: ColorF pour initialiser la structure. Pour plus d’informations, consultez utilisation de Color 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 l’achèvement du dessin pour ce frame. Toutes les opérations de dessin doivent être placées entre les appels à BeginDraw et EndDraw.

Les méthodes BeginDraw, Clearet 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 par la valeur de retour de la méthode EndDraw . La CreateGraphicsResources méthode est présenté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 de leur exécution jusqu’à ce que EndDraw soit appelé. Vous pouvez forcer l’appareil à exécuter des commandes de dessin en attente en appelant ID2D1RenderTarget :: Flush. Toutefois, le vidage peut réduire les performances.

Gestion de la perte d’appareil

Pendant que votre programme est en cours d’exécution, 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 la carte 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 un appareil perdu en renvoyant 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 supprimer une ressource, il suffit de libérer l’interface pour cette ressource.

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

La création d’une ressource peut être une opération coûteuse, donc ne recréez pas vos ressources pour chaque message WM _ Paint . Créez une ressource une seule fois et mettez en cache le pointeur de ressource jusqu’à ce que la ressource soit non valide en raison de la perte de l’appareil, ou jusqu’à ce que vous n’ayez plus besoin de cette ressource.

La boucle de rendu Direct2D

Indépendamment de ce que vous dessinez, votre programme doit effectuer une boucle semblable à la suivante.

  1. Créer des ressources indépendantes du périphérique.
  2. Affiche la scène.
    1. Vérifiez s’il existe une cible de rendu valide. 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. Émettez les commandes de dessin.
    4. Appelez ID2D1RenderTarget :: EndDraw.
    5. Si EndDraw retourne D2DERR _ _ cible de recréation, 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 de _ peinture WM .

La boucle présenté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 Device-Independent pixels