GPU and GLSL. Prof. João Madeiras Pereira 2008/2009

Transcrição

1 GPU and GLSL Prof. João Madeiras Pereira 2008/2009 1

2 Tópicos Evolução do hardware gráfico Pipeline gráfico fixo Pipeline gráfico programável Processador de vértices Processador de fragmentos GLSL Invocação pelo OpenGL Parâmetros Sintaxe Entradas e Saídas Exemplos Futuro do hardware gráfico 2

4 O que é GPU? GPU - Unidade de Processamento Gráfico Dedicado a tarefas gráficas tais como transformação e rasterização de modelos 3D 4

5 O que é Shading Language? É uma linguagem que contém funções gráficas específicas que definem as propriedades visuais da superfície de um objecto. Ex.: Cor, iluminação, reflexão, transparência, textura 5

6 Common Shader Languages HLSL: DirectX GLSL: OpenGL CG: Both 6

7 Linguagem de Shading para GPU GLSL é uma linguagem de shading que se executa directamente na GPU Por se tratar de uma linguagem específica para operações gráficas, não podemos usá-las para os mesmos fins das linguagens de propósitos gerais como C, C++, Java 7

8 Inspiração O Renderman, apesar de poderosa, é uma linguagem de rendering offline, ao passo que as linguagens de shading são destinadas às aplicações em tempo real e correm directamente na placa gráfica 8

9 Necessidade de Placas Gráficas programáveis em alto nível CPU : Intel Pentium 4 possui 55M transistores e hoje as placas gráficas já possuem cerca 550 M transistores-1000 M triang/seg 9

10 Motivação para linguagem em alto-nível Hardware gráfico cada vez mais potente e complexo Programação em código assembly é bem pesada GeForce Fx suportando programas com mais de 1000 instruções assembly Programadores necessitam dos benefícios de uma linguagem de alto-nível: Facilidade de programação Facilidade de reuso de código Facilidade de Debug Assembly DP3 R0, c[11].xyzx, c[11].xyzx; RSQ R0, R0.x; MUL R0, R0.x, c[11].xyzx; MOV R1, c[3]; MUL R1, R1.x, c[0].xyzx; DP3 R2, R1.xyzx, R1.xyzx; RSQ R2, R2.x; MUL R1, R2.x, R1.xyzx; ADD R2, R0.xyzx, R1.xyzx; DP3 R3, R2.xyzx, R2.xyzx; RSQ R3, R3.x; MUL R2, R3.x, R2.xyzx; DP3 R2, R1.xyzx, R2.xyzx; MAX R2, c[3].z, R2.x; MOV R2.z, c[3].y; MOV R2.w, c[3].y; LIT R2, R2;... Linguagem de alto-nível float3 cspecular = pow(max(0, dot(nf, H)), phongexp).xxx; float3 cplastic = Cd * (cambient + cdiffuse) + Cs * cspecular; 10

11 Evolução do hardware gráfico Era do 2D nos PCs 1987 : IBM introduz o VGA Placa gráfica é um frame buffer. O CPU faz o esforço computacional : IBM introduz o XGA Placa gráfica possui co-processador especializado para desenhar linhas, desenhar rectângulos e BitBLT. 11

12 Evolução do hardware gráfico Era do 3D nos PCs : nvidia TNT, ATI Rage, 3dfx Voodoo Desenho de triângulos com sombreamento, texturas OpenGL : GeForce 256, Radeon R100 Transformação dos vértices Cálculo da iluminação no vértice OpenGL

13 Evolução do hardware gráfico Era do 3D nos PCs 2001 : GeForce 3, Radeon R200 Programação ao nível dos vértices OpenGL 1.4 extensão ARB_vertex_program! 2002 : GeForce 4 Programas mais complexos 2003 : GeForce FX, Radeon 9500/9800, WildCat VP Programação ao nível dos fragmentos OpenGL 1.5 algum suporte OpenGL 2.0 extensão ARB_vertex_shader! extensão ARB_fragment_shader! Instruções de branching 13

