GLSL OpenGL Shading Language. Waldemar Celes Departamento de Informática, PUC-Rio inf. puc-rio. br

Transcription

1 OpenGL Shading Language Waldemar Celes Departamento de Informática, PUC-Rio inf. puc-rio. br

2 Pipeline Programável Vertex & fragment shader Vertex program Aplicação Transformação Modelagem e Visualização Iluminação Projeção Clipping Mapeamento de Tela Rasterização Mapeamento de Textura Combinação Blend Teste α,s,z Frame Buffer Fragment program Aplicação Geometria Rasterização

3 Pipeline Programável w Controle sobre operações de vértices w Controle sobre operações de fragmentos w Operações substituídas n Transformação n Iluminação n Projeção n Geração de coordenadas de textura n Aplicação de textura n Combinação w Geração de geometria w CPU GPU

4 Vertex shader w Operações substituídas n Transformação de vértices l Modelview e projection n Transformação de normais l Transformação, re-escala, normalização n Iluminação por vértice n Geração de coordenadas de textura n Geração de coordenadas de clip n Definição de tamanho de ponto

5 Vertex shader w Operações não substituídas n Clipping contra frustum n Divisão da perspectiva n Mapeamento de tela l Transformação de viewport l Transformação de Z

6 Vertex shader w Recebe um vértice n Não transformado e não iluminado w Transforma o vértice n As 4 componentes devem ser preenchidas w Opcionalmente n Gera coordenadas de textura l Aplica transformações l A coordenada w deve ser preenchida n Ilumina n Calcula fator de fog n Calcula tamanho de ponto n etc.

7 Vertex shader w Não cria ou destrói vértice n 1 vértice de entrada n 1 vértice de saída w Não há informação topológica n Não há aresta, face n Não há info de vértices vizinhos l Podemos usar atributos com info explicitada w Carregado dinamicamente n Como objetos de textura

8 Fragment shader w Aplicado a qualquer fragmento n Ponto, linha, triângulo, pixel, bitmap n Pode-se descartar fragmentos w Processamento n Fragmento a fragmento, independentes w Operações substituídas n Texturing n Color sum l Soma das cores primária e secundária pelo programa w Acesso ao stencil e buffers auxiliares n Possível futura extensão

9 230 CHAPTER 6 Thinking Outside the Box: Nonstock Shaders Arquitetura GLSL básica 101 The OpenGL Shading Language (GLSL) is a C-like high-level language that is compiled and linked by your OpenGL implementation and (usually) runs entirely on the graphics hardware. Shader programs look a lot like C, they start with the main function as their entry point, and you can write functions in GLSL that accept parameters and return values. Vertex & fragment shader Figure 3.1 from Chapter 3 is repeated here as Figure 6.1 and shows our basic shader architecture. Application Code: C/C++, etc. OpenGL API Client Texture Data Texture Data Uniforms Uniforms Vertex Shader void main() { Positions } Vertex Primitive Assembly (Ins) Attributes Outs Server ptg Ins Fragment Shader void main() { } FIGURE 6.1 Our basic shader architecture. 9

10 perspective. Variables and Data Types A good place to start for learning GLSL is to discuss the data types available to you. There are only four: integers (both signed and unsigned), floats (single precision only as of OpenGL 3.3), and Booleans (bool). There are no pointers in GLSL, and there are no strings or characters of any kind. Functions can return any of these data types but can also be declared as void, but again, no void pointers allowed. The use of these data types in GLSL mirrors their usage in C/C++. Tipos de variáveis 6 bool bdone = false; // Boolean true or false int ivalue = 42; // Signed integer 232 CHAPTER uint uivalue 6 Thinking = 3929u; Outside // the unsigned Box: Nonstock integer Shaders float fvalue = 42.0f; // Floating point value 232 CHAPTER 6 Thinking Outside the Box: Nonstock Shaders Types Tipos de TABLE vetores 6.1 GLSL Vector built-in Data Types vec2, vec3, vec4 Construtores TABLE Vector 6.1 TypesGLSL Vector Data Types An exciting and unique feature Description of GLSL (as compared to C/C++) is the availability of vector data types. All four of the basic data types can be stored in two-, three-, or fourdimensional 2, 3, and 4 component floating-point vectors Types vectors. The Description complete list of vector data types is listed in Table 6.1. ivec2, ivec3, ivec4 2, 3, and 4 component integer vectors vec2, uvec2, vec3, uvec3, vec4 uvec4 2, 3, 2, and 3, and 4 4 component floating-point unsigned integer vectors vectors ivec2, bvec2, ivec3, bvec3, ivec4 bvec4 2, 3, 2, and 3, and 4 component 4 component integer Boolean vectors vectors uvec2, uvec3, uvec4 2, 3, and 4 component unsigned integer vectors bvec2, bvec3, bvec4 2, 3, and 4 component Boolean vectors A vector data type can be declared just like any other kind of variable; for example, you would declare a vertex position as a four-component floating-point vector like this: A vector data type can be declared just like any other kind of variable; for example, you would vec4 declare vvertexpos; a vertex position as a four-component floating-point vector like this: Download from vec4 You vvertexpos; can also initialize a vector with a constructor: You vec4 can vvertexpos also initialize = vec4(39.0f, a vector with 10.0f, a constructor: 0.0f, 1.0f); vec4 vvertexpos = vec4(39.0f, 10.0f, 0.0f, 1.0f); This should not be confused with C++ class constructors. GLSL vector data types are not classes; they are their own built-in data type. Vectors can be assigned to one another, This should not be confused with C++ class constructors. GLSL vector data types are not added together, scaled by a scalar (nonvector type), and so on. classes; they are their own built-in data type. Vectors can be assigned to one another, added vvertexpos together, = scaled voldpos by + a scalar voffset; (nonvector type), and so on. 10

