OpenGL - Rendering in una trama

Question

Desidero essere in grado di eseguire il rendering di qualcosa in una trama, su OpenGL, in modo da poterlo utilizzare ulteriormente quando lo desidero, senza eseguire nuovamente il rendering. Questo sito Web here mi ha fornito le linee guida per farlo, senza utilizzare FrameBuffer. Non voglio farlo con il FrameBuffer Object a causa di problemi di compatibilità, dal momento che questa vecchia macchina non lo supporta. Ho fatto un po 'di codice, che crea la mia texture, rende la mia scena, e poi creo un Quad per renderizzare la trama su di esso. L'unico problema è che la texture viene sottoposta a rendering come una "maschera alfa", significa, sembra che stia prendendo in considerazione solo il valore alfa, mantenendo sempre il mio rettangolo con lo stesso colore, ma semplicemente cambiando la trasparenza su pixel. Ecco il codice che ho fatto finora:

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; 
} 

Poi:

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

E infine:

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

Il DrawScene() funzione rende semplicemente un rettangolo con un triangolo su in alto, con ogni vertice che ha colori diversi .. niente di speciale.

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

ho trovato qualcosa sul sito nVidia che sembra utile, per chi non può fare anche fuori campo di rendering con FBO:

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

Questa ragnatele esso contiene un progetto chiamato "Simple P-Buffer", che contiene fondamentalmente un'implementazione di un P-buffer. L'idea dell'esempio è che tu cambi il contesto passando a pBuffer, mentre vuoi disegnare pixel in modalità non in linea, diciamo. Dopo aver disegnato la scena con le normali funzioni di rendering, utilizziamo glReadPixels per leggere i dati dal pBuffer in una matrice di byte senza segno (GLubyte). Dopodiché, facciamo di nuovo il cambio di contesto, riportandolo al contesto dello schermo, in modo che tu possa usare glReadPixels per leggere il contenuto dal nostro array.

Answer 2

Procedimento prima OSA erano disponibili era di utilizzare un alternativo rendering tampone (see glDrawBuffer(GL_AUX0), quindi copiare pixel da detto tampone (see glReadBuffer) alla struttura (see glCopyTexImage2D. Rendering direttamente in un tessuto richiede OSA.