JeGX's Infamous Lab » OpenGL

Visualisez les Molécules en OpenGL + AO avec QuteMol

JeGX — Thu, 05 Aug 2010 20:03:26 +0000

QutMol est un soft pour visualiser les molécules (format PDB) et utilise OpenGL pour le rendu 3D. Bon QutMol (drôle de nom au passage) n’a pas été updaté depuis presque 3 ans mais dans la liste des features il y a: Real Time Ambient Occlusion. C’est bon je lance le download…

Une grosse molécule avec de l’AO uniquement:

Et là une autre molécule avec toujours de l’AO mais aussi une détection de silhouette et même un petit halo (noir) pour la rendre plus classe la publication des molécules sur les sites web par exemple:

Tiens, je vais peut être en faire une news sur Geeks3D un des ces quatres

Demos (Videos!) Particules OpenGL JOGL

JeGX — Thu, 05 Aug 2010 19:35:57 +0000

Basic stateless “Particle System” calculated entirely as vertex shader.

JOGL est le wrapper OpenGL pour le language Java. Voilà quelques videos sympas qui montrent des particles JOGL en action.

“Intermediate Particle System” using a more complex movement algorithm as in the “Basic Particle System”

Geometry Instancing en OpenGL: le Presque Retour!

JeGX — Fri, 25 Jun 2010 12:20:55 +0000

80,000,000 de polygones… c’est cool l’instancing!

Vue les feedbacks réguliers (genre: le download n’est plus dispo!!!) que je reçois par rapport au petit article que j’ai pondu il y a 2 ans sur le geometry instancing en OpenGL, j’ai decidé de remettre le pack de demos à jour.

Et j’ai ajouté un nouveau mode basé sur les uniform buffers.

Les demos fonctionnent maintenant correctement sur ma GTX 480. Et bien sûr, je viens juste de tester sur une HD 5870 + Cat 10.6 et ça mer… euh crashe!

Et vue que j’ai pas envie de remplacer la GTX 480 par la HD 5870 sur ma machine de dev, je vais devoir debugger à distance…

Dès que c’est ok sur la radeon, je publie l’article complet sur Geeks3D.com.

HowTo: Matrice de Projection Perspective en OpenGL

JeGX — Tue, 28 Jul 2009 08:48:52 +0000

Je viens de tomber sur ce post de Xavier Gouchet qui avait besoin d’une routine pour initialiser la matrice de projection de la caméra en OpenGL. Vu qu’il ne pouvait pas utiliser les fonctions de la glu/glut car non supportées sous Android, il a du trouver une routine avec juste deux fonctions de base d’OpenGL: glMatrixMode et glFrustum. C’est bien! Mais on peut mieux faire: rendre le calcul de la matrice totalement indépendant d’OpenGL. En gros, recoder la fonction glFrustum.

Gros intéret de la méthode: la routine peut être utilisée aussi bien avec Direct3D qu’avec avec le futur Larrabee…

Okay mes amis, voici le code extrait de mes routines 3D (et légèrement modifié pour les besoins de ce post):

void BuildPerspProjMat(float *m, float fov, float aspect,
float znear, float zfar)
{
  float xymax = znear * tan(fov * PI_OVER_360);
  float ymin = -ymax;
  float xmin = -xmax;

  float width = xymax - xmin;
  float height = xymax - ymin;

  float depth = zfar - znear;
  float q = -(zfar + znear) / depth;
  float qn = -2 * (zfar * znear) / depth;

  float w = 2 * znear / width;
  w = w / aspect;
  float h = 2 * znear / height;

  m[0]  = w;
  m[1]  = 0;
  m[2]  = 0;
  m[3]  = 0;

  m[4]  = 0;
  m[5]  = h;
  m[6]  = 0;
  m[7]  = 0;

  m[8]  = 0;
  m[9]  = 0;
  m[10] = q;
  m[11] = -1;

  m[12] = 0;
  m[13] = 0;
  m[14] = qn;
  m[15] = 0;
}

et voici son utilisation:

float m[16] = {0};
float fov=60.0f; // en degrés
float aspect=1.3333f;
float znear=1.0f;
float zfar=1000.0f;
BuildPerspProjMat(m, fov, aspect, znear, zfar);
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(m);

// et hop on repasse en modelview pour le reste des matrices
glMatrixMode(GL_MODELVIEW);
...

Pour finir et juste pour optimiser un peu, la fonction glLoadIdentity dans le code de Xavier n’est pas nécessaire car la fonction glFrustum remplace complétement la matrice…

Vertex Displacement Mapping in GLSL Now Available on Radeon!

JeGX — Tue, 30 Sep 2008 16:29:54 +0000

As I said in this news, the release of Catalyst 8.10 BETA comes with a nice bugfix: vertex texture fetching is now operational on Radeon (at least on my Radeon HD 4850). From 2 or 3 months, Catalyst makes it possible to fetch texture from inside a vertex shader. You can see with GPU Caps Viewer how many texture units are exposed in a vertex shader for your Radeon:

But so far, vertex texture fetching in GLSL didn’t work due to a bug in the driver. But now this is an old story, since VTF works well. For more details about vertex displacement mapping, you can read this rather old (2 years!) tutorial: Vertex Displacement Mapping using GLSL.

This very cool news makes me want to create a new benchmark based on VTF!

I’ve only tested the XP version of Catalyst 8.10. If someone has tested the Vista version, feel free to post a comment…

Next step for ATI driver team: enable geometry texture fetching: allows texture fetching inside a geometry shader…

See you soon!

OpenGL Geometry Instancing

JeGX — Sun, 16 Mar 2008 14:40:13 +0000

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.

This 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:

each sphere is made of 1,800 triangles (18 millions triangles for the whole ring)
each sphere is made of 800 triangles (8 millions triangles for the whole ring)
each sphere is made of 200 triangles (2 millions triangles for the whole ring)
each sphere is made of 72 triangles (720,000 triangles for the whole ring)
each sphere is made of 18 triangles (180,000 triangles for the whole ring)

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).

DOWNLOAD

OpenGL Instancing DemoPack – (2676k)

Several instancing techniques are used and you can select them with F1 to F6 keys.

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.
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.
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.
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. There is no camera frustum test. OpenGL rendering uses the glDrawElements() function.
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.
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.

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+.