Opengl es2 no iphone. Alguns objetos são feitos com várias camadas de sprites com alfas.

Então eu também tenho elementos de interface do usuário que também são compostos juntos de vários sprites que eu entro / saio por cima de todo o resto. Eu faço o desbotamento, ajustando o alfa no shader.

Minhas texturas são PNG com alpha feitas no photoshop. Eu não os levo de propósito. Eu quero que eles sejam alpha, mas no meu aplicativo eles estão agindo como se fossem pré-multiplicados, onde eu posso ver uma borda escura em torno de um sprite branco desenhado sobre um fundo branco.

Se eu definir meu modo de mesclagem para:

glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);

Os elementos combinam bem juntos, sem bordas estranhas. Mas quando os elementos estão desaparecendo, eles POP no final. Eles começarão a desaparecer, mas não irão até o zero. Então, no final da animação de fadeout, quando removo os elementos, eles "surgem" porque não estão completamente desbotados.

Se eu mudar meu modo de mesclagem para:

glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

Os elementos desaparecem bem. Mas qualquer elemento branco sobre branco tem uma borda escura ao redor do que parece uma pré-multiplicação alfa. Veja o círculo branco desenhado por cima da caixa branca:

Mas as outras misturas na cena parecem boas para mim. Os outros objetos transparentes se misturam bem.

Outra nota importante é que meu shader lida com a opacidade de elementos e elementos de colorização. Para cada coisa que é desenhada eu multiplico por uma cor de elemento e o alfa final com um valor de opacidade:

void main(void)
{
    gl_FragColor = texture2D(u_textureSampler,v_fragmentTexCoord0);
    gl_FragColor = vec4(gl_FragColor.r*u_baseColor.r,gl_FragColor.g*u_baseColor.g,gl_FragColor.b*u_baseColor.b,gl_FragColor.a*u_baseColor.a * u_opacity);
}

Isso me permite pegar um objeto branco na minha folha de sprite e fazer qualquer cor que eu quiser. Ou escureça objetos usando uma baseColor de cinza.

Toda vez que eu acho que entendo esses modos de mistura, algo assim surge e eu começo a duvidar de mim mesmo.

Existe alguma outra combinação de modo de mesclagem que terá bordas suaves em meus sprites e também suportará desvanecimento / mesclagem alfa no shader?

Eu estou supondo que o GL_SRC_ALPHA é necessário para misturar usando alfa no shader.

Ou o meu problema é que eu preciso usar algo diferente de PSD para salvar minha folha de sprite? Porque isso seria quase impossível neste momento.

ATUALIZAR:

Eu acho que a resposta pode ser apenas NÃO, que não há como fazer o que eu quero. O segundo modo de mesclagem deve estar correto. Mas é possível que ele duplique o RGB com o alpha em algum lugar, ou que seja pré-multiplicado no arquivo de origem. Eu até tentei pré-multiplicar o alpha no shader acima adicionando:

gl_FragColor.rgb *= glFragColor.a;

Mas isso faz com que os desvanecimentos pareçam ruins, pois as coisas ficam cinza quando desaparecem. Se eu pré-multiplicar o alpha e usar o outro modo de mesclagem acima, as coisas serão mais ou menos as mesmas do meu original. Eles desaparecem sem estourar, mas você ainda pode ver o halo.