14 Evolução do hardware gráfico 2004: WildCat Realizm, GeForce 6 e 7, ATI x800 cards They support a higher subset of GLSL, including direct texture access from vertex shaders, large program support, hardwarebased noise generation, variable-length arrays, indirect indexing, texture dependent reading, sub-routines, and a standard library for the most common functions (like dot, cross, normalise, sin, cos, tan, log, sqrt, length, reflect, refract, dfdx, dfdy, etc.). They can also use a long list of built-in variables to access many OpenGL states (like gl_lightsource[n].position, gl_texcoord[n], gl_modelviewmatrix, gl_projectioninversematrix, etc.). Data structures are supported as well through C-like structs. Novembro 2006: GeForce 8800 Arquitectura unificada: unified shaders processors 14

16 Fixed Pipeline Functionalities 16

17 Fixed Functionality 17

18 Pipeline gráfico fixo Vertex Transformation Dados de entrada Vértices com as coordenadas tal como especificadas na aplicação, e outros atributos como normais, cores, coordenadas de textura Estado do OpenGL Operações Transformação do vértice de acordo com as matrizes ModelView e Projection Transformação de normais (por exemplo: normalização) Iluminação do vértice Geração/Transformação das coordenadas de textura 18

19 Pipeline gráfico fixo Primitive Assembly Dados de entrada Vértices transformados Informação de conectividade (GL_TRIANGLE, GL_QUAD,...) Operações Construção das primitivas gráficas com os vértices já transformados View frustum clipping Back face culling Early Z culling 19

20 Pipeline gráfico fixo Rasterization Dados de Entrada Primitivas construídas na fase anterior Operações Determina o conjunto de fragmentos cobertos por uma primitiva geométrica Para cada fragmento é calculado o seu conjunto de atributos por interpolação dos atributos dos vértices da primitiva Resultado: conjunto de fragmentos 20

21 Pipeline gráfico fixo Rasterization (2) Pixel vs. Fragmento Pixel representa o conteúdo do frame buffer numa determinada posição: cor, profundidade, localização,... Fragmento: pixel potencial + atributos 21

22 Pipeline gráfico fixo Texturização e Cor Os dados de entrada desta fase são os valores interpolados na fase anterior para cada fragmento Nesta fase aplicam-se as texturas e calcula-se a cor do fragmento. 22

23 Pipeline gráfico fixo Raster Operations Dados de entrada Localização do pixel Fragmentos processados (cor e profundidade) Operações Teste de scissor, alpha, stencil, profundidade (sem early Z cull) Operações de blending: combina a cor do fragmento com a cor do pixel existente no color buffer 23

24 Programmable Pipeline 24

25 Programmable Pipeline 25

26 Vertex Shader Per-Vertex processing (normais, coordenadas de textura,...) Esta unidade é responsável por operações como: Transformação de vértices (matrizes modelview e projection) Transformação de normais e sua normalização Geração de coordenadas de textura Transformação de coordenadas de textura Iluminação (por vértice)... 26

27 Geometry Shader New. Supported in HLSL 4.0 Nvidia Affect primitives: Triangles, Lines Executed after vertex shaders Input is a primitive with adjacency information. 27

28 Fragment Shader Per-Fragment Rendering Esta unidade é responsável por operações como: Operações sobre valores interpolados (cores, normais, coordenadas de textura, e outros atributos) Acesso a texturas Aplicação de texturas Cálculo da cor 28

29 IDE Tools ATI RenderMonkey Nvidia FX Composer 29

31 Invocação pelo OpenGL GLEW Biblioteca que permite a detecção de qual a versão do OpenGL utilizada, bem como as extensões dos shaders.!#include <GL/glew.h>!!glewInit();!!/* extensões ARB para shaders disponíveis */!!if (GLEW_ARB_vertex_shader &&!!!! GLEW_ARB_fragment_shader)!!/* ou OpenGL 2.0 disponível */!!if (glewissupported("gl_version_2_0"))! 31

