Opengl, Shaders Y Blend

[zupervaca]

 alguien ha probado a realizar un render en opengl usando shaders y pasandole un vertice personalizado con por ejemplo blendweight o blendindices o tangent, etc. he estado mirando y no hay manera de que de un tiron le podamos decir que el formato del vertice tiene esos valores, la unica manera es renderizando triangulo a triangulo cambiandole valores al shader, he mirado algunos ejemplos de shaders que usan estos valores y pintan triangulo a triangulo, ¿esto tiene que ser asi o hay algun truco por ahi?

saludos

[zupervaca]

 bueno retomo este hilo de hace unos dias poniendo un mensaje en otro hilo por si Minos sabe solucionar mi problema, yo llevo tiempo intentando poder renderizar mallas sin tener que usar glVertex pero con el tema shaders me ha sido imposible, ya que no puedo definir al opengl donde esta el buffer de los blends, tangents, etc

los vertices en direct3d esten en la memoria de video como estaticos y en cambio en opengl siguen en la memoria ram ya te dire la diferencia

Eso es que no sabes usar bien las extensiones de OGL, en concreto ARB_VERTEX_BUFFER_OBJECT.

saludos

pd: esto no es en plan cachondeo, vamos que veo que sabes sobre opengl y sus extensiones

[ajmendoza]

 Zupervaca está dolido :P

[zupervaca]

 no en serio, que soy incapaz de hacer con vertexbuffer el tema shaders y minos parece que si sabe hacerlo, vamos que esto no es cachondeo, si sabe solucionar el tema podria cambiar todo el motor que tengo y fijo que esas 2000fps que pierdo en opengl se quedan 0fps  ;)

[Xam]

 Como te comento Minos, la extensión ARB_VERTEX_BUFFER_OBJECT (actualmente esta extensión forma parte del núcleo de OpenGl 2.0) te sirve para poder almacenar vértices ( y sus propiedades) en la memoria de video.

Pero me parece que lo que tu buscas es poder pasar (sin tener que hacerlo vértice a vértice) la información sobre vértices y sus propiedades de manera más eficiente. Para tener acceso a ella dentro de los shaders. Yo me miraría el capítulo 2.8, Vertex Arrays, de la especificación de OpenGl 2.0. Concretamente la función VertexAttribPointer( ... ) sería lo que buscas; te permite asociar información extra a un vértice (tangent space, ...).

Tengo pendiente ponerme con estas cosas, así que no he podido probar lo que te cuento. Pero no debería darte muchos problemas.

[zupervaca]

 si exactamente el problema que tengo es ese, voy a hechar un vistazo a lo que dices a ver si es la solucion

[Pogacha]

 El problema es que los shaders no son estandarts en openGL como lo son en DX, como ya dije antes para las placas viejas que no soportan GLSL, el tema de los parametros entran o por coordenandas de texturas, o por color primario o secundario o normal, tambien hay extensiones intermedias para placas que admiten pasar tangente y binormal, pero no he visto mucho sobre esto.
Los vertices definidos por el usuario de d3d o algo parecido se consigue con glVertexPointer, glTexcoordsPointer, glNormalPointer y glColorPointer, las cuales tienen varios parametros, entre ellos el stride, que es el desplazamiento de vertice a vertice, aqui debes poner el tamaño de la estructura.
http://oss.sgi.com/projects/ogl-sample/reg...ertex_array.txt

Al final hay que hacer algo como esto: ( el codigo es cualquier cosa, pero es la idea general de como se hace, probablemente este mal la sintaxys y el uso, pero es el camino )

Código [Seleccionar] Expand

#pragma push option pack // no es así pero es la idea
#pragma pack BYTE    // esto menos

struct MiVertice
{
 Vector3d Posicion;
 Vector2d Texcoord;
 Vector3d Normal;
 Vector4d Color;
};

MiVertice Vertices[1000];

#pragma pop option pack // espero se entienda

glVertexPointerEXT(3, GLFLOAT,  sizeof(MiVertice), 1000,  &Vertices[0].Posicion);
glNormalPointerEXT(3, GLFLOAT,  sizeof(MiVertice), 1000,  &Vertices[0].Normal);
glColorPointerEXT(4, GLFLOAT,  sizeof(MiVertice), 1000,  &Vertices[0].Color);
glTexCoordPointerEXT(2, GLFLOAT,  sizeof(MiVertice), 1000,  &Vertices[0].TexCoord);

glEnable(GL_VERTEX_POINTER_ARRAY);
 ...
DrawArraysEXT(GL_TRIANGLES,     0,   1000);


El codigo de arriba es para tener un Vertice estructurado, si tienes vectores paralelos puedes pones en el stride el tamaño del atributo nuevamente ...

Luego salio GLSL la de glAtribsPointerARB o algo así ... pero yo no la usé nunca ... que ahí puedes meter atributos genericos ...

Me olvidaba!, VertexBufferObject sirve para tener paquetes de vertexs en memoria de video, pero de todas formas para acceder a ellos debes usar los glVertexPointer pero en la direccion de memoria en vez de poner la direccion en ram pones la direccion en video ...

Saludos.

