A combinação de cores, ou blending, é um recurso fundamental no OpenGL, frequentemente empregado para simular transparência. Contudo, sua flexibilidade permite uma vasta gama de efeitos visuais, desde a semi-transparência realista até composições de imagem mais abstratas.

Em sua essência, o blending mistura duas cores: a cor existente em um pixel (cor de destino) e a nova cor que será desenhada (cor fonte). O resultado é uma nova cor que reflete a interação entre ambas. Imagine visualizar um objeto verde através de um vidro vermelho semi-transparente. Primeiramente, o objeto verde é renderizado. Em seguida, ao desenhar o vidro vermelho, o blending mistura o vermelho do vidro com o verde do objeto, criando uma percepção de transparência.

Para ativar o recurso de combinação de cores no OpenGL, utiliza-se a função glEnable(GL_BLEND);. Para desativá-lo, chama-se glDisable(GL_BLEND);. É importante notar que o blending é funcional apenas em modos de cor RGBA; ele não está disponível em modos de índice de cor.

Fatores de Combinação (Source e Destination Factors)

O processo de blending envolve a combinação da cor fonte e da cor de destino através de uma fórmula. O OpenGL extrai os componentes (vermelho, verde, azul e alfa) de ambas as cores e os multiplica por coeficientes específicos, conhecidos como "fatores". O coeficiente aplicado à cor fonte é o "fator de fonte", e o aplicado à cor de destino é o "fator de destino". Os resultados dessas multiplicações são então somados para produzir a cor final do pixel. Embora versões mais recentes do OpenGL permitam diferentes operações (adição, subtração, mínimo, máximo, operações lógicas), a adição é a mais comum e será o foco aqui.

Matematicamente, se a cor fonte é (Rs, Gs, Bs, As) e a cor de destino é (Rd, Gd, Bd, Ad), e os fatores de fonte são (Sr, Sg, Sb, Sa) e os fatores de destino são (Dr, Dg, Db, Da), a cor resultante (Rf, Gf, Bf, Af) é calculada como:

• Rf = Rs * Sr + Rd * Dr
• Gf = Gs * Sg + Gd * Dg
• Bf = Bs * Sb + Bd * Db
• Af = As * Sa + Ad * Da

Os valores dos componentes de cor são automaticamente saturados para 1.0 se excederem esse limite.

Os fatores de fonte e destino são configurados usando a função glBlendFunc(GLenum sfactor, GLenum dfactor);, onde sfactor define o fator de fonte e dfactor define o fator de destino. Abaixo estão alguns dos valores mais utilizados:

• GL_ZERO: Usa 0.0 como fator, efetivamente excluindo a cor correspondente da combinação.
• GL_ONE: Usa 1.0 como fator, significando que a cor é totalmente utilizada na combinação.
• GL_SRC_ALPHA: O fator é o valor alfa da cor fonte.
• GL_DST_ALPHA: O fator é o valor alfa da cor de destino.
• GL_ONE_MINUS_SRC_ALPHA: O fator é 1.0 menos o valor alfa da cor fonte.
• GL_ONE_MINUS_DST_ALPHA: O fator é 1.0 menos o valor alfa da cor de destino.

Existem outros fatores como GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR, e em versões mais recentes, GL_CONST_COLOR, GL_ONE_MINUS_CONST_COLOR, GL_CONST_ALPHA, GL_ONE_MINUS_CONST_ALPHA e GL_SRC_ALPHA_SATURATE. Para fins introdutórios, focaremos nos mais comuns.

Exemplos de Configuração de Fatores:

• glBlendFunc(GL_ONE, GL_ZERO);: Apenas a cor fonte é utilizada, ignorando completamente a cor de destino. O resultado é idêntico a não usar blending, mas com um pequeno custo de desempenho. Esta é a configuração padrão se nenhuma outra for especificada.
• glBlendFunc(GL_ZERO, GL_ONE);: Apenas a cor de destino é utilizada. Qualquer tentativa de desenhar uma nova cor não terá efeito visível (embora possa ter usos específicos).
• glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);: Esta é a configuração mais comum para transparência. A cor fonte é multiplicada pelo seu próprio valor alfa, e a cor de destino é multiplicada por 1.0 - alfa_fonte. Quanto maior o alfa da fonte, mais a cor fonte contribui para o resultado final, e menos a cor de destino. O valor alfa aqui age como um "nível de opacidade".
• glBlendFunc(GL_ONE, GL_ONE);: As cores fonte e destino são simplesmente somadas. Por exemplo, vermelho (1,0,0) somado a verde (0,1,0) resulta em amarelo (1,1,0).