11 Vetores built-in Sufixos: vvertexpos.x xyzw, rgba, = 3.0f; stpq Swizzling classes; they are their own built-in data type. Vectors can be assigned to one another, vvertexpos added together, = voldpos scaled by + voffset; a scalar (nonvector type), and so on. added together, scaled by a scalar (nonvector type), and so on. vvertexpos = vnewpos; vvertexpos voldpos + voffset; vvertexpos += = voldpos vec4(1.0f, + voffset; 1.0f, 0.0f, 0.0f); vvertexpos = vnewpos; vvertexpos *= = vnewpos; 5.0f; vvertexpos += vec4(1.0f, 1.0f, 0.0f, 0.0f); vvertexpos *= += 5.0f; vec4(1.0f, 1.0f, 0.0f, 0.0f); Another vvertexpos unique *= 5.0f; feature to GLSL is how we can address individual elements of a vector. If you Another are familiar unique feature with the union to GLSL is construct how we from can address C/C++, individual vectors are elements like unions of a on vector. steroids. If We Another you use are the familiar unique dot notation with feature the to to address union GLSL construct is up how to from four we can C/C++, vector address elements, vectors individual are but like we unions elements can use on any of steroids. a of vector. the If following you We use are the three familiar dot notation sets of identifiers: with the to union address xyzw, construct up to rgba, four from vector or stpq. C/C++, elements, Typically vectors but we are we would can like use use unions any the xyzw of on the set steroids. of We following identifiers use the three when dot sets referring notation of identifiers: to vertex to address xyzw, type up rgba, data. to four or stpq. vector Typically elements, we would but we use can the use xyzw any set of the following of identifiers three when sets referring of identifiers: to vertex xyzw, type rgba, data. or stpq. Typically we would use the xyzw set vvertexpos.xy of vvertexpos.x identifiers = when = vec2(3.0f, 3.0f; referring 5.0f); to vertex type data. vvertexpos.xyz = vnewpos.xyz; vvertexpos.xy = 3.0f; vec2(3.0f, 5.0f); GLSL vvertexpos.xy vvertexpos.xyz = vnewpos.xyz; vec2(3.0f, 5.0f); Then rgba when doing color work. vvertexpos.xyz = vnewpos.xyz; voutputcolor.r Then choice rgba when of which = doing 1.0f; set color of identifiers work. you use is completely arbitrary as far as GLSL is voutputcolor.rgba concerned; for example, Then voutputcolor.r rgba when = 1.0f; doing = vec4(1.0f, you could color work. 1.0f, easily 0.5f, do something 1.0f); like this: GLSL vtexcoord.st voutputcolor.rgba = vvertex.st; = vec4(1.0f, 1.0f, 0.5f, 1.0f); And voutputcolor.r finally, when = working 1.0f; with texture coordinates, stpq. The choice of which set of identifiers you use is completely arbitrary as far as GLSL is voutputcolor.rgba = vec4(1.0f, 1.0f, 0.5f, 1.0f); vtexcoord.st However, And concerned; finally, what for when = example, you vec2(1.0f, working cannot you with could do 0.0f); is texture easily mix the do coordinates, something different like groups stpq. this: within a single vector access, such as this: And vtexcoord.st finally, when = vec2(1.0f, vvertex.st; working 0.0f); with texture coordinates, stpq. vtexcoord.st = vvertex.xt; // mixing of x and t is not allowed! vtexcoord.st However, what = you vec2(1.0f, cannot do is 0.0f); mix the different groups within a single vector access, such as this: Vector data types also support swizzling. A swizzle is when you swap two or more vector vtexcoord.st = vvertex.xt; // mixing of x and t is not allowed! elements. For example, if you were converting color data from RGB ordering to BGR ordering, Vector the data following types also line support of code swizzling. would A do swizzle the trick: is when you swap two or more vector elements. For example, if you were converting color data from RGB ordering to BGR Download ordering, the following line of code would do the trick: Download from from vnewcolor.bgra = voldcolor.rgba; Vector vnewcolor.bgra data types = are voldcolor.rgba; not only native to GLSL, they are native to the hardware. They are fast, and operations are performed on all the components at once. For example, Download the from Vector data types are not only native to GLSL, they are native to the hardware. They are following fast, and operations operation are performed on all the components at once. For example, the following operation vvertex.x = vothervertex.x INF f; - W. Celes - PUC-Rio 11

