Textura translúcida OpenGL sobre otra textura

Question

Obtuve 2 imágenes png, que se utilizan como texturas en una aplicación Qt/C++ 2D OpenGL. El primero se usa como un tipo de terreno "medio" y el segundo se usa como un "objeto" que se representa "ontop" (Nota: todos tienen el mismo valor z atm, obtengo el comportamiento deseado al representarlo en un orden definido). El "objeto" -textura es parcialmente translúcido. La textura de "middleground" es en su mayoría sólida. El problema es que la parte translúcida de mi textura de "objeto" tiene el color de fondo sólido y no la textura de "plano intermedio".

¿Algún consejo sobre cómo lograr esto?

Siguiendo falgs OpenGL se utilizan para mis texturas de renderizado

glEnable (GL_TEXTURE_2D); 
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); 
glEnable (GL_BLEND); 
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 

Gracias por cualquier ayuda.

Editar:

Más código:

glColor4f(1.0f, 1.0f, 1.0f, 1.0f); 

glEnable(GL_DEPTH_TEST); 
glDepthMask(GL_TRUE); 

glEnable(GL_ALPHA_TEST); 
glAlphaFunc(GL_GREATER, 0.1f); 

glEnable(GL_TEXTURE_2D); 
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); 
glBindTexture(GL_TEXTURE_2D, c->_texture); 

glEnable(GL_BLEND); 
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); 

glBegin(GL_QUADS); 
{ 
    glTexCoord2i(0,0); 
    glVertex2i(-128,-128); 

    glTexCoord2i(0,1); 
    glVertex2i(-128,128); 

    glTexCoord2i(1,1); 
    glVertex2i(128,128); 

    glTexCoord2i(1,0); 
    glVertex2i(128,-128); 

} 
glEnd(); 

glDisable(GL_TEXTURE_2D); 

glDisable(GL_ALPHA_TEST); 
glDisable(GL_DEPTH_TEST); 

Editar: ¿Cómo cargo mi textura y por lo que yo puedo decir que lo carga con el canal alfa

QImage img("./images/dummycar.png","PNG"); 
QImage t(QGLWidget::convertToGLFormat(img)); 
glGenTextures(1, &_texture); 
glBindTexture(GL_TEXTURE_2D, _texture); 
glTexImage2D(GL_TEXTURE_2D, 0, 3, t.width(), t.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, t.bits()); 
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); 
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); 
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); 

Captura de pantalla : http://img824.imageshack.us/img824/1912/blackbox.png

El Skyimage es el "segundo plano", el fondo es negro sólido.

Answer 1

glTexImage2D(GL_TEXTURE_2D, 0, 3, t.width(), t.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, t.bits()); 

Usted está especificando 3 canales para el internalFormat, por lo que es RGB, RGBA no. Intenta usar GL_RGBA en esa posición.

Answer 2

¿Ha intentado tocar el violín con glAlphaFunc? Puede usarlo para descartar el dibujo de las partes translúcidas de la textura de su objeto en función del valor alfa.

¿Qué pasa con cualquiera

glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND)

o

glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE)?

Espero que ayude.

Answer 3

Si está procesando una textura por objeto, entonces necesita usar glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE).

Si la textura todavía tiene "caja" alrededor, incluso después de eso, se cargó sin canal alfa.

funciona esto perfectamente para mí:

textura

glEnable(GL_BLEND); 
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 
    glBindTexture(GL_TEXTURE_2D, texture2->tex); 
    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); 
    glColor4f(0.5f, 1.0f, 0.5f, 0.5f); 
    glBegin(GL_TRIANGLE_FAN); 
    glTexCoord2f(0, 0); 
    glVertex2f(x, y); 
    glTexCoord2f(1, 0); 
    glVertex2f(x + texture2->width, y); 
    glTexCoord2f(1, 1); 
    glVertex2f(x + texture2->width, y+ texture2->height); 
    glTexCoord2f(0, 1); 
    glVertex2f(x, y + texture2->height); 
    glEnd(); 
    glDisable(GL_BLEND); 

semitransparente, teñido por último color.

Si "tener una caja alrededor de la textura" no describe su problema, entonces necesita publicar capturas de pantalla.

--EDIT--

Datos actualizados basados ​​en your screenshot.

Necesita PRIMERO renderizar el fondo, y luego renderizar el automóvil. Verá el color de fondo porque incluso si la superficie es transparente, rellena z-buffer con valores, y como el fondo está debajo del carro, se vuelve invisible.

Cuando está renderizando objetos semitransparentes, debe seguir esas reglas.

1. Todos los objetos no transparentes deben representarse antes que los objetos semitransparentes. Siempre.

2. Todos los objetos transparentes deben representarse en el objeto de atrás hacia adelante. Los objetos más alejados deberían representarse primero, los objetos más cercanos deberían representarse en segundo lugar.

3. Si no es posible el renderizado en orden de retorno (partículas sin clasificar con combinación GL_ADD), la escritura en el búfer de profundidad debe desactivarse utilizando glDepthMask (GL_FALSE). Si no lo haces, obtendrás artefactos feos. (como el de tu captura de pantalla).