Partager via

Vue d’ensemble des réalisations géométriques

  • Article

Cette rubrique explique comment utiliser les réalisations de géométrie Direct2D pour améliorer les performances de rendu géométrique de votre application dans certains scénarios.

Il contient les sections suivantes :

Que sont les réalisations géométriques ?

Les réalisations geometry, introduites dans Windows 8.1, sont un nouveau type de primitive de dessin qui permet aux applications Direct2D d’améliorer facilement les performances de rendu de géométrie dans certains cas. Les réalisations geometry sont représentées par l’interface ID2D1GeometryRealization .

Pourquoi utiliser des réalisations géométriques ?

Lorsque Direct2D restitue un objet ID2D1Geometry , il doit convertir cette géométrie en une forme que le matériel graphique comprend par le biais d’un processus appelé tssellation. En règle générale, Direct2D doit mettre en forme la géométrie chaque image qu’elle est dessinée, même si la géométrie ne change pas. Si votre application restitue la même géométrie chaque image, le redéployage répété représente un gaspillage d’effort de calcul. Il est plus efficace sur le plan du calcul de mettre en cache la mise en cache, ou même la rastérisation complète, de la géométrie, et de dessiner cette représentation mise en cache chaque image au lieu de ressceller à plusieurs reprises.

Une façon courante pour les développeurs de résoudre ce problème consiste à mettre en cache la rastérisation complète de la géométrie. En particulier, il est courant de créer une image bitmap, de rasteriser la géométrie dans cette bitmap, puis de dessiner cette bitmap sur la scène si nécessaire. (Cette approche est décrite dans la section De rendu geometry de l’article Amélioration des performances des applications Direct2D.) Bien que cette approche soit très efficace sur le plan du calcul, elle présente certains inconvénients :

  • L’image bitmap mise en cache est sensible aux modifications de la transformation appliquée à la scène. Par exemple, la mise à l’échelle de la rastérisation peut entraîner une mise à l’échelle notable des artefacts de mise à l’échelle. L’atténuation de ces artefacts avec des algorithmes de mise à l’échelle de haute qualité peut être coûteuse en calcul.
  • L’image bitmap mise en cache consomme une quantité importante de mémoire, en particulier si elle est rastérisée à haute résolution.

Les réalisations geometry fournissent un autre moyen de mettre en cache la géométrie qui évite les inconvénients ci-dessus. Les réalisations géométriques ne sont pas représentées par des pixels (comme c’est le cas avec une rastérisation complète), mais par des points sur un plan mathématique. Pour cette raison, ils sont moins sensibles que les rastérisations complètes à la mise à l’échelle et à d’autres manipulations, et ils consomment beaucoup moins de mémoire.

Quand utiliser les réalisations géométriques

Envisagez d’utiliser des réalisations géométriques lorsque votre application affiche des géométries complexes dont les formes changent rarement, mais qui peuvent être sujettes à des transformations modifiées.

Par exemple, considérez une application de mappage qui affiche une carte statique, mais qui permet à l’utilisateur de zoomer avant et arrière. Cette application peut tirer parti de l’utilisation des réalisations geometry. Étant donné que les géométries rendues restent statiques, il est utile de les mettre en cache afin d’enregistrer le travail de pavage. Toutefois, étant donné que les cartes sont mises à l’échelle lorsque l’utilisateur effectue un zoom, la mise en cache d’une rastérisation complète n’est pas idéale, en raison de la mise à l’échelle des artefacts. La mise en cache des réalisations géométriques permettrait à l’application d’éviter le travail de ressaisement tout en conservant une qualité visuelle élevée pendant la mise à l’échelle.

D’autre part, envisagez une application de kaléidoscope avec une géométrie animée qui change continuellement. Cette application ne tirerait probablement pas parti de l’utilisation des réalisations geometry. Étant donné que les formes elles-mêmes changent d’image en image, il n’est pas utile de mettre en cache leurs pavages. La meilleure approche pour cette application consiste à dessiner directement des objets ID2D1Geometry .

Création de réalisations géométriques

Un objet ID2D1GeometryRealization doit être créé à partir d’un objet ID2D1Geometry existant. Pour créer une réalisation de géométrie, appelez la méthode CreateFilledGeometryRealization ou la méthode CreateStrokedGeometryRealization et passez l’ID2D1Geometry à réaliser.

