Capítulo 6: Blending, Antialiasing, Fog y Polygon Offset

Efectos

• Blending: se utiliza para crear efectos de transparencia. Esto se hace por medio de la especificación de un función de mezcla que combina valores de colores entre un fuente y un destino.

• Antialiasing: es una técnica que altera los colores de objetos (puntos, líneas y polígonos) para que los bordes se vean más suaves (o menos dentados).

• Fog: corresponde al efecto de niebla en que los objetos más lejanos desaparecen. Esta ilusión de profundidad se crea calculando los colores de un objeto basado en la distancia que existe entre el objeto y el punto de vista.

• Polygon Offset: permite eliminar imperfecciones que se producen cuando un objeto sombreado y su wireframe utilizan los mismos vértices.

Blending
• Cuando el blending es activado, el valor alpha puede ser utilizado para combinar el valor del color del fragmento que está siendo procesado, con el pixel que ya está almacenado en el framebuffer.
• Con blending se puede controlar cuanto del color del actual pixel puede ser combinado con el nuevo fragmento.
• Blending ocurre después que la escena ha sido renderizada y convertida a fragmentos, pero antes que el pixel sea almacenado en el framebuffer.
• El valor alpha también puede ser usado para aceptar a rechazar un fragmento basado en su valor alpha (ver capítulo 10 del redbook).
• Blending no funciona en modo color index.
• Las operaciones blending se puede pensar en términos de que la componentes RGB son el color de un fragmento, y el alpha representa el nivel de opacidad de ese fragmento.

Factores Fuente y Destino
• Fuente (source): valor del color del fragmento que está siendo procesado.
• Destino (destination): valor del color del píxel almacenado.
• Durante el blending fuente y destino son combinados en 2 etapas:
– Primero se especifica cómo los factores fuente y destino van a ser calculados. Estos factores (R,G,B,A) multiplican a cada componente R, G, B, A del fuente y destino respectivamente.

– Luego se suman fuente y destino, y se obtiene el resultado.
• Factor Fuente: (Sr, Sg, Sb, Sa).
• Factor Destino: (Dr, Dg, Db, Da)
• Valor Final: (RsSr+RdDr, GsSg+GdDg, BsSb+BdDb, AsSa+AdDa)
• El valor final de cada componente es limitado a: 0-1.

Blending en OpenGL
• Habilitar blending: glEnable(GL_BLEND);
• Definir cómo se calcularán factores Fuente y Destino:
glBlendFunc(GLenum sfactor, Glenum dfactor);
sfactor: factor fuente.
dfactor: factor destino.

Factores de Blending Fuente y Destino

Ejemplos de Blending

• No todas las combinaciones tienen sentido.
• Mezcla de dos imágenes:
– Primera Imagen:
• Factor Fuente: GL_ONE (1,1,1,1)
• Factor Destino: GL_ZERO (0,0,0,0)
• (Rs*1 + Rd*0, Gs*1 + Gd*0, Bs*1 + Bd*0) = (Rs,Gs,Bs)
– Segunda Imagen:
• Factor Fuente: GL_SRC_ALPHA (As,As,As,As)
• Factor Destino: GL_ONE_MINUS_SRC_ALPHA
(1-As, 1-As,1-As,1-As)
• ( RsAs + Rd(1-As), GsAs + Gd(1-As), BsAs + Bd(1-As) )

