Para los amantes de GL!!! Al fin!!!

[MChiz]

                                Hola a todos!!

Me he quedado sorprendido con lo que me he encontrado. No se si alguno ya lo sabra, pero lo digo por si hay alguien tan despistado como yo :b

http://oss.sgi.com/projects/ogl-sample/reg...ffer_object.txt

Se trata de la estandarizacion de la VertexArrayRange ( VAR ). Al fin es ARB!! :) La extension VAR y la VertexArrayObject ( creo que se llama asi. Es de ATI ) quedan obsoletas y dejan paso a esta nueva :)

No tardare en probarla :) Si hay alguien que la haya implementado, que diga algo. Implementar una nueva extension siempre es un poco dificil.

Un saludote!!                                

[MChiz]

                                Bueno, ya he conseguido implementar dicha extension. Ha costado lo suyo, pero bueno...
Las ganancias solo son jugosas cuando hay que pintar mucha malla. Si no es asi, las ganancias son "pocas". Lo cual no quiere decir que sea malo : )
En fin, como tampoco veo que le interese el tema a nadie, no explicare como funciona. Si alguien esta interesado, que me lo diga.
Adiooos!!                                

[Aureal]

                                Pues a mi me interesa, podrias explicarlo, claro que tu dices que algo queda obsoleto pero no se a que te refieres  :loco:  asi  que podrias explicar que queda para ti obsoleto y que hay de nuevo en esas extensiones si no es mucha molestia claro  :ojo:                                

[MChiz]

                                Hola:

Veras, la extension GL_ARB_vertex_buffer_object viene a ser, ni mas ni menos, los VertexBuffers de D3D. Hasta estan los IndexBuffers!! : )

Lo que hace esta extension es proporcionarte memoria de video para guardar lo que tu quieras. Esto lo puedes aprovechar para guardar ahi mallas de tu juego. Asi, cuando quieras renderizar algo que este en la memoria de video, no tiene que pasar por el BUS, lo cual es muy costoso. Tan solo la GPU tiene que procesar la malla. No hay penalizacion por transferencia ( lo cual es una puta pasada ).

Lo que decia de las extensiones obsoletas: antes de que la GL_ARB_vertex_buffer_object existiera, estaba ( en las nVidia ) la extension GL_NV_vertex_array_range, que vendria a ser algo muy parecido, pero con unas cuantas complicaciones. Resumiendo, las VertexArrayRange son las GL_ARB_vertex_buffer_object, a bajo nivel. No la implemente nunca, pero tengo entendido que hacer cambios entre buffers estaba MUY penalizado, cosa que ahora, con los VertexBufferObjects no lo esta apenas.
Con las VertexArrayRange tambien tenias que gestionarte tu la memoria, y sincronizarte con la tarjeta, y cosas asi. Total, un coñazo.
Y luego esta la GL_ATI_vertex_array_object ( no se si es asi exactamente ) que CREO ( y digo CREO ) que es igual que la GL_ARB_vertex_buffer_object, pero con unas pequeñas diferencias, pero creo que trabajan de la misma forma ( o casi ).

Y de esto trata : )
Espero haberlo explicado bien
Adios!!                                

[MaSteR]

                                Eso es bastante interesante...

Una pregunta y corrigeme... crees q si en la memoria de la tarjeta se puede meter mapas :D xDD por ejemplo un Octree? o tienen q ser cosas pequeñas?, puedes pasarte de la memoria almacenando osas q la tarjeta ya se las avia ? me produce grandes interrogantes lo del buffer                                

[MChiz]

                                Claro que se puede. Como he dicho anteriormente, tu pides memoria de video. Puedes guardar ahi lo que quieras : )
Yo, en mi intento de juego, he pasado toda la malla de mi Octree a la memoria de video, y bueno, ya he comentado en el 2 post el rendimiento obtenido. Haces un VertexBufferObject para cada nodo del Octree y guardas ahi su malla. Luego, a la hora de pintar, si un nodo se ve, seleccionas su VertexBufferObject y lo mandas a pintar. Asi de facil!
En resumidas cuentas, un VertexBufferObject viene a ser un malloc pero de memoria de video : )

puedes pasarte de la memoria almacenando osas q la tarjeta ya se las avia ?

Eso no lo entiendo. Si eso, ponme un ejemplo.
talueK!!!                                

[Loover]

                                Mola
Ya he actulizado los drivers de mi radeon y reconoce esa extensión, cojonudo. ¿Hasta que tarjetas puedo presuponer que soportarán esa extensión?                                

[MChiz]

                                http://www.delphi3d.net/hardware/extsuppor...x_buffer_object

: )                                

[MaSteR]

                                imagina q mi octree es de mmmmmmmm 150 M y la memoria de la tarjeta solo 128 :S q pasa entonces? la tarjeta gestiona sola la memoria? o sea lo q no cabe lo almacena en memoria del PC?

Ah! y otra cosa! hay q bajarse unos drivers nuevos para las ATI? si es asi de dnd ? tengo una 9100 por si alguien se pasara el enlace :P                                

[MChiz]

                                Vale. Como ya he dicho, la extension funciona como un malloc. Y que hace un malloc cuando no hay memoria? Devuelve un NULL :b Pues la extension esta mas o menos trabaja asi ( no devuelve un NULL, devuelve un OUT_OF_MEMORY ).