12 TABLE 6.2 Matrizes built-in Matrix Types In addition to the vector data types, GLSL supports a number of matrix types. Unlike the vector types, however, the matrix types are all floating-point only sorry, no integer or Boolean matrices, as these are not practically useful. Table 6.2 lists the supported matrix types. Type mat2, mat2x2 mat3, mat3x3 mat4, mat4x4 CHAPTER mat2x3 6 mat2x4 mat3x2 GLSL Matrix Types Description 2 columns and 2 rows 3 columns and 3 rows 4 columns and 4 rows Thinking Outside 2 columns the Box: and Nonstock 3 rows Shaders 2 columns and 4 rows 3 columns and 2 rows A mat3x4 matrix is essentially an array 3 columns of vectors and 4 rows in GLSL column vectors, in fact (a review of column mat4x2 4 columns and 2 rows CHAPTER major 6 Thinking vector Outside ordering the from Box: Chapter Nonstock 4, Shaders Basic Transformations: A Vector/Matrix Primer, mat4x3 may be in order here). 4 columns For and example, 3 rows to set the last column of a 4 x 4 matrix, you would write code similar to this: mmodelview[3] A matrix is essentially = vec4(0.0f, an array 0.0f, of vectors 0.0f, in 1.0f); GLSL column vectors, in fact (a review of column major vector ordering from Chapter 4, Basic Transformations: A Vector/Matrix Conversely, Primer, may to be retrieve in order the here). last column For example, of a matrix: to set the last column of a 4 x 4 matrix, you would write code similar to this: Download from vec4 vtranslation = mmodelview[3]; mmodelview[3] = vec4(0.0f, 0.0f, 0.0f, 1.0f); Essencialmente, array de vetores por coluna Or even a finer grained query: Conversely, to retrieve the last column of a matrix: vec3 vtranslation = mmodelview[3].xyz; vec4 vtranslation = mmodelview[3]; Matrices can be multiplied by vectors too; a common use of this is to transform a vertex by Or the even ModelViewProjection a finer grained query: matrix, such as: vec3 vtranslation = mmodelview[3].xyz; vec4 vvertex; mat4 mvpmatrix; 12