• Mezcla de tres imágenes equivalentemente:
– Factor Fuente: GL_SRC_ALPHA
– Factor Destino: GL_ONE
– Dibujar cada imagen con Factor Alpha: 0.333333
– (Rs*0.3 + (Rd=0)*1,
– (Rs*0.3 + (Rs*0.3)*1,
– (Rs*0.3 + (Rs*0.3 + Rs*0.3)*1,

• Mezcla gradual:
– Factor Fuente: GL_SRC_ALPHA
– Factor Destino: GL_ONE_MINUS_SRC_ALPHA
– Dibujar cada imagen con Factor Alpha = % (0.1)
– ( RsAs + Rd(1-As), …
– ( RsAs + ( RsAs + Rd(1-A) )*(1-As), …
– ( RsAs + ( ...)* ( 1-As), …

• Modulación de colores:
– Factor Fuente: GL_DST_COLOR (Rd, Gd, Bd, Ad)
– Factor Destino: GL_SRC_COLOR (Rs, Gs, Bs, As)
– ( RsRd + RdRs,…
– Es una especie de filtro.

• Tres objetos, uno detrás de otro, sobre un fondo sólido:
– Objeto 1 (más lejano): Transp: 80%
– Objeto 2 (intermedio: Transp: 40%
– Objeto 3 (más cercano): Transp: 90%

• Dibujar Fondo:
– Factor Fuente: GL_ONE
– Factor Destino: GL_ZERO

• Cambiar Factores blending:
– Factor Fuente: GL_SRC_ALPHA
– Factor Destino: GL_ONE_MINUS_SRC_ALPHA
• Dibujar objeto 1, Alpha = 0.2.
• Dibujar objeto 2, Alpha = 0.6.
• Dibujar objeto 3, Alpha = 0.1.

Ejemplo alpha.c
/* Initialize alpha blending function. */
static void init(void){
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glShadeModel (GL_FLAT);
glClearColor (0.0, 0.0, 0.0, 0.0);
}

void display(void){
glClear(GL_COLOR_BUFFER_BIT);
if (leftFirst) {
drawLeftTriangle();
drawRightTriangle();
}
else {
drawRightTriangle();
drawLeftTriangle();
}
glFlush();
}

Ejemplo alpha3d.c
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix ();
glCallList (sphereList);
glPopMatrix ();
glPushMatrix ();
glEnable (GL_BLEND);
glDepthMask (GL_FALSE);
glBlendFunc (GL_SRC_ALPHA, GL_ONE);
glCallList (cubeList);
glDepthMask (GL_TRUE);
glDisable (GL_BLEND);
glPopMatrix ();

Antialiasing (o graduación)

• Para controlar el comportamiento OpenGL:
void glHint(GLenum target, GLenum hint);
target: comportamiento a controlar (ver tabla)
hint: GL_FASTEST, GL_NICEST, GL_DONT_CARE

Antialiasing Puntos, Lineas

Puntos:
• glEnable( GL_POINT_SMOOTH )
• glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);

Líneas:
• glEnable( GL_LINE_SMOOTH );
• glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
• En modo RGBA, antialiasing debe tener blending habilitado.
Ejemplo aarbg.c
void init(void){
GLfloat values[2];
glGetFloatv (GL_LINE_WIDTH_GRANULARITY, values);
printf ("GL_LINE_WIDTH_GRANULARITY value is %3.1f\n",
values[0]);
glGetFloatv (GL_LINE_WIDTH_RANGE, values);
printf ("GL_LINE_WIDTH_RANGE values are %3.1f %3.1f\n",
values[0], values[1]);
glEnable (GL_LINE_SMOOTH);
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glHint (GL_LINE_SMOOTH_HINT, GL_DONT_CARE);
glLineWidth (1.5);
glClearColor(0.0, 0.0, 0.0, 0.0);
}

Fog
• Es un Término general que describe formas similares de efectos atmosféricos: niebla, humo, polución.
• Limita la visibilidad.
• Para habilitar Fog:
– glEnable(GL_FOG);
– Elegir el color de fog.
– Determinar la función de densidad de fog con: glFog*();.

Fog

void glFog{if}(GLenum pname, TYPE param);
void glFog{if}v(GLenum pname, TYPE *params);

Si pname = GL_FOG_MODE,
entonces param = GL_EXP, GL_EXP2 o GL_LINEAR.
Si pname = GL_FOG_DENSITY, GL_FOG_START o GL_FOG_END,
entonces param es el valor correspondiente.

En modo RGBA si pname = GL_FOG_COLOR,
entonces param = valor RGBA.
El color de final C = f Ci + (1 – f) Cf
Ci: color del fragmento.
Cf : color de fog.

Ejemplo fog.c
GLfloat fogColor[4] = {0.5, 0.5, 0.5, 1.0};
glEnable(GL_FOG);
fogMode = GL_EXP;
glFogi (GL_FOG_MODE, fogMode);
glFogfv (GL_FOG_COLOR, fogColor);
glFogf (GL_FOG_DENSITY, 0.35);
glHint (GL_FOG_HINT, GL_DONT_CARE);
glFogf (GL_FOG_START, 1.0);
glFogf (GL_FOG_END, 5.0);
glClearColor(0.5, 0.5, 0.5, 1.0); /* fog color */