\n[French]\nVoici une petite d\u00e9mo qui utilise les techniques d’instancing (instancing simple, pseudo-instancing et geometry instancing(ou GI)) pour effectuer le rendu d’un anneau compos\u00e9 de 10000 petites sph\u00e8res.
\nLa d\u00e9mo est livr\u00e9e en 5 versions:<\/p>\n
- \n
- chaque sph\u00e8re est compos\u00e9e de 1800 triangles (18 millions de triangles pour l’anneau entier)<\/li>\n
- chaque sph\u00e8re est compos\u00e9e de 800 triangles (8 millions de triangles pour l’anneau entier)<\/li>\n
- chaque sph\u00e8re est compos\u00e9e de 200 triangles (2 millions de triangles pour l’anneau entier)<\/li>\n
- chaque sph\u00e8re est compos\u00e9e de 72 triangles (720000 triangles pour l’anneau entier)<\/li>\n
- chaque sph\u00e8re est compos\u00e9e de 18 triangles (180000 triangles pour l’anneau entier)<\/li>\n<\/ul>\n
J’ai ajout\u00e9 au dernier moment un extra: une version avec 20000 instances de 5000 triangles chacune soit 100 millions de polygones (fichier Demo_Instancing_100MTriangles_20kInstances.exe).
\n[\/French]\n[English]\nThis demo uses instancing techniques (simple instancing, pseudo-instancing and geometry instancing(or GI)) to render a ring made of 10,000 small spheres. The demo is delivered in 5 versions:<\/p>\n- \n
- each sphere is made of 1,800 triangles (18 millions triangles for the whole ring)<\/li>\n
- each sphere is made of 800 triangles (8 millions triangles for the whole ring)<\/li>\n
- each sphere is made of 200 triangles (2 millions triangles for the whole ring)<\/li>\n
- each sphere is made of 72 triangles (720,000 triangles for the whole ring)<\/li>\n
- each sphere is made of 18 triangles (180,000 triangles for the whole ring)<\/li>\n<\/ul>\n
I added in the last moment a bonus: a 20,000 instances version, each instance made of 5,000 triangles. We get the monstruous count of 100 millions triangles (file Demo_Instancing_100MTriangles_20kInstances.exe).
\n[\/English]\n
\n![](\"public\/200803\/demo_opengl_instancing_01_400x253.jpg\")
\n![](\"public\/200803\/demo_opengl_instancing_02_400x253.jpg\")
\n![](\"public\/200803\/demo_opengl_instancing_03_400x253.jpg\")
\n<\/center><\/p>\nDOWNLOAD<\/h3>\n
- \nOpenGL Instancing DemoPack – (2676k)<\/a><\/strong>\n<\/ul>\n[French]\nIl y a plusieurs techniques d’instancing qui sont utilis\u00e9es et chaque technique est accessible avec une des touches F1 \u00e0 F6.<\/p>\n
- F1: instancing simple avec camera frustum culling: il y a une seule source de g\u00e9om\u00e9trie (un mesh) et elle est rendu pour chaque instance. Le calcul de la matrice de transformation est fait sur le CPU ainsi que le test de clipping avec la camera. Le rendu OpenGL utilise la fonction glDrawElements().<\/li>\n
- F2: instancing simple SANS camera frustum culling: il y a une seule source de g\u00e9om\u00e9trie (un mesh) et elle est rendu pour chaque instance. Le calcul de la matrice de transformation est fait sur le CPU mais il n’y a plus de test de clipping avec la camera. Le rendu OpenGL utilise la fonction glDrawElements().<\/li>\n
- F3: pseudo-instancing lent: il y a une seule source de g\u00e9om\u00e9trie (un mesh) et elle est rendu pour chaque instance. Le calcul de la matrice de transformation est maintenant effectu\u00e9 sur le GPU. Le passage des param\u00e8tres pour chaque instance se fait avec des variables uniformes. Il n’y a pas de test de clipping avec la camera. Le rendu OpenGL utilise la fonction glDrawElements().<\/li>\n
- F4: pseudo-instancing rapide: il y a une seule source de g\u00e9om\u00e9trie (un mesh) et elle est rendu pour chaque instance. Le calcul de la matrice de transformation est maintenant effectu\u00e9 sur le GPU. Le passage des param\u00e8tres pour chaque instance se fait avec des attributs de vertex persistants (comme les coordonn\u00e9es de textures ou la couleur). C’est cette technique qui
\na \u00e9t\u00e9 mise en avant par NVIDIA avec son whitepaper: GLSL Pseudo-Instancing<\/a>. Il n’y a pas de test de clipping avec la camera. Le rendu OpenGL utilise la fonction glDrawElements().<\/li>\n- F5: Geometry Instancing: c’est le vrai instancing hardware. Il y a une seule source de g\u00e9om\u00e9trie (un mesh) et le rendu se fait par lots (ou batchs) de 400 instances par draw call. Le rendu complet de l’anneau ne n\u00e9cessite que 25 draw-calls au lieu de 10000. Le calcul de la matrice de transformation est effectu\u00e9 sur le GPU. Le passage des param\u00e8tres pour chaque batch se fait avec des tableaux de variables uniformes. Il n’y a pas de test de clipping avec la camera. Le rendu OpenGL utilise la fonction glDrawElementsInstancedEXT(). Actuellement, seules les cartes NVIDIA GeForce 8 (et sup.) supportent cette fonction.<\/li>\n
- F6: Geometry Instancing avec attributs de vertex persistants: c’est le geometry instancing hardware coupl\u00e9 avec le passage des param\u00e8tres par les attributs de vertex persistants. Mais le nombre d’attributs de vertex persistants est tr\u00e8s limit\u00e9. Au maximum j’ai reussi \u00e0 rendre 4 instances par draw-call. Mais \u00e9trangement, 2 instances par draw-call donne de meilleurs r\u00e9sultats. Dans ce cas, le rendu complet de l’anneau n\u00e9cessite que 5000 draw-calls au lieu des 10000. Le calcul de la matrice de transformation est effectu\u00e9 sur le GPU. Il n’y a pas de test de clipping avec la camera. Le rendu OpenGL utilise la fonction glDrawElementsInstancedEXT(). Actuellement, seules les cartes NVIDIA GeForce 8 (et sup.) supportent cette fonction.<\/li>\n<\/ul>\n[\/French]\n[English]\nSeveral instancing techniques are used and you can select them with F1 to F6 keys.<\/p>\n
- \n
- F1: simple instancing with camera frustum culling: there is one source for geometry (a mesh) and it’s rendered for each instance. The tranformation matrix calculation is done on the CPU as well as the camera frustum test. OpenGL rendering uses the glDrawElements() function.<\/li>\n
- F2: simple instancing without camera frustum culling: there is one source for geometry (a mesh) and it’s rendered for each instance. The tranformation matrix calculation is done on the CPU but there is no longer camera frustum test. OpenGL rendering uses the glDrawElements() function.<\/li>\n
- F3: slow pseudo-instancing: there is one source for geometry (a mesh) and it’s rendered for each instance. Now the tranformation matrix calculation is done on the GPU and per-instance data are passed via uniform variables. There is no camera frustum test. OpenGL rendering uses the glDrawElements() function.<\/li>\n
- F4: pseudo-instancing: there is one source for geometry (a mesh) and it’s rendered for each instance. The tranformation matrix calculation is done on the GPU and per-instance data are passed via persistent vertex attributes (like texture coordinates or color). This technique has been shown by NVIDIA in the following whitepaper: GLSL Pseudo-Instancing<\/a>. There is no camera frustum test. OpenGL rendering uses the glDrawElements() function.<\/li>\n
- F5: geometry instancing: it’s the real hardware instancing. There is one source for geometry (a mesh) and rendering is done by batchs of 400 instances per draw-call. The whole rendering of the ring requires 25 draw-calls instead of 10,000. The tranformation matrix calculation is done on the GPU and per-batch data is passed via uniform arrays. There is no camera frustum test. OpenGL rendering uses the glDrawElementsInstancedEXT() function. Currently, only NVIDIA GeForce 8 (and higher) support this function.<\/li>\n
- F6: geometry instancing with persistant vertex attributes: it’s the hardware instancing coupled with the transmission of parameters is done via the persistent vertex attributes. But the number of persistent vertex attributes is very limited. The best I did is to render 4 instances per draw-call. But oddly, I got the best results with 2 instances per draw-call. In that case, the rendering of whole ring requires 5000 draw-calls. The tranformation matrix calculation is done on the GPU and per-batch data is passed via uniform arrays. There is no camera frustum test. OpenGL rendering uses the glDrawElementsInstancedEXT() function. Currently, only NVIDIA GeForce 8 (and higher) support this function.<\/li>\n<\/ul>\n
Ok now, let’s see some results with a NVIDIA GeForce 8800 GTX and an ATI Radeon HD 3870. Both cards have been tested with an AMD 64 3800+.
\n[\/English]\n18 millions triangles – 1800 tri\/instance<\/h3>\n
NVIDIA GeForce 8800 GTX – Forceware 169.38 XP32<\/b><\/p>\n
- \n
- F1: 223MTris\/sec – 13FPS <\/li>\n
- F2: 223MTris\/sec – 13FPS <\/li>\n
- F3: 223MTris\/sec – 13FPS <\/li>\n
- F4: 223MTris\/sec – 13FPS <\/li>\n
- F5: 223MTris\/sec – 13FPS <\/li>\n
- F6: 171MTris\/sec – 10FPS <\/li>\n<\/ul>\n
ATI Radeon HD 3870 – Catalyst 8.2 XP32<\/b><\/p>\n
- \n
- F1: 429MTris\/sec – 25FPS <\/li>\n
- F2: 463MTris\/sec – 27FPS <\/li>\n
- F3: 446MTris\/sec – 26FPS <\/li>\n
- F4: 274MTris\/sec – 16FPS <\/li>\n
- F5: mode not available <\/li>\n
- F6: mode not available <\/li>\n<\/ul>\n
8 millions de triangles – 800 tri\/instance<\/h3>\n
NVIDIA GeForce 8800 GTX – Forceware 169.38 XP32<\/b><\/p>\n
- \n
- F1: 190MTri\/sec – 25FPS<\/li>\n
- F2: 190MTri\/sec – 25FPS<\/li>\n
- F3: 205MTri\/sec – 27FPS<\/li>\n
- F4: 213MTri\/sec – 28FPS<\/li>\n
- F5: 205MTri\/sec – 27FPS<\/li>\n
- F6: 152MTri\/sec – 20FPS<\/li>\n<\/ul>\n
ATI Radeon HD 3870 – Catalyst 8.2 XP32<\/b><\/p>\n
- \n
- F1: 251MTris\/sec – 33FPS <\/li>\n
- F2: 236MTris\/sec – 31FPS <\/li>\n
- F3: 297MTris\/sec – 39FPS <\/li>\n
- F4: 251MTris\/sec – 33FPS <\/li>\n
- F5: mode not available <\/li>\n
- F6: mode not available <\/li>\n<\/ul>\n
2 millions de triangles – 200 tri\/instance<\/h3>\n
NVIDIA GeForce 8800 GTX – Forceware 169.38 XP32<\/b><\/p>\n
- \n
- F1: 47MTri\/sec – 25FPS<\/li>\n
- F2: 47MTri\/sec – 25FPS<\/li>\n
- F3: 57MTri\/sec – 30FPS<\/li>\n
- F4: 131MTri\/sec – 69FPS<\/li>\n
- F5: 167MTri\/sec – 88FPS<\/li>\n
- F6: 148MTri\/sec – 78FPS<\/li>\n<\/ul>\n
ATI Radeon HD 3870 – Catalyst 8.2 XP32<\/b><\/p>\n
- \n
- F1: 47MTris\/sec – 25FPS <\/li>\n
- F2: 59MTris\/sec – 31FPS <\/li>\n
- F3: 74MTris\/sec – 39FPS <\/li>\n
- F4: 112MTris\/sec – 59FPS <\/li>\n
- F5: mode not available <\/li>\n
- F6: mode not available <\/li>\n<\/ul>\n
720,000 triangles – 72 tri\/instance<\/h3>\n
NVIDIA GeForce 8800 GTX – Forceware 169.38 XP32<\/b><\/p>\n
- \n
- F1: 17MTri\/sec – 25FPS<\/li>\n
- F2: 17MTri\/sec – 25FPS<\/li>\n
- F3: 20MTri\/sec – 30FPS<\/li>\n
- F4: 47MTri\/sec – 69FPS<\/li>\n
- F5: 60MTri\/sec – 88FPS<\/li>\n
- F6: 53MTri\/sec – 78FPS<\/li>\n<\/ul>\n
ATI Radeon HD 3870 – Catalyst 8.2 XP32<\/b><\/p>\n
- \n
- F1: 17MTris\/sec – 25FPS <\/li>\n
- F2: 21MTris\/sec – 31FPS <\/li>\n
- F3: 26MTris\/sec – 39FPS <\/li>\n
- F4: 40MTris\/sec – 59FPS <\/li>\n
- F5: mode not available <\/li>\n
- F6: mode not available <\/li>\n<\/ul>\n
180000 triangles – 18 tri\/instance<\/h3>\n
NVIDIA GeForce 8800 GTX – Forceware 169.38 XP32<\/b><\/p>\n
- \n
- F1: 4MTri\/sec – 25FPS<\/li>\n
- F2: 4MTri\/sec – 25FPS<\/li>\n
- F3: 5MTri\/sec – 30FPS<\/li>\n
- F4: 11MTri\/sec – 69FPS<\/li>\n
- F5: 15MTri\/sec – 89FPS<\/li>\n
- F6: 13MTri\/sec – 79FPS<\/li>\n<\/ul>\n
ATI Radeon HD 3870 – Catalyst 8.2 XP32<\/b><\/p>\n
- \n
- F1: 4MTris\/sec – 25FPS <\/li>\n
- F2: 5MTris\/sec – 31FPS <\/li>\n
- F3: 6MTris\/sec – 39FPS <\/li>\n
- F4: 10MTris\/sec – 59FPS <\/li>\n
- F5: mode not available <\/li>\n
- F6: mode not available <\/li>\n<\/ul>\n[French]\nAnalyse rapide des resultats:<\/p>\n
- \n
- nous comprenons maintenant pourquoi NVIDIA a appell\u00e9 “Pseudo-Instancing” la technique utilisant les attributs persistants de vertex (key F4). La fonction glDrawElements() d’OpenGL est extremement rapide et optimis\u00e9e et les attrubuts persistants de vertex n\u00e9cessitent moins de traitement que les variables uniformes pour \u00eatre pass\u00e9s au vertex shader. Les deux coupl\u00e9s ensemble donnent ce boost de performance.<\/li>\n
- le b\u00e9n\u00e9fice du vrai hardware geometry instancing est principalement visible losqu’il y a peu de triangles par instance.<\/li>\n
- lorsqu’il y a beacoup de triangles par instance (1800), l’imp\u00e9mentation mat\u00e9rielle de glDrawElements() semble \u00eatre plus efficace (pr\u00e8s de deux fois!) sur le GPU RV670 que sur le G80.<\/li>\n<\/ul>\n
Conclusion<\/h3>\n
Au vu des r\u00e9sultats, le hardware geometry instancing n’est pas la kill-feature que j’attendais. Je trouve cela tr\u00e8s curieux car la diff\u00e9rence entre 10000 render-calls avec glDrawElements et 25 render-calls avec glDrawElementsInstancedEXT n’est pas tr\u00e8s importante. On dirait que la gestion de l’instancing (variable gl_InstanceID dans le vertex shader) fait perdre beaucoup de temps. Je trouve aussi dommage qu’ATI n’ait pas encore pris le temps d’impl\u00e9menter le geomtry instancing dans les pilotes Catalyst. Je serais tr\u00e8s curieux de tester le GI hardware avec un RV670.
\n[\/French]\n[English]\nQuick results analysis:<\/p>\n- \n
- we now understand why NVIDIA has called the technique using persistent vertex attributes “Pseudo-Instancing” (key F4). OpenGL glDrawElements() function is extremly fastand persistent vertex attributes require less overhead than uniforms to be passed to vertex shader. Both coupled together give this performance boost.<\/li>\n
- benefit of real hardware geometry instancing is mostly visible with few triangles per instance.<\/li>\n
- when there are many triangles per instance (1,800), the hardware implementation of glDrawElements() seems to be more efficient (twice!) on RV670 GPU than on G80.<\/li>\n<\/ul>\n
Conclusion<\/h3>\n
From the results, hardware geometry instancing isn’t the kill-feature I expected. I find that very weird since the diff\u00e9rence between 10000 render-calls with glDrawElements and 25 render-calls with glDrawElementsInstancedEXT is not verx important. Seems the instancing management (gl_InstanceID variable in the vertex shader) is a GPU-cycle eater!What a pity ATI hasn’t implemented yet geometry instancing in the Catalyst drivers. I’d be very curious to test hardware GI with a RV670.
\n[\/English]\n","protected":false},"excerpt":{"rendered":"This article has been updated with new demos and new GI technique. Read the complete article here: OpenGL Geometry Instancing: GeForce GTX 480 vs Radeon HD 5870. [French] Voici une petite d\u00e9mo qui utilise les techniques d’instancing (instancing simple, pseudo-instancing et geometry instancing(ou GI)) pour effectuer le rendu d’un anneau compos\u00e9 de 10000 petites sph\u00e8res. La d\u00e9mo est livr\u00e9e en 5 versions: chaque sph\u00e8re est … Continue reading OpenGL Geometry Instancing<\/span>
- \n