32 Invocação pelo OpenGL Uma aplicação pode substituir a funcionalidade fixa relativamente aos vértices e/ou aos fragmentos, não sendo obrigada a implementar os dois Para cada shader é necessário proceder a uma compilação Depois de compilados os shaders são incorporados num programa que depois será linkado 32

33 Invocação pelo OpenGL Como usar shaders na sintaxe OpenGL

34 Invocação pelo OpenGL Código OPENGL 2.0 para criação de shaders!gluint v, f, p;!!v = glcreateshader(gl_vertex_shader);!!f = glcreateshader(gl_fragment_shader);!!const char *vcode = readtextfile("my.vert");!!const char *fcode = readtextfile("my.frag");!!glshadersource(v, 1, &vcode, NULL);!!glShaderSource(f, 1, &fcode, NULL);!!glCompileShader(v);!!glCompileShader(f);! 34

35 Invocação pelo OpenGL Criação e selecção do programa!...!!p = glcreateprogram();!!glattachshader(p,v);!!glattachshader(p,f);!!gllinkprogram(p);!!gluseprogram(p);! 35

36 Invocação pelo OpenGL InfoLog A cada shader ou programa está associado um registo, com mensagens sobre o processo de compilação ou link, respectivamente Através deste registo, para além de ser possível detectar se as operações ocorreram sem erros, poderá ser dada informação relativamente à capacidade do hardware para executar o shader 36

37 Qualifiers Qualifiers give a special meaning to the variable and allows the communication between OGL application and shaders. In GLSL the following qualifiers are available: const - the declaration is of a compile time constant attribute (only used in vertex shaders, and read-only in shader) global variables that may change per vertex, that are passed from the OpenGL application to vertex shaders uniform (used both in vertex/fragment shaders, readonly in both) global variables that may change per primitive (may not be set inside glbegin,/glend) varying - used for interpolated data between a vertex shader and a fragment shader. Available for writing in the vertex shader, and read-only in a fragment shader. 37

38 Attribute Qualifier Attribute-qualified variables can change at most once per vertex Cannot be used in fragment shaders Built-in (OpenGL state variables) gl_vertex gl_normal gl_color gl_multitexcoord0 User defined (in application program) attribute float temperature attribute vec3 velocity 38

39 Uniform Qualifier Variables that are constant for an entire primitive Allows communication between OGL application and both shaders Can be changed in application outside scope of glbegin and glend Cannot be changed in shader Used to pass information to shader such as the bounding box of a primitive 39

40 Varying qualifier Variables that are passed from vertex shader to fragment shader Automatically interpolated by the rasterizer Built in Vertex colors Texture coordinates User defined Requires a user defined fragment shader 40

41 Example: Vertex Shader const vec4 red = vec4(1.0, 0.0, 0.0, 1.0); varying vec4 color_out; void main(void) { gl_position = gl_modelviewprojectionmatrix*gl_vertex; color_out = red; (e.g. instead of gl_frontcolor = red;) } 41

42 Required Fragment Shader varying vec4 color_out; void main(void) { gl_fragcolor = color_out; 1 } 1 instead of gl_fragcolor = gl_color; 42

43 Color shading Exception to the "rule" where a varying variable should be declared with the same name both in the vertex shader and the fragment shader attribute vec4 gl_color; varying vec4 gl_frontcolor; // writable on the vertex shader varying vec4 gl_backcolor; // writable on the vertex shader varying vec4 gl_color; // readable on the fragment shader Vertex Shader: void main() { gl_frontcolor = gl_color; gl_position = ftransform(); } NOTE: gl_position = ftransform(); instead of gl_position = gl_modelviewprojectionmatrix*gl_vertex; Fragment Shader: void main() { gl_fragcolor = gl_color; } 43

