OpenGL - Interpretación en una textura

Question

Quiero ser capaz de representar algo en una textura, en OpenGL, para que pueda usarlo cuando quiera, sin volver a renderizar todo. Este sitio web here me dio las pautas para hacerlo, sin usar FrameBuffer. No quiero hacerlo con el objeto FrameBuffer debido a problemas de compatibilidad, ya que esta máquina vieja no lo admite. He hecho algo de código, que crea mi textura, representa mi escena y luego creo un Cuadrángulo para representar la textura en él. El único problema es que la textura se representa como una "Máscara alfa", es decir, parece que solo tiene en cuenta el valor alfa, manteniendo mi rectángulo siempre con el mismo color, pero simplemente cambiando la transparencia en píxeles. Aquí hay un código que he hecho hasta ahora:

void CreateTexture() 
{ 
    xSize = 512; 
    ySize = 512; //size of texture 
//new array 
    char* colorBits = new char[ xSize * ySize * 3 ]; 
//texture creation.. 
    glGenTextures(1,&texture); 
    glBindTexture(GL_TEXTURE_2D,texture); 
    glTexImage2D(GL_TEXTURE_2D,0 ,3 , xSize, 
       ySize, 0 , GL_RGB, 
       GL_UNSIGNED_BYTE, colorBits); 
//you can set other texture parameters if you want 
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_LINEAR); 
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR); 
//clean up 
    delete[] colorBits; 
} 

continuación:

int viewport[4]; 
    glGetIntegerv(GL_VIEWPORT,(int*)viewport); 
    glViewport(0,0,xSize,ySize); 


    DrawScene(hDC); 

    //save data to texture using glCopyTexImage2D 
    glBindTexture(GL_TEXTURE_2D,texture); 

    glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 
        0,0, xSize, ySize, 0); 
    glClearColor(.0f, 0.5f, 0.5f, 1.0f);    // Set The Clear Color To Medium Blue 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 

    glViewport(viewport[0],viewport[1],viewport[2],viewport[3]); 
    // glBindTexture(GL_TEXTURE_2D,texture); 

Y por último:

glEnable(GL_TEXTURE_2D);     // Enable 2D Texture Mapping 
     glBlendFunc(GL_DST_COLOR,GL_ONE);    // Set Blending Mode 
     glEnable(GL_BLEND); 

     glClear(GL_COLOR_BUFFER_BIT); 
     glBindTexture(GL_TEXTURE_2D,texture); 

     glRotatef(theta, 0.0f, 0.0f, 0.01f); 
     glBegin(GL_QUADS); 
     //Front Face 
     glTexCoord2f(0.0f, 0.0f); 
     glVertex3f(-0.5, -0.5f, 0.5f); 
     glTexCoord2f(1.0f, 0.0f); 
     glVertex3f(0.5f, -0.5f, 0.5f); 
     glTexCoord2f(1.0f, 1.0f); 
     glVertex3f(0.5f, 0.5f, 0.5f); 
     glTexCoord2f(0.0f, 1.0f); 
     glVertex3f(-0.5f, 0.5f, 0.5f); 
     glEnd(); 
     SwapBuffers(hDC); 

El drawScene() función simplemente hace un rectángulo con un triángulo en encima de ella, con cada vertice teniendo colores diferentes ... nada especial.

glClearColor(0.0f, 0.0f, 0.0f, 0.0f); 
glClear(GL_COLOR_BUFFER_BIT);//| GL_DEPTH_BUFFER_BIT); 

glPushMatrix(); 
// glRotatef(theta, 0.0f, 0.0f, 1.0f); 

glBegin(GL_QUADS); 
glColor3f(1.0f, 0.0f, 0.0f); 
glVertex3f(-1.0f, -1.0f, 1.0f); 
glColor3f(0.0f, 1.0f, 0.0f); 
glVertex3f(1.0f, -1.0f, 1.0f); 
glColor3f(0.0f, 0.0f, 1.0f); 
glVertex3f(1.0f, 1.0f, 1.0f); 
glColor3f(1.0f, 1.0f, 1.0f); 
glVertex3f(-1.0f, 1.0f, 1.0f); 
glEnd(); 

glBegin(GL_TRIANGLES); 

glColor3f(1.0f, 0.0f, 0.0f); 
glVertex2f(0.0f, 1.0f); 
glColor3f(0.0f, 1.0f, 0.0f); 
glVertex2f(0.87f, -0.5f); 
glColor3f(0.0f, 0.0f, 1.0f); 
glVertex2f(-0.87f, -0.5f); 
glEnd(); 
glPopMatrix(); 

Answer 1

he encontrado algo en el sitio web de nVidia que parece útil, por alguien que no puede hacer también fuera de la pantalla de representación con OBF:

http://developer.download.nvidia.com/SDK/9.5/Samples/samples.html

Este telas ite contiene un proyecto llamado "Simple P-Buffer", que básicamente contiene una implementación de un P-buffer. La idea de la muestra es que hagas un cambio de contexto al pBuffer, mientras que quieres dibujar píxeles en modo fuera de pantalla, digamos. Después de dibujar su escena con las funciones de representación normales, usamos glReadPixels para leer los datos del pBuffer en una matriz de bytes sin firmar (GLubyte). Después de eso, hacemos un cambio de contexto una vez más, volviéndolo al contexto de la pantalla, para que pueda usar glReadPixels para leer el contenido de nuestra matriz.

Answer 2

El método antes OBF estaban disponibles era utilizar un suplente tampón (see glDrawBuffer(GL_AUX0) render, entonces copiar píxeles de ese tampón (see glReadBuffer) a la textura (see glCopyTexImage2D. Rendering directamente en una textura requiere OBF.