2010-08-10 : Direct2D, un GDI 32 bits intéressant

Documentation officielle

Direct2D : https://docs.microsoft.com/en-us/windows/win32/direct2d/direct2d-portal

GDI+ : http://msdn2.microsoft.com/en-us/library/ms533798(VS.85).aspx

GDI : http://msdn2.microsoft.com/en-us/library/ms536795(VS.85).aspx

Petite histoire

Le vieux GDI utilisé par Windows est un vilain GDI 16 bits. Concrètement, cela signifie qu'il est impossible d'utiliser les fonctions graphiques en utilisant des points de coordonnées à l'extérieur du domaine [-2¹⁵;2¹⁵-1]² soit [-32768;32767]². C'est ridiculement faible.

GDI+ est un GDI sorti en 2001. Il assure de base une compatibilité avec la majorité des systèmes d'exploitation en place à l'époque (Windows 2000, Windows 98, Windows Me, Windows XP, et même Windows NT). Il contient pas mal de primitives intéressantes, il assure la prise en charge de la transparence avec la canal alpha. Et il supporte la manipulation des images issues de nombreux formats possibles. Mais j'adresse 2 reproches à GDI+ :

Les performances sont loin d'être décoiffantes. De toute manière, GDI+ fait essentiellement son travail sur le CPU, tout comme GDI le faisait (excepté quelques primitives accélérées telles que BitBlt). Les graphismes faits avec OpenGL ou DirectX utilisent de leur côté massivement les capacités des GPU.
GDI+ n'est pas un pur GDI 32 bits. Je l'ai en effet prouvé il y a plus de 2 ans dans cet article : GDI+, un GDI 24 bits.

Fin octobre 2008, Microsoft annonçait la sortie d'un nouveau GDI appelé Direct2D. A priori prometteur car il repose essentiellement sur Direct3D, donc il est normalement accéléré par le GPU. Mais un inconvénient notable : Direct2D n'est prévu que pour Windows 7, Windows Server 2008 et leurs successeurs. Le moment venu, je testerai la version finale de cette API, comme je l'avais fait dès 2001 pour le GDI+.

Il y a un peu plus d'un an, Héclium était enfin doté d'une interface dynamique. Les nombreuses optimisations dont il est doté permettent au logiciel de se comporter avec une fluidité acceptable. Seule la partie purement graphique (le dessin des polygones) pose réellement problème : les compteurs de performance m'indiquent clairement que la partie dessin est la plus consommatrice de temps CPU.
Ce qui est étonnant, c'est que la puissance des processeurs stagne depuis des années alors que la puissance des processeurs graphiques continue sa course en avant. Jusqu'à en devenir déraisonnable. Ainsi, le monstre de puissance graphique du moment, le GeForce GTX 480 doté de pas moins de 512 cœurs vient d'être testé. Dès lors, il semble naturel que la partie graphique d'Héclium doit être traitée par le processeur graphique et non le processeur central. Mais DirectX ou OpenGL restent des choix trop douloureux et en tout cas bien trop éloignés des graphismes 2D.

Août 2010 : le temps est venu de tester réellement Direct2D sur Windows 7, même si certains blogueurs se sont déchaînés contre Direct2D et m'invitent donc à ne pas m'enthousiasmer d'avance.

Direct2D : enfin un GDI 32 bits

Premier test : est-ce que Direct2D fait mieux que GDI+ pour tracer des segments dont les extrémités sont à l'extérieur du domaine [-2²³-1;2²³-1]² ?

La réponse est oui. Voici un extrait de code source simple :

hr = m_pRT->CreateSolidColorBrush(
D2D1::ColorF(D2D1::ColorF::Red),
&m_pRedBrush
);

m_pRT->BeginDraw();

m_pRT->Clear(D2D1::ColorF(D2D1::ColorF(0x0a1a44, 1.0f)));

D2D1_POINT_2F d1 = D2D1::Point2F(-99655379.0f, -99655379.0f);
D2D1_POINT_2F d2 = D2D1::Point2F( 99655379.0f, 99655379.0f);
m_pRT->DrawLine(d1, d2, m_pRedBrush, 13.6F);

HRESULT hr = m_pRT->EndDraw();

Voici ce que ça donne en images :

Logiciel Héclium - Capture d'écran - Cliquez pour agrandir

Le segment est donc correctement dessiné comme prévu.

Direct2D : une API intéressante

L'API Direct2D est un peu lourde à manier. Elle nécessite d'écrire beaucoup de lignes de code. Mais elle possède beaucoup de fonctionnalités. Ne serait-ce que l'API dédié aux gradients qui est fort intéressante. Dans Héclium, la partie dessin de la Terre et de son atmosphère peut enfin être largement simplifiée en utilisant Direct2D (en dessinant des disques), alors que jusque là, il était nécessaire de dessiner des polygones savamment calculés par le CPU.

Au niveau performances, elle semble assez efficace, même sur une carte graphique ne disposant que d'un pilote WDDM 1.0 au lieu de 1.1.

Conclusions

Ces quelques tests m'ont convaincu d'aller plus loin et aller jusqu'à écrire une version spécifique d'Héclium pour les systèmes d'exploitation dotés de Direct2D.

◄ Retour