Usar alfa de textura para dibujar un color sólido

Question

¿Cómo puedo usar OpenGLES 1.1 (iPhone) para dibujar una textura, pero solo usando el alfa para dibujar algo de color?

El resultado debe ser exactamente la misma máscara alfa de la textura original, con un único color sólido dentro en lugar de los colores originales.

Estoy usando glDrawArrays con glCoordPointer y glVertexPointer.

Creo que hacer dos pases, uno con la textura y otro con un color sólido para esto. Simplemente no puedo encontrar la inversión de glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_ALPHA);.

Editar: después de mirar un poco más, creo que esto debería ser posible con glTexEnvf. Es solo cuestión de encontrar los argumentos correctos.

Answer 1

Como se mencionó, glTexEnv es el camino a seguir.

Para sustituir los componentes RGB de su textura y mantener intacta su alfa, podría intentar algo como esto (el código utiliza el rojo como color de sustitución):

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

glActiveTexture(GL_TEXTURE_0); 
glEnable(GL_TEXTURE_2D); 
glBindTexture(GL_TEXTURE_2D, spriteTexture); 

glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE); 

glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE); 
glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_PREVIOUS); 
glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_TEXTURE); 
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR); 
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR); 

// ... draw as usual 

Aquí vienen algunas explicaciones.

Al usar GL_COMBINE, tiene control completo sobre cómo la entrada/salida de las diferentes etapas de textura se combinan juntas. En este caso, especificamos que queremos reemplazar (GL_REPLACE) los componentes RGB de la etapa de textura 0 con lo que viene de la etapa anterior (GL_PREVIOUS) que en este caso es un color único (establecido con glColor4f).

No establecimos nada especial para el componente alfa ya que queremos el comportamiento normal. Añadiendo las siguientes líneas habría tenido el mismo efecto que si no está incluido (comportamiento predeterminado):

glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE); 
glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_PREVIOUS); 
glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_ALPHA, GL_TEXTURE); 
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA); 
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA); 

Answer 2

Si puede usar OpenGL ES 2.0, puede hacerlo con un sombreador de fragmentos personalizado. Si está utilizando un marco basado en 1.1 o está apuntando a dispositivos que no son compatibles con 2.0, esto no será de mucha ayuda. Pero si se puede, así es como se hace:

uniform lowp sampler2D sampler; // which texture unit to use 
uniform lowp vec4 solidColor; 

varying highp vec2 fragmentTexCoord; 

void main() 
{ 
    // Get the color with an alpha of zero 
    vec4 color = vec4(1,1,1,0) * solidColor; 
    // Get the alpha from the texture, zero the r,g,b components 
    vec4 alpha = vec4(0,0,0,1) * texture2D(sampler, fragmentTexCoord); 
    // their sum is the solid color with the alpha mask of the texture 
    gl_FragColor = color + alpha; 
} 

Si se puede garantizar la solidColor tiene un alfa de cero se podría omitir el paso de multiplicación.

Answer 3

glBlendFunc(source_factor, dest_factor) se traduce en:

dest= source*source_factor + dest*dest_factor 

Así glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_ALPHA) es:

dest= source*0 + dest*(1 - source.alpha) 

El segundo pase (que no es el inverso) debe ser glBlendFunc(GL_SRC_ALPHA, GL_ONE):

dest= source*source.alpha + dest 

ya que ya aplicó la máscara alfa en el primer pase. Aunque todavía necesita averiguar cómo aplicar un color constante con alfa en lugar de la textura de origen.