Asi de facil.                                

[Loover]

                                http://www.delphi3d.net/hardware/extsuppor...x_buffer_object

Pues en el enlace ese no aparece mi tarjeta (Radeon 7200) y sinembargo con los nuevos ati catalyst soporta esa extensión. Tirón de orejas.                                

[MChiz]

                                jejeje, mejor : )
La verdad es que debe ser una extension bastante general. Como lo que paso con WGL_pixel_buffer. Las TNT tambien la soportaban.                                

[Degiik]

                                Buenas, he leido el post y aunque dispongo de poco tiempo no me he podido retraer de programarlo. Pues bien, lo he echo, pero no he obserbado ninguna mejora en frames ( redimiento ). ¿ Quizas porque hice algo mal ? Pasteo aqui la parte del código más sensible a poder haber cometido algun error.

Un saludo. Y gracias MChiz por poner este post tan interesante. A veces no todo deben ser preguntas.

unsigned int vb[2];
float *va;
unsigned int *indices;

   /* BEGIN malla ( va y indices vb son globales ) */

   va=(float *) malloc (50*300*sizeof (float));
   indices =(unsigned int *) malloc (50*100*sizeof (unsigned int));
   unsigned int i,u,j;

   for (j=0;j<50;j++)
      {
      for (u=0,i=0;i<300;i++,u++)
         {
         *(va+i+(j*300))=(-25.0f)+u;
         i++;
         *(va+i+(j*300))=25.0f-(float)j;
         i++;      
         *(va+i+(j*300))=0.0f;
         i++;

         *(va+i+(j*300))=(-25.0f)+u;
         i++;
         *(va+i+(j*300))=24.0f-(float)j;
         i++;      
         *(va+i+(j*300))=0.0f;
         }
      }

   for (i=0;i<100*50;i++)
      {
      *(indices+i)=i;
      }

   /* FIN malla */   


// Comprovación de la extensión

   if (isExtensionSupported("GL_ARB_vertex_buffer_object"))
      {
      LoadVertexBuffersFunctions (&BindBufferARB,&DeleteBuffersARB,&GenBuffersARB,&BufferDataARB);
      #define USE_BUFFER_OBJECTS //para provar este programa sin Vertex Objects se cambia simplemente el nombre del define
      }


//Creación de los buffers objects.

   #ifndef USE_BUFFER_OBJECTS
      MessageBox (NULL,"Imposible de utilizar VertexBuffers, falta GL_ARB_vertex_buffer_object","Info",MB_OK);
   #else
      GenBuffersARB (2,vb);
      BindBufferARB(GL_ARRAY_BUFFER_ARB, vb[0]);
      BufferDataARB(GL_ARRAY_BUFFER_ARB, 50*300 * sizeof(float), va, GL_STATIC_DRAW_ARB);
      BindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB , vb[1]);
      BufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB , 50*100 * sizeof(int), indices, GL_STATIC_DRAW_ARB);

      free (va);
      free (indices);
      va=NULL;
      indices=NULL;
   #endif


// Render

   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();

   
   glTranslatef (0,0,-50);
   
   for (i=0;i<2;i++) //dibujo un par de mallas
      {

      glTranslatef (0,0,-20);

      #ifdef USE_BUFFER_OBJECTS
         BindBufferARB(GL_ARRAY_BUFFER_ARB, vb[0]);
      #endif
      glVertexPointer (3,GL_FLOAT,0,va);

      #ifdef USE_BUFFER_OBJECTS
         BindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB , vb[1]);
      #endif
      glDrawElements(GL_TRIANGLE_STRIP, 50*100, GL_UNSIGNED_INT, indices );

      }


p.d: No se como se tabula :( , se pierden las tabulaciones cuando posteo, sorry;                                

[MChiz]

                                Me alegra que te interese el post : )

Sobre lo de que no notas mejora, pueden ser ( que ahora me acuerde ) por dos cosas:

1.- Lei por algun sitio que es mejor NO guardar los indices de la malla en la memoria de video. Prueba de guardar tan solo la malla, y los indices los mantienes en memoria RAM convencional. Yo lo he hecho asi, y no he probado el metodo que tu haces, de guardar los indices en memoria de video.

2.- El rendimiento no se nota porque estas pintando pocos triangulos, por lo tanto, no existe ningun cuello de botella con el procesado de la malla. Prueba a pintar 100.000 triangulos sin VBO y con. Ahi si que se nota : )

Tambien se pueden probar mas cosas, como usar Interleaved Arrays o cualquier cosa que se te pueda ocurrir. Tambien manda coordenadas de textura, colores, normales, ... en fin, que haya mucha transferencia por BUS. Es entonces cuando lo deberias notar ( en teoria ).

Expon aqui tus resultados!! : D                                

[Degiik]

                                He aumentado el numero de triangulos a dibujar hasta superar la cifra de 1 millon, pero no consigo mejores resultados. Más adelante tengo pensado incluir los vertex buffers en un programa mas completo ( texturas, normales, etc etc ) donde posiblemente si se note la mejora por el ' cuello de botella '. Ya dire algo cuando lo pruebe.

Una saludo.