P-buffers Con Rtt

[MA]Mestre]

 Buenas,

He implemetado P-Buffers para hacer un RTT. Cuando utilizo la textura del RTT para pastearla aparece invertida. ( tal y como la invierte el formato bmp )  :huh:  Las coordenadas de textura estan bien.

Alguna idea ?

[davidib]

 ¿has probado a poner una altura negativa?

[Haddd]

 P-Buffers? RTT?  :blink:  ¿Qué es eso?

[Prompt]

 P-Buffer: es un Buffer q usa GLX(en linux) o las ventanitas de windows, como su nombre indica es un buffer pero con algo de especial, cuando almacenas algo en el, se almacena en la memoria de la tarjeta grafica, puedes meter lo q sea, incluso renderizar en ese Buffer fuera de pantalla! (simulando tecnicas q tu tarjeta no soportaria, por software claro).

RTT: Render To Texture

Sobre lo de la textura invertida, mira bien los TexCord.

[MA]Mestre]

 Un P-Buffer, es un buffer off-screen como ya comenta Prompt. Tiene muchas utilidades entre ellas hacer un Render To Texture ( RTT ).

P-Buffers
http://developer.nvidia.com/object/PBuffer..._OffScreen.html
http://developer.nvidia.com/object/gdc2001...xelbuffers.html

RTT con P-Buffers
http://developer.nvidia.com/object/ogl_rtt.html

¿has probado a poner una altura negativa?

No entiendo lo que me quieres decir, de todas formas dejo como hago los renders.

En el P-buufer:

glBegin (GL_TRIANGLES);
glVertex3f (0.0f,5.0f,-15.0f);
glVertex3f (5.0f,-5.0f,-15.0f);
glVertex3f (-5.0f,-5.0f,-15.0f);
glEnd ();



En el Front Buffer

glEnable (GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, rtt.GetTexture());
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(1.0f, 1.0f); glVertex3f(-5.0f,5.0f,-15.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(-5.0f,-5.0f,-15.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f(5.0f,5.0f,-15.0f);
glTexCoord2f(0.0f, 0.0f); glVertex3f(5.0f,-5.0f,-15.0f);
glEnd();
glDisable(GL_TEXTURE_2D);

Como podeis ver he tenido que modificar las coordenadas de textura para que se vea correctamente la textrua. Sino apareceria invertida arriba-abajo.

Un saludo.

[_Grey]

 Igual me meo fuera, pero....

En OpenGL las coordenadas de(en la) textura son diferentes a lo habitual en graficos 2D, la coordenada 0,0 no es la superior-izquierda sino la inferior-izquierda y la y se incrementa hacia arriba y no hacia abajo, igual es algo de esto.

Saludos.

[MA]Mestre]

 ...pos va a ser eso Grey... thanks.

[tamat]

 Refloto este thread porque me acabo de encontrar con un problema relacionado con el RTT.

Uso SDL y OGL y veo que la extensión de nvidia para hacer render to texture requiere del HDC*, pero yo uso SDL y tengo interes en que sea crossplatform. Sé que SDL tiene algun mecanismo para obtener el DC de windows pero  me gustaría mantenerme al margen.

Alguien me puede dar algun consejo? Me gustaría poder renderizar la escena aparte y luego obtenerla como textura. Cual es el mejor método? a poder ser usando extensiones para que vaya rapido.

Gracias.

[DraKKaR]

 ¿Porqué no usas Framebuffer Objects en vez de PBuffers para el RTT?Son mucho más rápidos, portables y cómodos de utilizar y ya deberían estar soportados por los drivers actuales (he probado con nvidia y ati y bien). Es lo que utilizo para los shadow maps en el motor. La única pega es que he tenido algún problemilla con FBO+Stencil.

Tamat: con los FBO son cosa de OpenGL , no tiene nada que ver con el SO, por lo tanto nonecesitas el HDC para nada.

[zupervaca]

 Aprovecho el hilo, actualmente estoy desarrollando cosas en opengl+linux, ¿funcionan los pbuffers o los fbo con drivers de tarjetas graficas que soporten shades? (menciono shaders para descartar todas las tarjetas graficas de hace unos años)

En algunos foros la gente dice que tiene problemas con linux+fbo, pero parece que estos son mas rapidos que los pbuffers ya que son solo para hacer los render targets.

[Ithaqua]

 Ahora mismo los FBO son la mejor manera de realizar renders a textura en OpenGL (adios pbuffers o glCopyTexImage2d, por fin), y sí, las soportan todas las tarjetas actuales mientras tengas instalados unos drivers medianamente recientes. Son extremadamente sencillos de implementar y muy flexibles.

Drakkar: podrías detallar que problema tienes con el stencil? Yo si en un framebuffer creo un renderbuffer de tipo stencil, y lo activo, no me renderiza correctamente y en según que versiones de driver incluso petaba.

[tamat]

 Si no es mucho pedir alguien podría resumirme un poco cómo funcionan los Frame Objects? Todo cuanto he encontrado es el powerpoint de Nvidia pero me hago un lio.

Lo que entiendo es que un frameobjects es una manera de wrappear el contexto de render, para poder meter dentro difernetes regiones de memoria que actuaran como colorbuffer, depthbuffer, etc.
Pero hay varias cosas que no entiendo:
- Qué es un renderbuffer? por renderbuffer se refiere a región 2D de la memoria de la GPU donde se guarda la información? Puede un renderbuffer usarse para color o para depth?
- Para qué serviría tener más de un framebuffer?
- Un framebuffer solo tiene asociado un color buffer, un depthbuffer, un accumulation, etc o puede tener más de uno?

Muchas gracias.

[DraKKaR]

 Ithaqua: el problema era que no me dejaba configurar un FBO con attachements de color + depth + stencil. Buceando por internet la gente hablaba de que para utilizar FBO+depth+stencil había que usar la extensión  EXT_packed_depth_stencil. Al parecer esto era así porque el hardware actual intercala en un mismo buffer de 32 bits los buffers de profundidad y de stencil (24+8 bits) por temos de velocidad.

Usando esta extensión me dejó configurar el FBO con color+depth+stencil. Sin embargo el stencil buffer no se comportaba bien. Cambiando el FBO por un Pbuffer con stencil SÍ funcionaba bien (con extactamente las mismas instrucciones de manejo del stencil buffer). Así que al final me tuve que conformar con usar PBuffer SOLO cuando se requiere el stencil buffer para RTT. De esto ya hace unos meses, así que puede que ya estén solucionados estos temas. Si alguien conoce la verdad me gustaría saberlo ;)