44 Built-in Uniforms uniform mat4 gl_modelviewmatrix; uniform mat4 gl_projectionmatrix; uniform mat4 gl_modelviewprojectionmatrix; uniform mat3 gl_normalmatrix; uniform mat4 gl_texturematrix[n]; struct gl_materialparameters { vec4 emission; vec4 ambient; vec4 diffuse; vec4 specular; float shininess; }; uniform gl_materialparameters gl_frontmaterial; uniform gl_materialparameters gl_backmaterial; 44

45 Built-in Uniforms struct gl_lightsourceparameters { vec4 ambient; vec4 diffuse; vec4 specular; vec4 position; vec4 halfvector; vec3 spotdirection; float spotexponent; float spotcutoff; float spotcoscutoff; float constantattenuation float linearattenuation float quadraticattenuation }; Uniform gl_lightsourceparameters gl_lightsource[gl_maxlights]; // stored in eye space 45

46 Uniform Variable Example GLint angleparam = glgetuniformlocation(myprogobj, "angle"); /* angle defined in shader */ // set angle to 5.0 gluniform1f(myprogobj, angleparam, 5.0); 46

47 Vertex Attribute Example GLint colorattr = glgetattriblocation(myprogobj, "mycolor"); /* mycolor is name in shader */ GLfloat color[4]; glvertexattrib4fv(colorattrib, color); /* color is variable in application */ 47

48 Syntax C/C++ language style Data Types scalars float, int, bool vectors vec, ivec, bvec matrizes mat structs, arrays in, out, inout (usados nos parâmetros de função) Flow Control if else, for, while, do while 48

49 GLSL Data Types 49

50 Entradas e saídas 50

51 Entradas e saídas 51

52 GLSL Hello 52

53 GLSL Hello Vertex shader!void main(void)!!{!! gl_position = ftransform();!!}! Fragment shader!void main(void)!!{!! gl_fragcolor = vec4(1.0, 0.0, 0.0, 1.0);!!}! 53

54 GLSL - Achatado 54

55 GLSL - Achatado Vertex shader void main(void)! {! vec4 vert = gl_vertex;! vert.z = 0;! gl_position = gl_modelviewprojectionmatrix * vert;! }! 55

56 GLSL - Ondulante 56

57 GLSL - Ondulante Vertex shader uniform float ftime0_x;! void main(void)! {! vec4 vert = gl_vertex;! vert.z = sin(0.5*vert.x + ftime0_x)*2.0;! gl_position = gl_modelviewprojectionmatrix * vert;! }! 57

58 Vertex vs Fragment Shader per vertex lighting per fragment lighting 58

59 Diffuse term The following formula is used in OpenGL to compute the diffuse term: where I is the reflected intensity, Ld is the light's diffuse color (gl_lightsource[0].diffuse), and Md is the material's diffuse coefficient (gl_frontmaterial.diffuse). 59

60 Specular term Blinn proposed a simpler and faster model, knows as the Blinn-Phong model 60

61 Specular Term // normalize the half-vector, and then compute the cosine (dot product) with the normal NdotHV = max(dot(normal, gl_lightsource[0].halfvector.xyz),0.0); specular = gl_frontmaterial.specular * gl_lightsource[0].specular * pow(ndothv,gl_frontmaterial.shininess); 61

62 Point Light Issue in a point light, the intensity decays with the distance to the vertex In vertex shader: ecpos = gl_modelviewmatrix * gl_vertex; // in eye space aux = vec3(gl_lightsource[0].position-ecpos); lightdir = normalize(aux); dist = length(aux); //varying In fragment shader (attenuation cannot be interpolated since is non-linear): att = 1.0 / (gl_lightsource[0].constantattenuation + gl_lightsource[0].linearattenuation * dist + gl_lightsource[0].quadraticattenuation * dist * dist); 62

63 Examples of Per-Pixel Lighting Directional Light Point Light 63

