OpenGL Shading Language - Escuela Superior de Informática

Tema 5
Lenguajes de programación
David Vallejo Fernández
Curso 2007/2008
Escuela Superior de Informática
Índice de contenidos
1.Introducción.
2.OpenGL Shading Language.
3.NVIDIA Cg Programming Language.
4.DirectX High-Level Shader Language.
5.Resumen.
2
1
Introducción
3
Introducción
●
Conceptos básicos.
–
Shader.
●
●
Conjunto de instrucciones destinadas a aplicar
efectos de renderizado.
Utilizados para programar la GPU.
–
–
–
●
Fixed pipeline --> programmable pipeline.
Mayor flexibilidad.
Mayor eficiencia.
Parte del proceso de render responsable de
calcular el color de un objeto.
4
Introducción
●
Conceptos básicos.
–
Shader.
Flexibilidad!
Eficiencia!
5
Introducción
●
Conceptos básicos.
–
Shader. Clasificación.
●
Vertex shaders.
–
–
–
–
Ejecutados por la GPU para cada vértice.
Transformar la posición 3D en 2D.
Manipulan posiciones, colores, coordenadas de
texturas.
Salida hacia un geometry shader o a la etapa de
rasterización.
6
Introducción
●
Conceptos básicos.
–
Shader. Clasificación.
●
Vertex shaders.
// Transformación de la posición de un punto simulando
// la aceleración de la gravedad.
uniform float t;
// Tiempo obtenido desde la aplicación.
attribute vec4 vel; // Velocidad de la partícula.
Const vec4 g = vec4(0.0, -9.80, 0.0);
void main ()
{
vec4 posicion = gl_Vertex;
posicion += t * vel + t *t * g;
gl_Position = gl_ModelViewProjectionMatrix * posicion;
}
7
Introducción
●
Conceptos básicos.
–
Shader. Clasificación.
●
Geometry shaders.
–
–
–
Pueden añadir y eliminar vértices de una malla.
Usados para generar geometrías o añadir
volumen.
Salida hacia la etapa de rasterización.
8
Introducción
●
Conceptos básicos.
–
Shader. Clasificación.
●
Geometry shaders.
!!NVgp4.0
# División de un triángulo
en 4 triángulos iguales.
PRIMITIVE_IN TRIANGLES;
PRIMITIVE_OUT TRIANGLE_STRIP;
VERTICES_OUT 8;
ATTRIB v0 = vertex[0].position;
ATTRIB v1 = vertex[1].position;
ATTRIB v2 = vertex[2].position;
TEMP m0, m1, m2;
# Cálculo de puntos.
ADD m0, v0, v1;
MUL m0, m0, 0.5;
ADD m1, v1, v2;
MUL m1, m1, 0.5;
ADD m2, v2, v0;
MUL m2, m2, 0.5;
# output 3 triangles as triangle strip
MOV result.position, v0; EMIT;
MOV result.position, m2; EMIT;
MOV result.position, m0; EMIT;
MOV result.position, m1; EMIT;
MOV result.position, v1; EMIT;
ENDPRIM;
# output 4th triangle
MOV result.position, v2; EMIT;
MOV result.position, m1; EMIT;
MOV result.position, m2; EMIT;
ENDPRIM;
END
9
Introducción
●
Conceptos básicos.
–
Shader. Clasificación.
●
Pixel shaders.
–
–
–
–
a.k.a. fragment shaders.
Calculan el color de píxeles individuales.
Utilizados para iluminación y efectos como el
bump mapping.
DirectX usa el término pixel shader y OpenGL el
de fragment shader.
10
Introducción
●
Conceptos básicos.
–
Shader. Clasificación.
●
Pixel shaders.
// Mapeado de texturas simple.
varying vec2 texture_coordinate;
void main()
{
// Transformación del vértice.
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
// Paso de la coordenada de la textura al fragment shader.
texture_coordinate = vec2(gl_MultiTexCoord0);
}
varying vec2 texture_coordinate;
uniform sampler2D my_color_texture;
void main()
{
// Muestreo de la textura y envío al frame buffer.
gl_FragColor = texture2D(my_color_texture, texture_coordinate);
}
11
Introducción
●
Conceptos básicos.
–
Shader. Clasificación.
●
Unified shader model.
–
–
–
–
Unificación de los tres tipos de shader.
En OpenGL y en DirectX 10.
Flexibilidad al asignar más shaders a la tarea con
más carga de trabajo.
Ejemplos de tarjetas gráficas.
● Serie 8 de NVIDIA GeForce.
● Serie 2000 de ATI Radeon HD.
● Serie X3000 de Intel GMA.
12
Introducción
●
Conceptos básicos.
–
Shading language.
●
Lenguaje de programación para shaders.
●
Tipos de datos especiales (color, normal...).
●
Clasificación.
–
–
Renderizado en producción.
● RenderMan Shading Language.
Renderizado en tiempo real.
● OpenGL shading language.
● Cg programming language.
● DirectX High-Level Shader Language.
13
2
OpenGL Shading Language
14
OpenGL Shading Language
●
¿Cómo opera OpenGL?
–
2 máquinas: vertex y fragment.
15
OpenGL Shading Language
●
Con OpenGL 2.0...
–
Programmable shading pipeline.
●
●
Procesamiento de vértices y fragments con
GLSL.
¿Qué estudiaremos?
–
Cómo afectan los shaders al procesamiento de
vértices y fragments.
–
Qué se requiere para la integración de shaders
en un programa OpenGL.
–
Cómo escribir shaders.
16
OpenGL Shading Language
●
Procesamiento de vértices.
–
Transformación de vértices.
–
Transformación y normalización de normales.
–
Generación de coordenadas de textura.
–
Transformación de coordenadas de textura.
–
Iluminación.
–
Etc.
17
OpenGL Shading Language
●
Procesamiento de fragments.
–
Operaciones en valores interpolados.
–
Acceso a texturas.
–
Aplicación de texturas.
–
Niebla.
–
Suma de colores.
–
Etc.
18
OpenGL Shading Language
●
Interfaz con GLSL.
–
–
Parecido a programar en C.
●
Compilación.
●
Debugging.
●
Generación de código objeto.
●
Enlazado.
Diferencias...
●
El compilador y el enlazador son parte del driver
OpenGL.
19
OpenGL Shading Language
●
Interfaz con GLSL.
–
–
Para cada objeto shader...
●
Crear un objeto (vertex o fragment).
●
Compilar el código del shader en dicho objeto.
●
Verificar que la compilación fue correcta.
Para enlazar varios objetos en un programa...
●
Crear un programa shader.
●
Asociar los objetos al programa.
●
Enlazar el programa.
●
Verificar que el enlazado fue correcto.
●
Utilizar el shader.
20
OpenGL Shading Language
●
Interfaz con GLSL.
–
¿Por qué crear múltiples objetos shader en un
programa?
–
Funciones importantes.
Gluint glCreateShader (GLenum type);
void glShaderSource (Gluint shader, Glsizei count,
const Glchar **string, const Glint *length);
void glCompileShader (Gluint shader);
Gluint glCreateProgram ();
void glAttachShader (Gluint program, Gluint shader);
void glLinkProgram (Gluint program);
void glUseProgram (Gluint program);
21
OpenGL Shading Language
●
Interfaz con GLSL.
–
1) Crear los shaders y el programa.
glhandleARB v, f, p;
v = glCreateShaderObjectARB (GL_VERTEX_SHADER_ARB);
f = glCreateShaderObjectARB (GL_FRAGMENT_SHADER_ARB);
p = glCreateProgramARB();
–
2) Leer el código de los shaders.
char *vs = read (vertex_shader_path);
char *fs = read (fragment_shader_path);
glShaderSourceARB (v, 1, &vs, NULL);
glShaderSourceARB (f, 1, &fs, NULL);
–
3) Compilar, asociar y enlazar los shaders.
glCompileShaderARB (v);
glCompileShaderARB (f);
glAttachObjectARB (p, v);
glAttachObjectARB (p, f);
glLinkProgramARB (p);
22
OpenGL Shading Language
●
Creación de shaders con GLSL.
–
~ programa en C.
void main ()
{
// Código del shader.
/* Más código...*/
// No se devuelve un int.
// Instrucciones terminan con ;
}
–
Fuertemente tipado (float f = 10).
–
Tipos agregados.
●
vec2, ivec3, bvec4, mat2...
●
Ej.: vec3 velocity = vec3 (0.0, 2.0, 3.0);
●
Estructuras, arrays...
23
OpenGL Shading Language
●
Creación de shaders con GLSL.
–
Modificadores de tipos.
●
–
–
const, attribute, uniform, varying.
Sentencias.
●
Operaciones aritméticas (++, --, (), [], ...).
●
Operadores de sobrecarga (vec_a * vec_b).
●
Funciones. Paso de parámetros.
...
24
3
NVIDIA Cg Programming Language
25
NVIDIA Cg
●
Basado en el lenguaje C.
●
Vertex y frament programs.
●
Modelo de programación.
26
NVIDIA Cg
●
Distintos perfiles.
–
Perfiles avanzados.
●
–
Perfiles básicos.
●
●
OpenGL NV2X, DirectX 8.
Declaraciones.
–
●
OpenGL ARB, NV40, NV30, DirectX 9.
Similares a C (y a GLSL).
E/S.
–
Varying inputs.
–
Uniform inputs.
27
NVIDIA Cg
●
●
Tipos y operaciones de datos.
–
Básicos.
–
Estructuras.
–
Arrays.
–
Conversiones de tipo.
Interfaces (como en C# y C++).
interface Light {
float3 illuminate (float3 P, out float3 L);
float3 color (void);
}
●
Sentencias y operaciones (~ C).
28
NVIDIA Cg
●
Cg Runtime.
–
#include <Cg/cg.h>
–
#include <Cg/cgGL.h>
–
#include <Cg/cgD3D9.h>
// Crear un contexto.
CGcontext ctx = cgCreateContext ();
// Compilar un programa.
Cgprogram p = cgCreateProgram (ctx, CG_SOURCE, vertexProgramString,
CG_PROFILE_ARBVP1, “main”, args);
// Cargar un programa en OpenGL.
cgGLLoadProgram(program);
// Modificar un parámetro en OpenGL.
CgGLSetParameter4fv (param, value);
// Ejecutar un programa en OpenGL.
CgGLBindProgram (p);
29
NVIDIA Cg
●
Puesta en marcha.
–
Requisitos.
●
Nvidia-cg-toolkit (no es free software).
–
–
http://developer.nvidia.com/object/cg_toolkit.html#downloads
Debian y derivados.
●
Paquetes nvidia-cg-toolkit y xorg-dev.
–
●
apt-get install nvidia-cg-toolkit xorg-dev
Documentación en /usr/share/doc.
30
NVIDIA Cg
●
Ejemplo simple.
// This is C2E1v_green from "The Cg Tutorial" (Addison-Wesley, ISBN
// 0321194969) by Randima Fernando and Mark J. Kilgard. See page 38.
struct C2E1v_Output {
float4 position : POSITION;
float3 color : COLOR;
};
C2E1v_Output C2E1v_green(float2 position : POSITION)
{
C2E1v_Output OUT;
OUT.position = float4(position,0,1);
OUT.color = float3(0,1,0);
}
return OUT;
31
NVIDIA Cg
●
Ejemplo simple.
int main(int argc, char **argv) {
glutInit (/*parameters*/);
glut*Func(callbackFunc);
myCgContext = cgCreateContext();
cgSetParameterSettingMode(myCgContext,
CG_DEFERRED_PARAMETER_SETTING);
myCgVertexProfile = cgGLGetLatestProfile(CG_GL_VERTEX);
cgGLSetOptimalOptions(myCgVertexProfile);
myCgVertexProgram =
cgCreateProgramFromFile(
myCgContext,
/* Cg runtime context */
CG_SOURCE,
/* Program in human-readable form */
myVertexProgramFileName, /* Name of file containing program */
myCgVertexProfile,
/* Profile: OpenGL ARB vertex program */
myVertexProgramName,
/* Entry function name */
NULL);
/* No extra compiler options */
checkForCgError("creating vertex program from file");
cgGLLoadProgram(myCgVertexProgram);
glutMainLoop();
return 0;
}
32
NVIDIA Cg
●
Ejemplo simple.
static void display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
cgGLBindProgram(myCgVertexProgram);
checkForCgError("binding vertex program");
cgGLEnableProfile(myCgVertexProfile);
checkForCgError("enabling vertex profile");
/* Rendering code verbatim from Chapter 1, Section 2.4.1
"Rendering a Triangle with OpenGL" (page 57). */
glBegin(GL_TRIANGLES);
glVertex2f(-0.8, 0.8);
glVertex2f(0.8, 0.8);
glVertex2f(0.0, -0.8);
glEnd();
cgGLDisableProfile(myCgVertexProfile);
checkForCgError("disabling vertex profile");
glutSwapBuffers();
}
33
NVIDIA Cg
●
Ejemplo simple.
static void keyboard(unsigned char c, int x, int y)
{
switch (c) {
case 27: /* Esc key */
/* Demonstrate proper deallocation of Cg runtime data structures.
Not strictly necessary if we are simply going to exit. */
cgDestroyProgram(myCgVertexProgram);
cgDestroyContext(myCgContext);
exit(0);
break;
}
}
●
Más ejemplos en nvidia-cg-toolkit/examples.
34
4
DirectX High­Level Shader Language
35
DirectX HLSL
●
Lenguage de shaders propietario.
●
Desarrollado por Microsoft.
●
Uso con Direct3D.
●
Vertex, geometry y pixel shaders.
36
DirectX HLSL
●
Ejemplo simple. Vertex shader.
float4x4 view_proj_matrix;
float4x4 texture_matrix0;
struct VS_OUTPUT
{
float4 Pos : POSITION;
float3 Pshade : TEXCOORD0;
};
VS_OUTPUT main (float4 vPosition : POSITION)
{
VS_OUTPUT Out = (VS_OUTPUT) 0;
// Transform position to clip space
Out.Pos = mul (view_proj_matrix, vPosition);
// Transform Pshade
Out.Pshade = mul (texture_matrix0, vPosition);
return Out;
}
Clip space
3D texture
37
DirectX HLSL
●
Ejemplo simple. Pixel shader.
float4 lightWood; // xyz == Light Wood Color
float4 darkWood; // xyz == Dark Wood Color
float ringFreq; // ring frequency
Calculado por el vertex
sampler PulseTrainSampler;
shader para cada vértice
float4 hlsl_rings (float4 Pshade : TEXCOORD0) : COLOR
{
float scaledDistFromZAxis = sqrt(dot(Pshade.xy, Pshade.xy)) *
ringFreq;
float blendFactor = tex1D (PulseTrainSampler, scaledDistFromZAxis);
return lerp (darkWood, lightWood, blendFactor);
Acceso a la textura
}
38
5
Resumen
39
Resumen
●
●
●
Conceptos básicos (shader, shading
language, clasificación...).
Ventajas y desventajas de los lenguajes de
alto nivel para programación de
aplicaciones gráficas.
Conocer la interfaz básica de GLSL y los
pasos para la creación de shaders.
40
Resumen
●
Referencias.
–
OpenGL Shading Language.
●
OpenGL Programming Guide (Fifth Edition).
–
●
OpenGL Shading Language.
–
●
–
Chapter 2.
http://www.lighthouse3d.com/opengl/glsl/
NVIDIA Cg.
●
–
Chapter 15.
http://developer.nvidia.com/page/cg_main.html
HLSL.
●
ati.amd.com/developer/ShaderX2_IntroductionToHLSL.pdf
41