tamat:
- un frame buffer object es una colección de buffers donde el usuario destina el resultado de sus renders (resultados de color, profundidad...). Un FBO admite varios buffers porque hay varios resultados que almacenar: color + profundidad + stencil...

- Cada uno de estos buffers puede ser de 2 tipos:
-- un renderbuffer que es simplemente un buffer de destino dentro del FBO
-- una textura

Generalmente para un attachment de un FBO usaras una textura 2D como buffer si quieres reutilizarla en futuros renders como una textura más. Si no va a ser así, el attachment lo configuras como renderbuffer.

Por ejemplo, podrías tener un FBO compuesto de 3 attachments:
- un texture2d para el color (para reutilizarlo como textura para lo que sea)
- un renderbuffer para el depth buffer
- un renderbuffer para el stencil buffer


Un framebuffer SOLO puede tener un buffer de profundiad asociado. SOLO uno de stencil. En cambio puede tener hasta 4 buffers de color por lo del Multiple Render Target.


¿Te he aclarado algo?

[tamat]

 Ok, creo que pillo la idea. Entonces a la hora de adaptarlo a mi framework lo que debería hacer es (y corrigeme si me equivoco):
- Al inicializar OGL creo el FBO pero asocio los renderbuffers normales. Esto supongo que no me supondrá ningun tipo de lastre para mi aplicacion, es decir, la velocidad de renderizado seguirá siendo la misma.
- Si en algun momento necesito un render a Texture creo una textura y la engancho a mi framebuffer object como colorbuffer. Renderizo la escena, y vuelvo a asociar el Renderbuffer de la pantalla.

Así de simple?

[Ithaqua]

 Básicamente todo empieza por crear un framebuffer object (glGenFramebuffersEXT), que es como el "contenedor" de los diferentes tipos de renderbuffer.
Una vez hecho ésto, puedes crear dentro de él los 3 tipos principales de renderbuffer, que sí son conceptualmente como las regiones de memoria donde vas a renderizar. Los tipos son color, depth y stencil.
Para cada uno de ellos necesitas crearlo (glGenRenderbuffersEXT) y hacer el bind correspondiente para configurarlo (glBindRenderbufferEXT). Y o bien pueden ser una zona de memoria nueva (definida con glRenderbufferStorageEXT) o una textura ya creada a la que se va a renderizar. Si vas a activarlo en el primer caso sería con glFramebufferRenderbufferEXT y en el segundo con glFramebufferTexture2DEXT.

Ejemplo de render a textura de color, con depth buffer y sin stencil:

Código [Seleccionar] Expand



int nWidth = 512;
int nHeight = 512;

// Handles
GLuint uglFBOHandle;
GLuint uglDepthRBOHandle;

// Creamos el framebuffer
glGenFramebuffersEXT(1, &uglFBOHandle);

// Creamos el render buffer object para el depth, y lo configuramos
glGenRenderbuffersEXT(1, &uglDepthRBOHandle);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, uglDepthRBOHandle);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT24, nWidth, nHeight);



En el render haríamos lo siguiente:

Código [Seleccionar] Expand



// Activamos el framebuffer
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, uglFBOHandle);

// "attacheamos" una textura ya creada al color renderbuffer
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, uMiTexturaGL, 0);

// "attacheamos" el depth renderbuffer
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, uglDepthRBOHandle);

// Renderizamos, y el resultado va directamente a nuestra textura de color:
RenderScene();

// Restauramos el framebuffer por defecto
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);



Luego al salir:

Código [Seleccionar] Expand



glDeleteFramebuffersEXT(1, &uglFBOHandle);
glDeleteRenderbuffersEXT(1, &uglDepthRBOHandle);



Eso sería un ejemplo básico de RTT sin chequeo de errores (mirate glCheckFramebufferStatusEXT entre otras cosas).
En otros casos, por ejemplo para hacer shadow mapping, lo que habría que hacer sería attachear una textura de tipo depth al depth renderbuffer.

Una nota para el depth: En NVidia he visto que se soporta el GL_DEPTH_COMPONENT24, mientras que en ATI GL_DEPTH_COMPONENT16, así que conviene chequear antes :)