Les deux types de réalisation géométrique sont représentés par l’interface ID2D1GeometryRealization .

Lors de la création d’une réalisation géométrique, Direct2D doit aplatir toutes les courbes de la géométrie fournie pour obtenir des approximations polygonales. Vous devez fournir un paramètre de tolérance d’aplatissement à la méthode de création, ce qui spécifie la distance maximale, en pixels indépendants de l’appareil (DIPs), entre la courbe vraie de la géométrie et son approximation polygonale. Plus la tolérance d’aplatissement que vous fournissez est faible, plus la fidélité de l’objet de réalisation de géométrie résultant est élevée. De même, en fournissant une tolérance d’aplatissement plus élevée, on obtient une réalisation géométrique à moindre fidélité. Notez que les réalisations de géométrie à fidélité supérieure sont plus coûteuses à dessiner que celles de moindre fidélité, mais qu’elles peuvent être mises à l’échelle avant d’introduire des artefacts visibles. Pour obtenir des conseils sur l’utilisation des tolérances d’aplatissement, consultez Réalisation de géométrie de mise à l’échelle ci-dessous.

Notes

Les objets de réalisation Geometry sont associés à un appareil graphique particulier : il s’agit de ressources dépendantes de l’appareil.

 

Dessin des réalisations géométriques

La réalisation de la géométrie de dessin est similaire au dessin d’autres primitives Direct2D , comme des bitmaps. Pour ce faire, appelez la méthode DrawGeometryRealization et passez-lui l’objet de réalisation geometry à dessiner et le pinceau à utiliser. Comme avec d’autres méthodes de dessin Direct2D, vous devez appeler DrawGeometryRealization entre les appels à BeginDraw et EndDraw.

Mise à l’échelle des réalisations géométriques

Les réalisations geometry, comme d’autres primitives Direct2D , respectent le jeu de transformation sur le contexte de l’appareil. Bien que les transformations de traduction et de rotation n’aient aucun effet sur la qualité visuelle des réalisations géométriques, les transformations à l’échelle peuvent produire des artefacts visuels.

En particulier, l’application d’une échelle suffisamment grande à toute réalisation géométrique peut révéler l’approximation polygonale des courbes vraies. L’image montre ici une paire de réalisations de géométrie elliptique (remplissage et trait) qui ont été mises à l’échelle trop loin. Les artefacts d’aplatissement de courbes sont visibles.

une paire de réalisations de géométrie elliptique (remplissage et trait) qui ont été mises à l’échelle trop loin. les artefacts d’aplatissement de courbes sont visibles.

Les applications sensibles à la qualité visuelle doivent prendre des mesures pour s’assurer que cela ne se produit pas. La façon dont vous gérez la mise à l’échelle dépend des besoins de votre application. Voici plusieurs approches recommandées pour différents types d’applications.

Utilisation de réalisations géométriques dans des applications qui ne sont pas mises à l’échelle

Si votre application n’effectue aucune mise à l’échelle sur les réalisations géométriques, il est prudent de créer les réalisations une seule fois, à l’aide d’une tolérance d’aplatissement unique. (Les transformations non mises à l’échelle n’affectent pas la qualité visuelle des réalisations géométriques rendues.) Utilisez la fonction ComputeFlatteningTolerance pour calculer la tolérance d’aplatissement appropriée pour le DPI :

    float dpiX, dpiY;
    deviceContext->GetDpi(&dpiX, &dpiY);

    float flatteningTolerance = D2D1::ComputeFlatteningTolerance(
        D2D1::Matrix3x2F::Identity(),   // apply no additional scaling transform
        dpiX,                           // horizontal DPI
        dpiY                            // vertical DPI
        );

Utilisation de réalisations géométriques dans les applications qui effectuent une petite mise à l’échelle

Si votre application ne peut mettre à l’échelle une réalisation de géométrie que d’une petite quantité (par exemple, jusqu’à 2x ou 3x), il peut être approprié de créer simplement la réalisation de la géométrie une fois, à une tolérance d’aplatissement proportionnellement inférieure à la valeur par défaut. Cela crée une réalisation de fidélité supérieure qui peut être mise à l’échelle de manière significative avant d’encourir des artefacts de mise à l’échelle ; le compromis est que dessiner la réalisation de la fidélité supérieure nécessite plus de travail.