[zupervaca]

 si efectivamente hasta ahora siempre lo habia hecho asi, pero me encuentro en el problema de enviar el blendweight al shader, he mirado el vertexattrib y parece que se meten en la memoria ram osea que en principio mal rollo para recuperar esos 2000fps con este sistema, me parece que voy a mirar glAtribsPointerARB que puede que me sirva, gracias

[Xam]

 Claro, el puntero que pasas a glVertexAttribPointer( ... ) es un puntero a memoria de sistema. Pero, como ya te ha comentado Pogacha, ese puntero que pasas se puede "mapear" en memoria de video mediante buffer objects (también forman parte del núcleo de OpenGl 2.0, o los puedes utilizar mediante extensión. La extensión ARB_VERTEX_BUFFER_OBJECT que comentaba Minos). Mírate el capítulo 2.9, Buffer Objects, en la especificación de OpenGl 2.0, seguro que te ayuda.

[Haddd]

 Yo no tengo ni idea de OGL 2.0, pero por lo que sé de OGL, seguro que lo han pensado, y lo han pensando bien. Seguro que ellos tienen la mejor forma de hacerlo  :P  

[Minos]

 Bueno, te dejo tutos y docs que espero que te sirvan.

humus Empieza por aqui, muchos ejemplos, este tio es la...
lighthouse3d Tutorial de GLSL con muchos ejemplos.
opengl.nutty.org Mas ejemplos.
3dlabs Informacion general sobre GLSL.
codesampler Mas ejemplos aunque no se si estos te valdran.

Ahora mismo no tengo mucho tiempo a ver si cuando tenga leo mejor el post, echo mano del orange book (te lo recomiendo, sobre GLSL) e intento responder mejor.

PD: Siento haber tardado tanto

[Minos]

 De Ogre3D, OgreGLRenderSystem.cpp

Código [Seleccionar] Expand


case VES_BLEND_INDICES:
               assert(mCapabilities->hasCapability(RSC_VERTEX_PROGRAM));
               glVertexAttribPointerARB_ptr(
                   7, // matrix indices are vertex attribute 7 (no def?)
                   VertexElement::getTypeCount(elem->getType()),
                   GLHardwareBufferManager::getGLType(elem->getType()),
                   GL_FALSE, // normalisation disabled
                   static_cast<GLsizei>(vertexBuffer->getVertexSize()),
                   pBufferData);
               glEnableVertexAttribArrayARB_ptr(7);
               break;
           case VES_BLEND_WEIGHTS:
               assert(mCapabilities->hasCapability(RSC_VERTEX_PROGRAM));
               glVertexAttribPointerARB_ptr(
                   1, // weights are vertex attribute 1 (no def?)
                   VertexElement::getTypeCount(elem->getType()),
                   GLHardwareBufferManager::getGLType(elem->getType()),
                   GL_FALSE, // normalisation disabled
                   static_cast<GLsizei>(vertexBuffer->getVertexSize()),
                   pBufferData);
               glEnableVertexAttribArrayARB_ptr(1);
               break;
           default:


Asi que lo que creo que estas buscando es glVertexAttribPointer, usca informacion de las misma. Para cualquier cosa que te pueda ayudar aqui estoy.

Saludos

[visualcubb]

 Hola colegas, el problema que tiene zupervaca es muy común con OpenGL, sobre todo si quieres usar GL_VERTEX_BUFFER_OBJECT, la razón de esto es que esta extensión hasta donde tengo claro solo guarda en memoria los arreglos que corresponden a propiedades primitivas de los polígonos, como los vértices, las texturas, las UV, las normales y el color, si quieres agregar un arreglo más, ese se queda en ram de sistema y no de video, lo que merma es rendimiento. Pero esto va a cambiar con la nueva extensión que todavía no se termina que se llama "GL_SUPER_BUFFER" donde vas a poder enviar a memoria todo lo que quieras.

Para resolver tu problema colega hay varios trucos, por ejemplo, si no estás usando el color, o si todos los vertices son del mismo color, puedes usar ese arreglo para enviar el blending, lo mismo con las normales, he incluso, los vertices tienen una cuarta coordenada que puedes usar al igual que las coordenadas de texturas que nunca se usan, como la tercera y cuarta (uvzw me parece que es el orden).

Es muy común ven en códigos de ejemplo trucos como ese, ahora si quieres usar binormales y tangentes te recomiendo calcularlas en el mismo shader, no vale la pena desperdiciar ancho de banda en algo que puedes calcular en el mismo shader.

Ojalá te haya servido de algo este comentario.

[visualcubb]

 Otra cosa, ese asunto de los 2000 fps depende de varios factores:

1.- Depende de tu versión de drivers.
2.- Depende de tu tarjeta de video, si tienes una Nvidia, OpenGL correrá mejor que DirectX, si tienes una ATI viceversa.
3.- Depende de si tienes o no desactivado Vsync, esto reduce el rendimiento por la sincronia con el monitor.
4.- Depende de como tengas configurados tus drivers, recuerda que tienen opciones para OpenGL y Direct X.
5.- Depende si estás usando intensamente pixel o vertex shaders, Nvidia es mejor para los pshaders y Ati para los vshaders.

Saludos.

[vincent]

3.- Depende de si tienes o no desactivado Vsync, esto reduce el rendimiento por la sincronia con el monitor.

Si tiene activado el Vsync le tendria que ir a la frequencia del monitor, no?