É crucial entender que as noções de "cor fonte" e "cor de destino" são determinadas pela ordem de renderização. O objeto desenhado primeiro estabelece a cor de destino, e os objetos subsequentes que se sobrepõem a ele fornecem a cor fonte. A sequência de desenho deve ser cuidadosamente planejada para que os fatores de combinação correspondam às cores apropriadas.

Exemplo de Blending 2D

Para ilustrar, desenharemos dois retângulos sobrepostos. Isso nos permitirá observar como as diferentes configurações de glBlendFunc afetam a área de interseção.

void renderizarCena2D(void) {
    glClear(GL_COLOR_BUFFER_BIT);

    glEnable(GL_BLEND);
    // Experimente as seguintes funcoes de blend:
    // glBlendFunc(GL_ONE, GL_ZERO); // Opacidade total da fonte
    // glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Transparencia baseada no alfa
    glBlendFunc(GL_ONE, GL_ONE); // Adicao de cores

    // Definir cor para o primeiro retangulo (vermelho)
    glColor4f(1.0f, 0.0f, 0.0f, 0.5f); // Vermelho com 50% de alfa
    glRectf(-1.0f, -1.0f, 0.5f, 0.5f);

    // Definir cor para o segundo retangulo (verde)
    glColor4f(0.0f, 1.0f, 0.0f, 0.5f); // Verde com 50% de alfa
    glRectf(-0.5f, -0.5f, 1.0f, 1.0f);

    glutSwapBuffers();
}

Ao testar as diferentes configurações de glBlendFunc:

• Com glBlendFunc(GL_ONE, GL_ZERO);, o segundo retângulo verde simplesmente cobre a parte do primeiro vermelho. A área de sobreposição é totalmente verde, como se não houvesse blending.
• Com glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);, ambos os retângulos aparecem semi-transparentes devido ao alfa de 0.5. Na área de sobreposição, as cores se misturam, e o fundo preto pode ser visível através deles.
• Com glBlendFunc(GL_ONE, GL_ONE);, a cor vermelha e a cor verde se somam na área de sobreposição, resultando em um tom amarelado.

Blending em Cenários 3D e Buffer de Profundidade

A aplicação de blending em ambientes 3D apresenta um desafio adicional: o buffer de profundidade (Z-buffer). O buffer de profundidade armazena informações sobre a distância de cada pixel renderizado em relação ao observador. Com o teste de profundidade habilitado, pixels mais próximos são desenhados, enquanto pixels mais distantes são descartados. Isso garante que objetos opacos mais próximos cubram objetos mais distantes, independentemente da ordem de desenho.

No entanto, para objetos transparentes, esse comportamento pode gerar artefatos. Se um objeto transparente próximo for desenhado, ele pode registrar sua profundidade no buffer, impedindo que objetos distantes que deveriam ser visíveis através dele sejam renderizados corretamente. O que se veria através do objeto transparente seria o fundo, e não o objeto distante.

Para contornar isso, é necessário gerenciar o buffer de profundidade de forma específica para objetos transparentes. A solução é renderizar primeiro todos os objetos opacos com o buffer de profundidade habilitado para escrita. Em seguida, para os objetos transparentes, o buffer de profundidade deve ser configurado como "somente leitura". Isso permite que os objetos transparentes sejam desenhados e combinados com o que já está na cena, sem alterar as informações de profundidade que poderiam bloquear a renderização de outros objetos distantes atrás deles. Após desenhar todos os objetos transparentes, o buffer de profundidade deve ser restaurado para o modo de leitura/escrita.

A ordem de desenho é ainda mais crítica em 3D. A regra geral é: **primeiro, renderize todos os objetos opacos**. A ordem entre os objetos opacos não importa. **Em seguida, renderize todos os objetos transparentes**, geralmente do mais distante para o mais próximo do observador, para garantir que o blending seja aplicado corretamente (o objeto mais distante é o destino, o mais próximo é a fonte).

A escrita no buffer de profundidade é controlada pelas funções:

• glDepthMask(GL_FALSE);: Desativa a escrita no buffer de profundiddae (somente leitura).
• glDepthMask(GL_TRUE);: Ativa a escrita no buffer de profundidade (leitura e escrita).

É importante ressaltar que simplesmente desabilitar o teste de profundidade com glDisable(GL_DEPTH_TEST); para objetos transparentes, como sugerido em alguns tutoriais antigos (inclusive em versões do famoso NeHe), é incorreto. Desabilitar o teste de profundidade faria com que um objeto transparente atrás de um objeto opaco fosse renderizado e combinado, mesmo que ele devesse estar completamente oculto pelo objeto opaco.

Exemplo de Blending 3D com Buffer de Profundidade

Vamos demonstrar com três esferas: uma vermelha opaca (mais distante), uma verde semi-transparente (intermediária) e uma azul semi-transparente (mais próxima). Para um toque de realismo, usaremos iluminação.