13 234 Matrizes built-in Construtores Matrices can be multiplied by vectors too; a common use of this is to transform a vertex Matrices by the ModelViewProjection can be multiplied by matrix, vectors such too; as: a common use of this is to transform a vertex by the ModelViewProjection matrix, such as: vec4 vvertex; vec4 mat4 vvertex; mvpmatrix; mat4 CHAPTER mvpmatrix; 6 Thinking Outside the Box: Nonstock Shaders voutpos = mvpmatrix * vvertex; voutpos A matrix = is mvpmatrix essentially * an vvertex; array of vectors in GLSL column vectors, in fact (a review of Also, column just major like vectors, ordering the matrix from data Chapter types have 4, Basic their Transformations: own constructors A too. Vector/Matrix For example, Also, to Primer, hard just code may like an vectors, be inline order the 4 x here). matrix 4 matrix, For data example, you types can have write to set their code the own last like column constructors this: of a 4 too. x 4 For matrix, example, you to hard code an inline 4 x 4 matrix, you can write code like this: mat4 would vtransform write code = similar mat4(1.0f, to this: 0.0f, 0.0f, 0.0f, mat4 mmodelview[3] vtransform = = vec4(0.0f, mat4(1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f); 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, Conversely, to retrieve the 0.0f, last column 0.0f, 1.0f, 0.0f, of a matrix: 0.0f, 1.0f); 0.0f, 0.0f, 0.0f, 1.0f); In vec4 this vtranslation case we made = the mmodelview[3]; transformation matrix the identity matrix. A quicker constructor In for this matrices case we that made fills the in just transformation the diagonal matrix with a the single identity value matrix. can also A be quicker used. constructor for Or mat4 matrices even a finer vtransform that grained fills = mat4(1.0f); in just query: the diagonal with a single value can also be used. vec3 vtranslation = mmodelview[3].xyz; mat4 vtransform = mat4(1.0f); Operações Storage com Qualifiers vetores Matrices can be multiplied by vectors too; a common use of this is to transform a vertex Storage Shader by the ModelViewProjection variable Qualifiers declarations may matrix, optionally such as: have a storage qualifier specified. Qualifiers are used to flag variables as input variables (in or uniform), output variables (out), or Shader vec4 vvertex; variable declarations may optionally have a storage qualifier specified. Qualifiers constants (const). Input variables receive data either from the OpenGL client (attributes are mat4 used mvpmatrix; to flag variables as input variables (in or uniform), output variables (out), or submitted via C/C++) or from the previous shader stage (for example, variables passed constants (const). Input variables receive data either from the OpenGL client (attributes from the vertex shader to the fragment shader). Output variables are variables you write to submitted via C/C++) or from the previous shader stage (for example, variables passed in any of the shader stages that you want to be seen by the subsequent shader stages, for from voutpos the = vertex mvpmatrix shader * to vvertex; the fragment shader). Output variables are variables you write to example, passing data from the vertex shader to the fragment shader or writing the final in any of the shader stages that you want to be seen by the subsequent shader stages, for fragment color by the fragment shader. Table 6.3 lists the primary variable qualifiers. example, Also, just passing like vectors, data from the matrix the vertex data shader types have to the their fragment own constructors shader or writing too. For the example, final fragment to hard code color an by inline the fragment 4 x 4 matrix, shader. you Table can write 6.3 lists code the like primary this: variable qualifiers. mat4 vtransform = mat4(1.0f, 0.0f, 0.0f, 0.0f, 13

14 ?$%&#9+5296$+',$GJ&9#66-2'6?;7 %&# Operadores M*-(KN-+OP(H*9"#+?(P9+?79?-(*9.($*-(C%22%<#+?(%N-&9$%&.5 K9#:#,#':# %&#9+529$41+66 %&# N662:-+5->-5C ((4(e*#?*-.$f N9&-+$*-$#/92(?&%7N#+? O*P ((((((W6 A F 9&&9I(.7Y./&#N$ C7+/$#%+(/922(9+"(/%+.$&7/$%&(.$&7/$7&-( C#-2"(%&(@-$*%"(.-2-/$%&0(.<# 2-& N%.$(C#Q(#+/&-@-+$(9+"("-/&-@-+$ N&-C#Q(#+/&-@-+$(9+"("-/&-@-+$ 7+9&I M*N O*P, GG**AA GG**AA G**A**V**X P-C$($%(=#?*$ =#?*$($%(P-C$ I***H****J P-C$($%(=#?*$ D 9""#$#:- G**A P-C$($%(=#?*$ G Y#$X<#.-(.*#C$ KK****LL P-C$($%(=#?*$ T &-29$#%+92 K****L****KW***LW P-C$($%(=#?*$ U -]792#$I WW***XW P-C$($%(=#?*$ [ Y#$X<#.-(9+"( U P-C$($%(=#?*$ 4J Y#$X<#.-(-Q/27.#:-(%&( S P-C$($%(=#?*$ 44 Y#$X<#.-(#+/27.#:-(%&( T P-C$($%(=#?*$ 4A 2%?#/92(9+" UU P-C$($%(=#?*$ 4F 2%?#/92(-Q/27.#:-(%& SS P-C$($%(=#?*$ 4E 2%?#/92(#+/27.#:-(%& T*T P-C$($%(=#?*$ 4D.-2-/$#%+ [*Y =#?*$($%(P-C$ 4G 6..#?+@-+$ 9&#$*@-$#/(9..#?+@-+$. W GW**AW IW**HW JW****KKW***LLW UW**SW**TW =#?*$($%(P-C$ 4T(e2%<-.$f.-]7-+/- D P-C$($%(=#?*$ M*-&-(#.(+%(9""&-..X%C(%N-&9$%&(+%&(9("-&-C-&-+/-(%N-&9$%&5((M*-&-(#.(+%($IN-/9.$(%N-&9$%&i(/%+.$&7/$%&.( 14

15 Qualificadores de tipos <none>: TABLE variável 6.3 Variable local, Storage sem Qualifiers visibilidade externa in out const Global: variável passada por estágio anterior Parâmetro: in centroid variável local regular Global: uniform variável passada para próximo estágio Parâmetro: variável de saída inout Qualifier Description <none> Just a normal local variable, no outside visibility or access. in out A compile-time constant, or a read-only parameter to a function. A variable passed in from a previous stage. Passed in from a previous state, uses centroid interpolation. Passed out to the next processing stage or assigned a return value in a function. out centroid Passed out to the next processing stage, uses centroid interpolation. inout A read/write variable. Only valid for local function parameters. Value is passed in from client code and does not change across vertices. One variable qualifier inout can only be used when declaring a parameter to a function. Because GLSL does not support pointers (or references), this is the only way to pass a value to a function and allow the function to modify and return the value of the same variable. For example, this function declaration Parâmetro: variável de entrada e saída GLSL const int CalculateSometing(float ftime, float fstepsize, inout float fvariance); would return an integer (perhaps a pass/fail flag), but also could modify the value of the fvariance variable, and the calling code could read the new value back from the variable as well. In C/C++, to allow modification of a parameter, you might well declare the function this way using a pointer: Global: constante para tempo de compilação Parâmetro: read-only int CalculateSomething(float ftime, float fstepsize, float* fvariance); 6 The centroid qualifier has no effect unless rendering is being done to a multisampled 15

16 as well. In C/C++, to allow modification of a parameter, you might well tion this way using a pointer: int CalculateSomething(float ftime, float fstepsize, float* fvaria Qualificadores The centroid qualifier has no effect unless rendering is being done to a buffer. In a single sampled buffer, interpolation is always performed from pixel. With multisampling, when the centroid qualifier is used, the inte selected so that it falls within the primitive and the pixel. See Chapter 9 Buffers: Beyond the Basics, for more details about how multisampling w Especificação de interpolação entre estágios <none>, smooth: interpolados com correção perspectiva noperspective: interpolados linearmente By default parameters are interpolated between shader stages in a perspe manner. You can specify nonperspective interpolation with the nopersp even no interpolation at all with the flat keyword. You can also option keyword to explicitly state the variable is smoothly interpolated in a per manner, but that is already the default. Here are a few example declarat flat: não interpolados centroid: usado em interpolação para multi-samples smooth out vec3 vsmoothvalue; flat out vec3 vflatcolor; noperspective float vlinearlysmoothed; 16

17 Variáveis built-in Vertex shader in int gl_vertexid; in int gl_instanceid; out vec4 gl_position; out float gl_pointsize; out float gl_clipdistance[]; Fragment shader in vec4 gl_fragcoord; in bool gl_frontfacing; in float gl_clipdistance; in float gl_pointsize; in float gl_clipdistance[]; in int gl_primitiveid; in int gl_sampleid; OpenGL 2.*: Vertex shader in: attribute out: varying Fragment shader in: varying in vec2 gl_sampleposition; out vec4 gl_fragcolor; out vec4 gl_fragdata[]; out float gl_fragdepth; out int gl_samplemask[]; 17

18 Exemplo de shader Vertex shader #version 330 in vec4 vvertex; in vec4 vcolor; out vec4 vvaryingcolor; // Vertex position attribute // Vertex color attribute // Color value passed to fragment shader void main(void) { vvaryingcolor = vcolor; gl Position = vvertex; } Fragment shader 240 CHAPTER 6 Thinking Outside the Box: Nonstock Shaders // Simply copy the color value // Simply pass along the vertex position #version 330 in vec4 vvaryingcolor; void main(void) { gl FragColor = vvaryingcolor; } // Interpolated color to fragment FIGURE 6.2 Output from the ShadedTriangle program. 18

19 Shader Uniforms While attributes are needed for per-vertex positions, surface normals, texture coordinates, // Incoming per vertex and so on, a uniform is how we pass data into a shader that stays the same is uniform in vec4 vvertex; for the entire primitive batch. Probably the single most common uniform for a vertex shader is the transformation matrix. Previously, we allowed the GLShaderManager class to void main(void) do this for us, with built-in support for the stock shaders and their needed uniforms. Now { that we are writing our own shaders, we need to be able to set our own uniforms, and not // This is pretty much it, transform the geo just for matrix values; any shader variable can be specified as a uniform, and uniforms can gl_position = mvpmatrix * vvertex; be in any of the three shader stages (even though we only talk about vertex and fragment shaders in this chapter). Making a uniform is as simple as placing the keyword uniform at the beginning of the variable declaration: Variáveis uniforms } Constantes por primitivas de desenho uniform float ftime; LISTING 6.5 The Flat Shader Fragment Program uniform int iindex; // Flat Shader uniform vec4 vcolorvalue; // Fragment Shader uniform mat4 mvpmatrix; // Richard S. Wright Jr. // OpenGL SuperBible Shader Uniforms 253 Uniforms cannot be marked as in or out, they cannot be interpolated (although you can #version 130 copy them into interpolated variables) between shader stages, and they are always readonly. // Transformation Matrix // Make geometry solid uniform mat4 mvpmatrix; uniform vec4 vcolorvalue; Exemplo: flat shader Finding Your Uniforms uniform mat4 mvpmatrix; // Incoming After a shader per vertex has been compiled and linked, you must find // Output the uniform fragment location color in the in vec4 shader. vvertex; This is done with the function glgetuniformlocation. out vec4 vfragcolor; GLint glgetuniformlocation(gluint shaderid, const GLchar* varname); void main(void) void main(void) { { // This is pretty much it, transform the geometry gl_fragcolor = vcolorvalue; gl_position = mvpmatrix * vvertex; } } 6 In the vertex program shown in Listing 6.4 we have 19 transformation matrix.

20 256 CHAPTER 6 Thinking Outside the Box: Nonstock Shaders Funções built-in Trigonometry Functions Funções trigonométricas Table 6.4 lists the trigonometry functions that are supported by GLSL. These functions are defined for float, vec2, vec3, and vec4 data types. Here we denote the data type by anyfloat, meaning any of these four floating-point data types. anyfloat: float, vec2, vec3, vec4 Componente a componente TABLE 6.4 Function Trigonometric Functions anyfloat radians(anyfloat degrees) anyfloat degrees(anyfloat radians) anyfloat sin(anyfloat angle) anyfloat cos(anyfloat angle) anyfloat tan(anyfloat angle) anyfloat asin(anyfloat x) anyfloat acos(anyfloat x) anyfloat atan(anyfloat y, anyfloat x) anyfloat atan(anyfloat y_over_x) anyfloat sinh(anyfloat x) anyfloat cosh(anyfloat x) anyfloat tanh(anyfloat x) anyfloat asinh(anyfloat x) anyfloat acosh(anyfloat x) anyfloat atanh(anyfloat x) Description Converts degrees to radians Converts radians to degrees Trigonometric sine Trigonometric cosine Trigonometric tangent Arc sine Arc cosine Arc tangent of y / x Arc tangent of y_over_x Hyperbolic sine Hyperbolic cosine Hyperbolic tangent Arc hyperbolic sine Arc hyperbolic cosine Arc hyperbolic tangent Exponential Functions 20

21 6 GLSL anyfloat acosh(anyfloat x) anyfloat atanh(anyfloat x) Exponential Functions Funções given in built-in Table 6.5. TABLE 6.5 Exponential Functions Funções de exponenciação TABLE 6.6 Funções geométricas Arc hyperbolic cosine Arc hyperbolic tangent Like the trigonometric functions, the exponential functions work on the floating-point data types (floats and floating-point vectors). The complete list of exponential functions is Function anyfloat pow(anyfloat x, anyfloat y) anyfloat exp(anyfloat x) Geometric Functions anyfloat log(anyfloat x) Description x raised to the y power Natural exponent of x The natural logarithm of x A anyfloat number exp2(anyfloat of general purpose x) geometric 2 functions raised to the are power also of included x in GLSL. Some of these anyfloat functions log2(anyfloat have angle) specific argument types Base 2 (cross logarithm product of x for example); others accept any anyfloat of the sqrt(anyfloat floating-point x) vector types (vec2, Square vec3, root of and x vec4), which we refer to here only as anyfloat vec. These inversesqrt(anyfloat functions are x) listed in Table Inverse 6.6. square root of x Function Geometric Functions float length(vec2/vec3/vec4 x) float distance(vec p0, vec p1) float dot(vec x, vec y) vec3 cross(vec3 x, vec3 y) Description Returns the length of the vector x Returns the distance between p0 and p1 Returns the dot product of x and y Returns the cross product of x and y vec normalize(vec x) Returns a unit length vector in the same direction as x Download from vec faceforward(vec N, vec I, vec nref) if dot(nref, I) < 0 return N, else return N vec reflect(vec I, vec N) vec refract(vec I, vec N, float eta) Returns reflection direction for incident vector I and surface orientation N Returns refraction vector for incident vector I, surface orientation N, and ratio of indices of refraction eta Built-In Functions 257 Matrix Functions 21

22 vec refract(vec I, vec N, float eta) surface orientation N Returns refraction vector for incident vector I, surface orientation N, and ratio of indices of refraction eta Matrix Functions Funções built-in Many matrix operations are done using the regular mathematical operators. Some useful matrix functions, however, are listed in Table 6.7. Each of these functions is specific and takes a specific argument data type, which is shown in the table. TABLE Funções 6.7 Matrix algébricas Functions Function Description mat matrixcompmult(mat x, mat y) Multiplies two matrices together component by component. This is not the same as the linear algebraic matrix multiply. mat2 outerproduct(vec2 c, vec2 r) Returns a matrix that is the outer product of the two vectors specified. mat3 outerproduct(vec3 c, vec3 r) mat4 outerproduct(vec4 c, vec4 r) mat2x3 outerproduct(vec3 c, vec2 r) mat3x2 outerproduct(vec2 c, vec3 r) mat2x4 outerproduct(vec4 c, vec2 r) mat4x2 outerproduct(vec2 c, vec4 r) mat3x4 outerproduct(vec4 c, vec3 r) mat4x3 outerproduct(vec3 c, vec4 r) 6 Download from 22

23 258 CHAPTER 6 Funções built-in Funções algébricas Thinking Outside the Box: Nonstock Shaders TABLE 6.7 Matrix Functions continued Function Description mat2 transpose(mat2 m) Returns a matrix that is the transpose of the matrix specified. mat3 transpose(mat3 m) mat4 transpose(mat4 m) mat2x3 transpose(mat3x2 m) mat3x2 transpose(mat2x3 m) mat2x4 transpose(mat4x2 m) mat4x2 transpose(mat2x4 m) mat3x4 transpose(mat4x3 m) mat4x3 transpose(mat3x4 m) float determinant(mat2 m) float determinant(mat3 m) float determinant(mat4 m) Returns the determinant of the matrix specified. mat2 inverse(mat2 m) mat3 inverse(mat3 m) mat4 inverse(mat4 m) Returns a matrix that is the inverse of the matrix specified. Vector Relational Functions Scalar values can be compared using the standard equality operators (<, <=, >, >=, ++,!=). For vector comparisons, the functions listed in Table 6.8 are provided. All of these functions return a Boolean vector of the same number of dimensions as the arguments. TABLE 6.8 Vector Relational Functions 23

24 float determinant(mat4 m) GLSL mat2 inverse(mat2 m) mat3 inverse(mat3 m) mat4 inverse(mat4 m) Returns a matrix that is the inverse of the matrix specified. Vector Relational Functions Funções built-in Scalar values can be compared using the standard equality operators (<, <=, >, >=, ++,!=). For vector comparisons, the functions listed in Table 6.8 are provided. All of these functions return a Boolean vector of the same number of dimensions as the arguments. Funções TABLE 6.8 relacionais Vector Relational Functions para vetores Function Description bvec lessthan(vec x, vec y) Returns component by component the result of x < y. bvec lessthan(ivec x, ivec y) bvec lessthan(uvec x, uvec y) ptg bvec lessthanequal(vec x, vec y) Returns component by component the result of x <= y. bvec lessthanequal(ivec x, ivec y) bvec lessthanequal(uvec x, uvec y) Built-In Functions 259 bvec greaterthan(vec x, vec y) Returns component by component the result of x > y. bvec greaterthan(ivec x, ivec y) bvec Function greaterthan(uvec x, uvec y) Description bvec greaterthanequal(vec x, vec y) Returns component by component the result of x >= y. bvec greaterthanequal(ivec x, ivec y) bvec greaterthanequal(uvec x, uvec y) bvec equal(vec x, vec y) Returns component by component the result of x == y. bvec equal(ivec x, ivec y) bvec equal(uvec x, uvec y) bvec equal(bvec x, bvec y) Download from bvec notequal(vec x, vec y) Returns component by component the result of x!= y. bvec notequal(ivec x, ivec y) bvec notequal(uvec x, uvec y) bvec notequal(bvec x, bvec y) bool any(bvec x) Returns true if any component of x is true. bool all(bvec x) Returns true if all components of x are true. bvec not(bvec x) Returns component wise complement of x. 24

25 bvec notequal(bvec x, bvec y) GLSL bool any(bvec x) Returns true if any component of x is true. bool all(bvec x) Returns true if all components of x are true. bvec not(bvec x) Returns component wise complement of x. Funções built-in Common Functions Finally we present the list of general purpose functions. All of these functions work on and return both scalar and vector data types (see Table 6.9). Funções TABLE gerais 6.9 Common Functions Function Description anyfloat abs(anyfloat x) Returns the absolute value of x. anyint abs(anyint x) 6 p anyfloat sign(anyfloat x) Returns 1.0 or -1.0 depending on the sign of x. anyint sign(anyint x) anyfloat floor(anyfloat x) Returns the lowest whole number not larger than x. anyfloat trunc(anyfloat x) Returns the nearest whole number not larger than the absolute value of x. anyfloat round(anyfloat x) Returns the value of the nearest integer to x. The fraction 0.5 may round in either direction. (This is implementation-dependent.) anyfloat roundeven(anyfloat x) Returns the value of the nearest integer to x. The fraction 0.5 rounds to the nearest even integer. anyfloat ceil(anyfloat x) Returns the value of the nearest integer greater than x. anyfloat fract(anyfloat x) Returns the fractional part of x. Download from 25

26 260 CHAPTER 6 Funções built-in Funções gerais Thinking Outside the Box: Nonstock Shaders TABLE 6.9 Common Functions continued Function Description anyfloat mod(anyfloat x, float y) Returns the modulus of x mod y. anyfloat mod(anyfloat x, anyfloat y) anyfloat modf(anyfloat x, out anyfloat i) Returns the fractional part of x and sets i to be the integer remainder. anyfloat min(anyfloat x, anyfloat y) Returns the smaller of x and y. anyfloat min(anyfloat x, float y) anyint min(anyint x, anyint y) anyint min(anyint x, int y) anyuint min(anyuint x, anyuint y) anyuint min(anyuint x, uint y) anyfloat max(anyfloat x, anyfloat y) Returns the larger of x and y. anyfloat max(anyfloat x, float y) anyint max(anyint x, anyint y) anyint max(anyint x, int y) anyuint max(anyuint x, anyuint y) anyuint max(anyuint x, uint y) anyfloat clamp(anyfloat x, anyfloat minval, anyfloat maxval) anyfloat clamp(anyfloat x, float minval, Returns x clamped to the range minval to maxval. 26

27 anyint min(anyint x, anyint y) anyint min(anyint x, int y) anyuint min(anyuint x, anyuint y) anyuint min(anyuint x, uint y) anyfloat max(anyfloat x, anyfloat y) Returns the larger of x and y. anyfloat max(anyfloat x, float y) Funções built-in anyint max(anyint x, anyint y) anyint max(anyint x, int y) Funções gerais anyuint max(anyuint x, anyuint y) anyuint max(anyuint x, uint y) anyfloat clamp(anyfloat x, anyfloat minval, anyfloat maxval) anyfloat clamp(anyfloat x, float minval, float maxval); anyint clamp(anyint x, anyint minval, anyint maxval) anyint clamp(anyint x, int minval, int maxval) anyuint clamp(anyuint x, anyuint minval, anyuint maxval); anyuint clamp(anyuint x, uint minval, uint maxval) Returns x clamped to the range minval to maxval. 27

28 Funções built-in Built-In Functions 261 Funções gerais Function Description anyfloat mix(anyfloat x, Returns the linear blend of x and y, as a varies from 0 to 1 anyfloat y, anyfloat a) anyfloat mix(anyfloat x, anyfloat y, float a) anyfloat mix(anyfloat x, anyfloat y, anybool a) Returns the components of x where a is false and the components of y where a is true. anyfloat step(anyfloat edge, anyfloat x) anyfloat step(float edge, anyfloat x) Returns 0.0 if x is less than edge, or 1.0 otherwise. anyfloat smoothstep(anyfloat edge0, anyfloat edge1, anyfloat x) anyfloat smoothstep(float edge0, float edge1, anyfloat x) Returns 0.0 if x <= edge0, and 1.0 if x >= edge1, and a smooth Hermite interpolation between 0.0 and 1.0 in between. ptg anybool isnan(anyfloat x) anybool isinf(anyfloat x) Returns true if x is Nan. Returns true if x is positive or negative infinity. 6 anyint floatbitstoint(anyfloat x) anyuint floatbitstouint(anyfloat x) Converts floating-point values to integer values. anyfloat intbitstofloat(anyint x) anyfloat uintbitstofloat(anyuint x) Converts integers to floating-point values. 28

29 Exemplo: iluminação difusa por vértice Simulatin // diffuse ilumination in vec4 vvertex; in vec3 vnormal; uniform vec4 diffusecolor; uniform vec3 vlightposition; uniform mat4 mvpmatrix; uniform mat4 mvmatrix; uniform mat3 normalmatrix; smooth out vec4 vvaryingcolor; void main(void) { vec3 veyenormal = normalmatrix vnormal; vec4 vposition4 = mvmatrix vvertex; FIGURE 6.6 vec3 vposition3 = vposition4.xyz / vposition4.w; } The ADS Light Model vec3 vlightdir = normalize(vlightposition Position3); float diff = max(0.0, dot(veyenormal, vlightdir)); vvaryingcolor.xyz = diff diffusecolor.xyz; vvaryingcolor.a = 1.0; gl Position = mvpmatrix vvertex; The DiffuseLight example program. One of the most common lighting models, especially to those familiar with the now deprecated fixed function pipeline, is the ADS lighting model. ADS stands for Ambie Diffuse, and Specular. It works on a simple principle, which is that objects have three material properties, which are the Ambient, Diffuse, and Specular reflectivity. These p erties are assigned color values, with brighter colors representing a higher amount of reflectivity. Light sources have these same three properties and are again assigned col values that represent the brightness of the light. The final color value of a vertex is t the sum of the lighting and material interactions of these three properties. Ambient Light Ambient light doesn t come from any particular direction. It has an original source s where, but the rays of light have bounced around the room or scene and 29 become dir

30 For a given triangle, there are only three vertices and many more fragments that fill o the triangle. This makes vertex lighting and Gouraud shading very efficient, as all the computations are done only once per vertex. Figure 6.7 shows the output of the ADSGouraud example program. Exemplo: iluminação ADS por vértice in vec4 vvertex; in vec3 vnormal; uniform vec4 ambientcolor; uniform vec4 diffusecolor; uniform vec4 specularcolor; uniform vec3 vlightposition; uniform mat4 mvpmatrix; uniform mat4 mvmatrix; uniform mat3 normalmatrix; smooth out vec4 vvaryingcolor; void main (void) { FIGURE 6.7 vec3 veyenormal = normalmatrix vnormal; vec4 vposition4 = mvmatrix vvertex; vec3 vposition3 = vposition4.xyz Phong Shading / vposition4.w; } vec3 vlightdir = normalize(vlightposition vposition3); float diff = max(0.0, dot(veyenormal, vlightdir)); vvaryingcolor = diff diffusecolor; vvaryingcolor += ambientcolor; vec3 vreflection = normalize(reflect( vlightdir, veyenormal)); float spec = max(0.0, dot(veyenormal, vreflection)); if(diff!= 0) { float fspec = pow(spec, program (Figures 128.0); 6.7 and 6.8 are shown side-by-side in Color Plate 5). vvaryingcolor.rgb += vec3(fspec, fspec, fspec); } gl Position = mvpmatrix vvertex; Per-vertex-based lighting (Gouraud shading). One of the drawbacks to Gouraud shading is clearly apparent in Figure 6.7. Note the s burst pattern of the specular highlight. On a still image, this might almost pass as an intentional artistic effect. The running sample program, however, rotates the sphere a shows a characteristic flashing that is a bit distracting and generally undesirable. This caused by the discontinuity between triangles because the color values are being inter lated linearly through color space. The bright lines are actually the seams between ind ual triangles. One way to reduce this effect is to use more and more vertices in your geometry. Another, and higher quality, method is called Phong shading. With Phong shading, instead of interpolating the color values between vertices, we interpolate the surface normals between vertices. Figure 6.8 shows the output from the ADSPhong sa Download from w 30

31 Exemplo: iluminação ADS por pixel (Phong shading) Vertex shader in vec4 vvertex; in vec3 vnormal; uniform mat4 mvpmatrix; uniform mat4 mvmatrix; uniform mat3 normalmatrix; uniform vec3 vlightposition; smooth out vec3 vvaryingnormal; smooth out vec3 vvaryinglightdir; void main (void) { vvaryingnormal = normalmatrix vnormal; vec4 vposition4 = mvmatrix vvertex; vec3 vposition3 = vposition4.xyz / vposition4.w; vvaryinglightdir = normalize(vlightposition vposition3); gl Position = mvpmatrix vvertex; } 31

32 Exemplo: iluminação ADS por pixel (Phong shading) Fragment shader 274 CHAPTER 6 Thinking Outside the Box: Nonstock Shaders uniform vec4 ambientcolor; uniform vec4 diffusecolor; uniform vec4 specularcolor; in vec3 vvaryingnormal; in vec3 vvaryinglightdir; void main (void) { float diff = max(0.0, dot(normalize(vvaryingnormal), normalize(vvaryinglightdir))); gl FragColor = diff diffusecolor; gl FragColor += ambientcolor; vec3 vreflection = normalize(reflect( normalize(vvaryinglightdir), } normalize(vvaryingnormal))); program. float spec = max(0.0, dot(normalize(vvaryingnormal), Reflection)); LISTING 6.10 ADSPhong Vertex Shader if(diff!= 0) { // ADS Point lighting Shader float fspec = pow(spec, 128.0); // Vertex Shader gl FragColor.rgb += vec3(fspec, fspec, fspec); } FIGURE 6.8 Per-pixel-based lighting (Phong shading). The trade-off is of course we are now doing significantly more work in the fragment program, which is going to be executed significantly more times than the vertex program The basic code is the same as for the ADSGouraud example program, but this time there i some significant rearranging of the shader code. Listing 6.10 shows the new vertex // Richard S. Wright Jr. // OpenGL SuperBible #version 330 // Incoming per vertex... position and normal in vec4 vvertex; in vec3 vnormal; uniform mat4 mvpmatrix; 32

33 API Programs & shaders API para shader object uint glcreateshader (enum type); // type: {VERTEX,FRAGMENT,GEOMETRY} SHADER, TESS {EVALUATION,CONTROL} SHADER void glshadersource (uint shader, sizei count, const char string, const int length); void glcompileshader (uint shader); void gldeleteshader (uint shader); API para program object uint glcreateprogram (void); void glattachshader (uint program, uint shader); void gldetachshader (uint program, uint shader); void gllinkprogram(uint program); void gluseprogram(uint program); void gldeleteprogram(uint program); 33

34 API API para atributos de vértices // Before linking void glbindattriblocation (uint program, uint index, const char name); // After linking void glgetactiveattrib (uint program, uint index, sizei bufsize, sizei length, int size, enum type, char name); // type returns: FLOAT,FLOAT{VECn,MATn,MATnxm}, INT,INT VECn,UNSIGNED {INT,INT VECn} int glgetattriblocation (uint program, const char name); API para carga de variáveis uniformes // After linking the program int glgetuniformlocation (uint program, const char name); // load uniform variables in default uniform block on bound program void gluniform{1234}{ifd} (int location, T value); void gluniform{1234}{ifd}v (int location, sizei count, T value); void gluniform{1234}ui (int location, T value); void gluniform{1234}uiv (int location, sizei count, T value); void gluniformmatrix{234}{fd}v (int location, sizei count, boolean transpose, const T value); void gluniformmatrix{2x3,3x2,2x4,4x2, 3x4,4x3}{fd}v (int location, sizei count, boolean transpose, const T value); 34

35 Exercício Executável que renderiza um grid com os shaders (vertex & fragment) dados via comando de linha usage: trab filename.vs filename.fs Recomendação para desenvolvimento classe VGeometry Abstração para representar geometria de objetos classe VShader Abstração para encapsular API de definição de shaders 35

36 Referências OpenGL Super Bible, 5th edition Richard S. Wright, Jr. Nicholas Haemel, Graham Sellers, Benjamin Lipchak The OpenGL Graphics System: A Specification (Version 4.1 (Core Profile) - July 25, 2010) Mark Segal, Kurt Akeley 36