64 Texturing Access texture coordinates per vertex - GLSL provides some attribute variables, one for each texture unit! attribute vec4 gl_multitexcoord0;! attribute vec4 gl_multitexcoord1;! attribute vec4 gl_multitexcoord2;! attribute vec4 gl_multitexcoord3;! attribute vec4 gl_multitexcoord4;! attribute vec4 gl_multitexcoord5;! attribute vec4 gl_multitexcoord6;! attribute vec4 gl_multitexcoord7;! uniform mat4 gl_texturematrix[gl_maxtexturecoords]; (varying) gl_texcoord[0] = gl_multitexcoord0;! 64

65 Texturing void main() {! gl_texcoord[0] = gl_multitexcoord0;! // gl_texcoord[0] = gl_texturematrix[0] * gl_multitexcoord0;! gl_position = ftransform();! }! uniform sampler2d tex;! void main()! {!!vec4 color = texture2d(tex,gl_texcoord[0].st);!!gl_fragcolor = color;! }! 65

66 Texturing 66

67 VERTEX shader: Example of GL_Modulate varying vec3 lightdir,normal; void main() { normal = normalize(gl_normalmatrix * gl_normal); lightdir = normalize(vec3(gl_lightsource[0].position)); gl_texcoord[0] = gl_multitexcoord0; gl_position = ftransform(); } FRAGMENT Shader: varying vec3 lightdir,normal; uniform sampler2d tex; void main() { vec3 ct,cf; vec4 texel; float intensity,at,af; intensity = max(dot(lightdir,normalize(normal)),0.0); cf = intensity * (gl_frontmaterial.diffuse).rgb + gl_frontmaterial.ambient.rgb; af = gl_frontmaterial.diffuse.a; texel = texture2d(tex,gl_texcoord[0].st); ct = texel.rgb; at = texel.a; } gl_fragcolor = vec4(ct * cf, at * af); 67

68 varying vec3 lightdir,normal; uniform sampler2d tex, l3d; Multitexturing void main() { vec3 ct,cf; vec4 texel; float intensity,at,af; Texture Unit 0 intensity = max(dot(lightdir,normalize(normal)),0.0); Texture Unit 1 cf = intensity * (gl_frontmaterial.diffuse).rgb + gl_frontmaterial.ambient.rgb; af = gl_frontmaterial.diffuse.a; texel = texture2d(tex,gl_texcoord[0].st)+ texture2d(l3d,gl_texcoord[0].st); ct = texel.rgb; at = texel.a; gl_fragcolor = vec4(ct * cf, at * af); } Textured cube 68

69 GLSL - Listas 69

70 GLSL - Listas Vertex shader varying vec2 MC;! void main(void)! {! MC = gl_vertex.xy;! }! gl_position = ftransform();! 70

71 GLSL - Listas Fragment shader varying vec2 MC;! void main(void)! {! float r = fract(mc.x*0.05);! if (r < 0.5)! r = 1.0;! else! r = 0.5;! }! gl_fragcolor = vec4(r, 0.0, 0.0, 1.0);! 71

72 GLSL Mais Exemplos 72

74 Futuro do hardware gráfico Roda da reencarnação Função migrada para co-processador específico por razões de desempenho Co-processador torna-se programável, com as funcionalidades de um CPU Não faz sentido ter toda essa capacidade de processamento, inutilizada grande parte do tempo, num processador específico para uma só aplicação Movem-se funcionalidades para o CPU T.H. Myer and I.E. Sutherland On the Design of Display Processors, Comm. ACM, Vol. 11, no. 6, June

75 Referências OpenGL Shading Language, Second Edition - Randi Rost, Addison Wesley Professional Especificação - John Kessenich Quick Reference Guide - Mike Weiblen GLSL - Programação de Shaders António Ramires Fernandes GLSL Tutorial - Lighthouse 3D Rendermonkey GLEW 75