void configurarLuz(void) {
    static const GLfloat posicao_luz[] = {1.0f, 1.0f, -1.0f, 1.0f};
    static const GLfloat luz_ambiente[] = {0.2f, 0.2f, 0.2f, 1.0f};
    static const GLfloat luz_difusa[] = {1.0f, 1.0f, 1.0f, 1.0f};
    static const GLfloat luz_especular[] = {1.0f, 1.0f, 1.0f, 1.0f};

    glLightfv(GL_LIGHT0, GL_POSITION, posicao_luz);
    glLightfv(GL_LIGHT0, GL_AMBIENT, luz_ambiente);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, luz_difusa);
    glLightfv(GL_LIGHT0, GL_SPECULAR, luz_especular);

    glEnable(GL_LIGHT0);
    glEnable(GL_LIGHTING);
    glEnable(GL_DEPTH_TEST);
}

Cada esfera terá uma cor e material diferente. Uma função auxiliar para definir materiais simplifica o código:

void configurarMaterial(const GLfloat cor_difusa[4], GLfloat brilho_material) {
    static const GLfloat mat_especular[] = {0.0f, 0.0f, 0.0f, 1.0f};
    static const GLfloat mat_emissao[] = {0.0f, 0.0f, 0.0f, 1.0f};

    glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, cor_difusa);
    glMaterialfv(GL_FRONT, GL_SPECULAR, mat_especular);
    glMaterialfv(GL_FRONT, GL_EMISSION, mat_emissao);
    glMaterialf(GL_FRONT, GL_SHININESS, brilho_material);
}

Agora, a função principal de renderização. Para demonstrar a importância da ordem de desenho e do glDepthMask, vamos intencionalmente desenhar as esferas transparentes em uma ordem que *não* é da mais distante para a mais próxima (desenharemos a esfera azul mais próxima antes da verde intermediária), mas *corrigindo* a escrita do depth buffer.

void renderizarCena3D(void) {
    // Definicoes de cores de material
    const static GLfloat cor_vermelha_opaca[] = {1.0f, 0.0f, 0.0f, 1.0f};
    const static GLfloat cor_verde_transparente[] = {0.0f, 1.0f, 0.0f, 0.3333f};
    const static GLfloat cor_azul_transparente[] = {0.0f, 0.0f, 1.0f, 0.5f};

    // Limpar buffers de cor e profundidade
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // Configurar iluminacao
    configurarLuz();

    // Habilitar blending e definir fatores (usando SRC_ALPHA para transparencia)
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    // --- Parte 1: Desenhar objetos opacos ---
    // A esfera vermelha e opaca e a mais distante, entao eh desenhada primeiro.
    // A escrita no depth buffer esta ativada por padrao (GL_TRUE).
    configurarMaterial(cor_vermelha_opaca, 30.0f);
    glPushMatrix();
    glTranslatef(0.0f, 0.0f, 0.5f); // Posicao mais distante
    glutSolidSphere(0.3, 30, 30);
    glPopMatrix();

    // --- Parte 2: Desenhar objetos transparentes ---
    // Antes de desenhar objetos transparentes, desativamos a escrita no depth buffer.
    glDepthMask(GL_FALSE);

    // Esfera azul semi-transparente (mais proxima, desenhada fora de ordem 'distante-para-proxima')
    configurarMaterial(cor_azul_transparente, 30.0f);
    glPushMatrix();
    glTranslatef(0.2f, 0.0f, -0.5f); // Posicao mais proxima
    glutSolidSphere(0.2, 30, 30);
    glPopMatrix();

    // Esfera verde semi-transparente (entre a vermelha e a azul)
    configurarMaterial(cor_verde_transparente, 30.0f);
    glPushMatrix();
    glTranslatef(0.1f, 0.0f, 0.0f); // Posicao intermediaria
    glutSolidSphere(0.15, 30, 30);
    glPopMatrix();

    // Restaurar a escrita no depth buffer apos desenhar todos os objetos transparentes.
    glDepthMask(GL_TRUE);

    glutSwapBuffers();
}

Se você remover as chamadas para glDepthMask(GL_FALSE); e glDepthMask(GL_TRUE);, observará um erro comum: a esfera azul mais próxima, apesar de semi-transparente, ocultará incorretamente a esfera verde intermediária. O que você veria através da esfera azul seria a esfera vermelha (ou o fundo), ignorando a verde.

Esta lição cobriu os fundamentos da combinação de cores no OpenGL, desde a configuração de fatores de fonte e destino até as considerações cruciais do buffer de profundidade em renderizações 3D, garantindo a visualização correta de objetos transparentes.