Par exemple, supposons que vous sachiez que votre application ne mettra jamais à l’échelle une réalisation géométrique de plus de 2 fois. Votre application peut créer la réalisation de la géométrie à l’aide d’une tolérance d’aplatissement représentant la moitié de la valeur par défaut et mettre simplement à l’échelle la réalisation en fonction des besoins, jusqu’à 2x. Utilisez la fonction ComputeFlatteningTolerance pour calculer la tolérance d’aplatissement appropriée en passant 2.0 comme paramètre maxZoomFactor :

    float dpiX, dpiY;
    deviceContext->GetDpi(&dpiX, &dpiY);
    
    float flatteningTolerance = D2D1::ComputeFlatteningTolerance(
        D2D1::Matrix3x2F::Identity(),   // apply no additional scaling transform
        dpiX,                           // horizontal DPI
        dpiY,                           // vertical DPI
        2.0f                            // realization can be scaled by an additional 2x
        );

Utilisation de réalisations géométriques dans les applications qui effectuent une mise à l’échelle importante

Si votre application peut mettre à l’échelle une réalisation de géométrie vers le haut ou vers le bas de grandes quantités (par exemple, de 10 fois ou plus), la gestion appropriée de la mise à l’échelle est plus compliquée.

Pour la plupart de ces applications, l’approche recommandée consiste à recréer la réalisation de la géométrie à des tolérances d’aplatissement progressivement inférieures à mesure que la scène est mise à l’échelle, afin de maintenir la fidélité visuelle et d’éviter la mise à l’échelle des artefacts. De même, à mesure que la scène est mise à l’échelle, l’application doit recréer les réalisations géométriques à des tolérances d’aplatissement progressivement plus élevées, afin d’éviter le rendu inutile des détails qui ne sont pas visibles. L’application ne doit pas recréer les réalisations géométriques chaque fois que l’échelle change, car cela va à l’échec de la mise en cache du travail de mise en cache. Au lieu de cela, l’application doit recréer les réalisations géométriques moins fréquemment : par exemple, après chaque augmentation ou diminution de 2x de la mise à l’échelle.

Chaque fois que l’échelle change dans une application en réponse à l’interaction utilisateur, l’application peut comparer la nouvelle échelle à l’échelle à laquelle les réalisations géométriques ont été créées pour la dernière fois (stockées, par exemple, dans un membre m_lastScale ). Si les deux valeurs sont proches (dans ce cas, dans un facteur 2), aucune autre action n’est effectuée. Mais si les deux valeurs ne sont pas proches, les réalisations géométriques sont recréées. La fonction ComputeFlatteningTolerance est utilisée pour calculer une tolérance d’aplatissement appropriée pour la nouvelle échelle, et m_lastScale est mis à jour vers la nouvelle échelle.

En outre, l’application crée toujours des réalisations à l’aide d’une tolérance inférieure à celle qui serait normalement utilisée pour la nouvelle échelle, en passant une valeur de 2 comme paramètre maxZoomFactor à ComputeFlatteningTolerance. Cela permet aux nouvelles réalisations géométriques d’être mises à l’échelle par un facteur supplémentaire de 2 sans entraîner de mise à l’échelle d’artefacts.

Notes

L’approche décrite ici peut ne pas convenir à toutes les applications. Par exemple, si votre application permet à la scène d’être mise à l’échelle très rapidement par des facteurs très volumineux (par exemple, si elle contient un curseur de « zoom » qui peut être déplacé de 100 % à 1 000 000 % sur l’étendue de quelques images), cette approche peut entraîner un travail excessif en recréant les réalisations géométriques de chaque image. Une autre approche consiste à recréer les réalisations géométriques uniquement après chaque manipulation de l’échelle de la scène (par exemple, après que l’utilisateur a terminé un mouvement de pincement).

 

Vue d’ensemble des géométries

Amélioration des performances des applications Direct2D

Instructions générales pour le rendu du contenu statique complexe

ID2D1DeviceContext1

ID2D1GeometryRealization

Fonction ComputeFlatteningTolerance