Tema 5 Lenguajes de programación

Transcripción

1 Tema 5 Lenguajes de programación David Vallejo Fernández Curso 2007/2008 Escuela Superior de Informática 1 Índice de contenidos Programming Language. 4.DirectX High-Level Shader Language. 5.Resumen. 2 3 Shader. Conjunto de instrucciones destinadas a aplicar efectos de renderizado. Shader. Flexibilidad! Eficiencia! 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 5

2 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. 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; 6 gl_position = gl_modelviewprojectionmatrix * posicion; 7 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 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 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. 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; 10 void main() // Muestreo de la textura y envío al frame buffer. gl_fragcolor = texture2d(my_color_texture, texture_coordinate); 11 Shading language. 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. 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

3 2 OpenGL Shading Language Cómo opera OpenGL? 2 máquinas: vertex y fragment Con OpenGL Programmable shading pipeline. Procesamiento de vértices. Transformación de vértices. 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. Transformación y normalización de normales. Generación de coordenadas de textura. Transformación de coordenadas de textura. Iluminación. Etc Procesamiento de fragments. Operaciones en valores interpolados. Parecido a programar en C. Acceso a texturas. Compilación. Aplicación de texturas. Debugging. Niebla. Suma de colores. Etc. Generación de código objeto. Enlazado. Diferencias... El compilador y el enlazador son parte del driver OpenGL Para cada objeto shader... Crear un objeto (vertex o fragment). Compilar el código del shader en dicho objeto. Por qué crear múltiples objetos shader en un programa? Funciones importantes. 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. 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); Utilizar el shader

4 Creación de shaders con GLSL. 1) Crear los shaders y el programa. ~ programa en C. 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); void main () // Código del shader. /* Más código...*/ // No se devuelve un int. // Instrucciones terminan con ; Fuertemente tipado (float f = 10). 3) Compilar, asociar y enlazar los shaders. Tipos agregados. glcompileshaderarb (v); glcompileshaderarb (f); glattachobjectarb (p, v); glattachobjectarb (p, f); gllinkprogramarb (p); 22 vec2, ivec3, bvec4, mat2... Ej.: vec3 velocity = vec3 (0.0, 2.0, 3.0); Estructuras, arrays 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. 3 Programming Language Basado en el lenguaje C. Distintos perfiles. Vertex y frament programs. Modelo de programación. Perfiles avanzados. OpenGL ARB, NV40, NV30, DirectX 9. Perfiles básicos. OpenGL NV2X, DirectX 8. Declaraciones. Similares a C (y a GLSL). E/S. Varying inputs. Uniform inputs Tipos y operaciones de datos. Cg Runtime. Básicos. #include <Cg/cg.h> Estructuras. #include <Cg/cgGL.h> Arrays. #include <Cg/cgD3D9.h> 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). // 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); 28 // Ejecutar un programa en OpenGL. CgGLBindProgram (p); 29

5 Puesta en marcha. Requisitos. Nvidia-cg-toolkit (no es free software). Debian y derivados. Paquetes nvidia-cg-toolkit y xorg-dev. apt-get install nvidia-cg-toolkit xorg-dev Documentación en /usr/share/doc. // This is C2E1v_green from "The Cg Tutorial" (Addison-Wesley, ISBN // ) 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; int main(int argc, char **argv) glutinit (/*parameters*/); glut*func(callbackfunc); static void display(void) glclear(gl_color_buffer_bit GL_DEPTH_BUFFER_BIT); 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 cgglbindprogram(mycgvertexprogram); checkforcgerror("binding vertex program"); cgglenableprofile(mycgvertexprofile); checkforcgerror("enabling vertex profile"); /* Rendering code verbatim from Chapter 1, Section "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 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. 4 DirectX High Level Shader Language DirectX HLSL DirectX HLSL Lenguage de shaders propietario. Vertex shader. Desarrollado por Microsoft. Uso con Direct3D. Vertex, geometry y pixel shaders. 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 36 37

6 DirectX HLSL Pixel shader. float4 lightwood; // xyz == Light Wood Color float4 darkwood; // xyz == Dark Wood Color float ringfreq; // ring frequency Calculado por el vertex shader para cada vértice sampler PulseTrainSampler; float4 hlsl_rings (float4 Pshade : TEXCOORD0) : COLOR float scaleddistfromzaxis = sqrt(dot(pshade.xy, Pshade.xy)) * ringfreq; 5 Resumen float blendfactor = tex1d (PulseTrainSampler, scaleddistfromzaxis); return lerp (darkwood, lightwood, blendfactor); Acceso a la textura Resumen 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 Referencias.. OpenGL Programming Guide (Fifth Edition). Chapter 15.. Chapter 2. HLSL. ati.amd.com/developer/shaderx2_introductiontohlsl.pdf 41