En este módulo, exploraremos técnicas avanzadas de sombreado en OpenGL. Estas técnicas permiten crear efectos visuales más complejos y realistas, mejorando significativamente la calidad gráfica de tus aplicaciones.

1. Introducción a los Shaders
2. Shaders de Fragmentos Avanzados
3. Shaders de Vértices Avanzados
4. Shaders de Geometría
5. Ejemplo Práctico: Sombreado Phong
6. Ejercicios Prácticos
7. Conclusión

Los shaders son programas que se ejecutan en la GPU y se utilizan para controlar el proceso de renderizado. Los dos tipos más comunes de shaders son:

• Vertex Shaders: Procesan cada vértice individualmente.
• Fragment Shaders: Procesan cada fragmento (o píxel) individualmente.

En esta sección, nos centraremos en técnicas avanzadas para ambos tipos de shaders, así como en los shaders de geometría.

El sombreado Phong es una técnica que proporciona un modelo de iluminación más realista al calcular la iluminación en cada fragmento. A continuación, se muestra un ejemplo de un fragment shader que implementa el sombreado Phong:

1. Propiedades Ambientales: La luz ambiental es una luz constante que ilumina todos los objetos de manera uniforme.
2. Propiedades Difusas: La luz difusa depende de la orientación de la superficie con respecto a la fuente de luz.
3. Propiedades Especulares: La luz especular simula los reflejos brillantes en la superficie del objeto.

El desplazamiento de vértices es una técnica que permite modificar la posición de los vértices en el vertex shader. Esto se puede utilizar para crear efectos como ondas en el agua o terrenos deformados.

1. Desplazamiento de Vértices: La posición de los vértices se modifica utilizando una función seno para crear un efecto de onda.
2. Transformaciones: Se aplican las transformaciones de modelo, vista y proyección para posicionar correctamente los vértices en el espacio 3D.

Los shaders de geometría permiten generar nuevos vértices a partir de los vértices existentes. Esto es útil para efectos como la generación de sombras volumétricas o la creación de geometría adicional.

1. Entrada y Salida: El shader de geometría toma triángulos como entrada y genera un triángulo strip como salida.
2. EmitVertex y EndPrimitive: Estas funciones se utilizan para emitir los vértices y finalizar la primitiva.

Vamos a combinar lo aprendido en un ejemplo práctico que implementa el sombreado Phong en un objeto 3D.

1. Vertex Shader: Calcula la posición del fragmento y la normal transformada.
2. Fragment Shader: Implementa el modelo de iluminación Phong para calcular la luz ambiental, difusa y especular.

1. Implementar Sombreado Gouraud: Modifica el ejemplo anterior para implementar el sombreado Gouraud, donde la iluminación se calcula en el vertex shader y se interpola en el fragment shader.
2. Efecto de Onda en el Agua: Utiliza el desplazamiento de vértices para crear un efecto de onda en una superficie plana.
3. Shader de Geometría para Generar Normales: Escribe un shader de geometría que genere normales para cada triángulo de un objeto.

1. Sombreado Gouraud:

   Vertex Shader:

   #version 330 core
   layout(location = 0) in vec3 aPos;
   layout(location = 1) in vec3 aNormal;
   
   out vec3 FragColor;
   
   uniform vec3 lightPos; 
   uniform vec3 viewPos; 
   uniform vec3 lightColor;
   uniform vec3 objectColor;
   uniform mat4 model;
   uniform mat4 view;
   uniform mat4 projection;
   
   void main()
   {
       vec3 FragPos = vec3(model * vec4(aPos, 1.0));
       vec3 Normal = mat3(transpose(inverse(model))) * aNormal;  
   
       float ambientStrength = 0.1;
       vec3 ambient = ambientStrength * lightColor;
   
       vec3 norm = normalize(Normal);
       vec3 lightDir = normalize(lightPos - FragPos);
       float diff = max(dot(norm, lightDir), 0.0);
       vec3 diffuse = diff * lightColor;
   
       float specularStrength = 0.5;
       vec3 viewDir = normalize(viewPos - FragPos);
       vec3 reflectDir = reflect(-lightDir, norm);  
       float spec = pow(max(dot(viewDir, reflectDir), 0.0), 32);
       vec3 specular = specularStrength * spec * lightColor;  
   
       vec3 result = (ambient + diffuse + specular) * objectColor;
       FragColor = result;
   
       gl_Position = projection * view * vec4(FragPos, 1.0);
   }
   

   Fragment Shader:

   #version 330 core
   in vec3 FragColor;
   out vec4 color;
   
   void main()
   {
       color = vec4(FragColor, 1.0);
   }
   

2. Efecto de Onda en el Agua:

   Vertex Shader:

   #version 330 core
   layout(location = 0) in vec3 aPos;
   layout(location = 1) in vec3 aNormal;
   
   out vec3 FragPos;
   out vec3 Normal;
   
   uniform mat4 model;
   uniform mat4 view;
   uniform mat4 projection;
   uniform float time;
   
   void main()
   {
       vec3 newPos = aPos + vec3(0.0, sin(aPos.x * 10.0 + time) * 0.1, 0.0);
       FragPos = vec3(model * vec4(newPos, 1.0));
       Normal = mat3(transpose(inverse(model))) * aNormal;  
   
       gl_Position = projection * view * vec4(FragPos, 1.0);
   }
   

3. Shader de Geometría para Generar Normales:

   Geometry Shader:

   #version 330 core
   layout(triangles) in;
   layout(triangle_strip, max_vertices = 3) out;
   
   out vec3 Normal;
   
   void main()
   {
       vec3 U = gl_in[1].gl_Position.xyz - gl_in[0].gl_Position.xyz;
       vec3 V = gl_in[2].gl_Position.xyz - gl_in[0].gl_Position.xyz;
       vec3 normal = normalize(cross(U, V));
   
       for(int i = 0; i < 3; i++)
       {
           Normal = normal;
           gl_Position = gl_in[i].gl_Position;
           EmitVertex();
       }
       EndPrimitive();
   }
   

En esta sección, hemos explorado técnicas avanzadas de sombreado en OpenGL, incluyendo el sombreado Phong, el desplazamiento de vértices y los shaders de geometría. Estas técnicas permiten crear efectos visuales más complejos y realistas, mejorando significativamente la calidad gráfica de tus aplicaciones.

En el próximo módulo, profundizaremos en el renderizado instanciado, una técnica que permite renderizar múltiples instancias de un objeto de manera eficiente.