Engenharia Informática Computação Gráfica

Transcription

1 Computação Gráfica Engenharia Informática OpenGL Shading Language - GLSL Computação Gráfica 1

2 OpenGL Shading Language! The 'Red Book' is known to be the gold standard for OpenGL;! The 'Orange Book' is considered to be the gold standard for the OpenGL Shading Language (GLSL)! This language has been made part of the OpenGL standard as of OpenGL 2.0. OpenGL Shading Language OpenGL Shading Language (GLSL) Reference Pages OpenGL Shading Language! Known as GLSL! Part of core OpenGL 2.0 and higher! Uses a C-like language! Authoring of vertex and fragment shaders! Later added geometry shaders (OpenGL 3.0) and tessellation shaders (OpenGL 4.0) 2

3 Versions and Extensions in OpenGL! OpenGL is constantly evolving! New core version updates:! 2.0, 3.0, 4.5! OpenGL also supports extensions! Using new versions and extensions! Possible using GetProcAddress API to ask driver for entry-point for new commands! OpenGL Extension Wrangler Library (GLEW)! Regularly updated to support all available OpenGL extensions and versions! Linking with GLEW keeps you from dealing with GetProcAddress hassles! Details! Link with lglew! Call glewinit() right after creating an OpenGL context! Call OpenGL new version and extension routines Credits: Mark Kilgard (CS 354), University of Texas OpenGL! OpenGL tem já várias versões! OpenGL 1.0 (1992)!! OpenGL 2.0 (2004)! introdução do GLSL!! OpenGL 3.0 (2008)! Suporte para Geometry Shader!! OpenGL 4.3 (2012) Vertex shader and fragment shader! Suporte para Tesselation Shader e Compute Shader! Melhoramentos na transferência de dados entre shaders 3

4 GLSL - Shaders! The recent trend in graphics hardware has been to replace fixed functionality with programmability in areas that have grown exceedingly complex.! Two such areas are vertex processing and fragment processing.! OpenGL provides mechanisms for compiling shaders and linking them to form executable code called a PROGRAM. A program can run on the programmable processing units (GPU) Pipeline Gráfico GPU Créditos: A. Fernandes, Univ. Minho 4

5 GLSL! The OpenGL Shading Language is a high-level procedural language.! It is part of standard OpenGL (i.e., OpenGL 2.0), the leading crossplatform, operating environment-independent API for 3D graphics.! The same language, with a small set of differences, is used for both vertex and fragment shaders.! It is based on C and C++ syntax and flow control.! It natively supports vector and matrix operations since these are inherent to many graphics algorithms.! It is stricter with types than C and C++, and functions are called by value-return.! It uses type qualifiers rather than reads and writes to manage input and output.! It imposes no practical limits to a shader's length, nor does the shader length need to be queried. Shaders! With each new generation of graphics hardware, more complex rendering techniques can be implemented as OpenGL shaders and can be used in real-time rendering applications.! OpenGL Shaders are programs that run on the GPU.! The fact that these techniques can now be implemented with hardware acceleration means that rendering performance can be increased dramatically and at the same time the CPU can be off-loaded so that it can perform other tasks. 5

6 Shaders! Here's a brief list of what s possible with OpenGL shaders:! Increasingly realistic materials metals, stone, wood, paints, and so on! Increasingly realistic lighting effects area lights, soft shadows, and so on! Natural phenomena fire, smoke, water, clouds, and so on! Advanced rendering effects global illumination, ray-tracing, and so on! Non-photorealistic materials painterly effects, pen-and-ink drawings, simulation of illustration techniques, and so on! New uses for texture memory storage of normals, gloss values, polynomial coefficients, and so on! Procedural textures dynamically generated 2D and 3D textures, not static texture images! Image processing convolution, unsharp masking, complex blending, and so on! Animation effects key frame interpolation, particle systems, procedurally defined motion! User programmable antialiasing methods! General computation sorting, mathematical modeling, fluid dynamics, and so on Vertex processor! The VERTEX PROCESSOR is a programmable unit that operates on incoming vertex values and their associated data.! The vertex processor usually performs traditional graphics operations such as the following:! Vertex transformation! Normal transformation and normalization! Texture coordinate generation! Texture coordinate transformation! Lighting! Color material application 6

7 Fragment processor! The FRAGMENT PROCESSOR is a programmable unit that operates on fragment values and their associated data.! The fragment processor usually performs traditional graphics operations such as the following:! Operations on interpolated values! Texture access! Texture application! Fog! Color sum GLSL - Language Overview! GLSL is based on the syntax of the ANSI C programming language. Programs written in this language look very much like C programs (to make the language easier to use).! The basic structure of programs written in the GLSL is the same as it is for programs written in C. The entry point of a set of shaders is the function void main();.! Constants, identifiers, operators, expressions, and statements are basically the same for the GLSL as they are for C.! Control flow for looping, if-then-else, and function calls are virtually identical to C. 7

8 GLSL - Language Overview! Addiction to C! Vector types are supported for floating-point, integer, and Boolean values.! For floating-point values, these vector types are referred to as vec2 (two floats), vec3 (three floats), and vec4 (four floats)! Floating-point matrix types are also supported as basic types.! The data type mat2 refers to a 2x2 matrix of floating-point values, mat3 refers to a 3x3 matrix, and mat4 refers to a 4x4matrix.! Columns of a matrix can be selected with array syntax.! Non-square matrices.! Samplers are a special type of opaque variable that access a particular texture map.! A variable of type sampler1d can be used to access a 1D texture map, a variable of type sampler2d can be used to access a 2D texture map, and so on. GLSL - Language Overview! Addiction to C! Qualifiers have been added to manage the input and output of shaders. The attribute, uniform, and varying qualifiers specify what type of input or output a variable serves.! Attribute variables communicate frequently changing values from the application to a vertex shader;! uniform variables communicate infrequently changing values from the application to any shader;! varying variables communicate interpolated values from a vertex shader to a fragment shader. 8

9 GLSL - Language Overview! Shaders written in the GLSL can use built-in variables that begin with the reserved prefix "gl_" in order to access existing OpenGL state and to communicate with the fixed functionality of OpenGL.! The vertex shader must write the special variable gl_position in order to provide necessary information to the fixed functionality stages between vertex processing and fragment processing.! A fragment shader typically writes into one or both of the special variables gl_fragcolor or gl_fragdepth. GLSL - Language Overview! A variety of built-in functions is also provided in the OpenGL Shading Language. The language defines built-in functions for a variety of operations:! Trigonometric operations sine, cosine, tangent, and so on! Exponential operations power, exponential, logarithm, square root, and inverse square root! Common math operations absolute value, floor, ceiling, fractional part, modulus, and so on! Geometric operations length, distance, dot product, cross product, normalization, and so on! Relational operations based on vectors component-wise operations such as greater than, less than, equal to, and so on! Specialized fragment shader functions for computing derivatives and estimating filter widths for antialiasing! Functions for accessing values in texture memory! Functions that return noise values for procedural texturing effects 9

10 GLSL - Language Overview! Addiction from C++! it supports function overloading to make it easy to define functions that differ only in the type or number of arguments being passed.! For instance, the dot product function is overloaded to deal with arguments that are types float, vec2, vec3, and vec4.! The concept of constructors also comes from C++. Initializers are done only with constructors in the GLSL.! Variables can be declared when they are needed;! The basic type bool is supported as in C++.! Functions must be declared before being used. GLSL - Language Overview! C Features not supported (not suited for GPUs)! Unlike ANSI C, the GLSL does not support automatic promotion of data types. Compiler errors are generated if variables used in an expression are of different types.! For instance, an error is generated for the statement float f = 0; but not for the statement float f = 0.0;! GLSL does not support pointers, strings, or characters.! It not support also unions, enumerated types, bit fields in structures, and bitwise operators.! It is not file based, so you won't see any #include directives or other references to file names.! goto, standard C library stuff like printf and malloc 10

11 GLSL - Language Overview! Some concepts:! The vertex shader is executed once for every vertex provided to OpenGL.! The fragment shader is executed once for every fragment (i.e., every pixel) that is produced by rasterization.! When vertex or fragment shaders are used, the corresponding fixed functionality is disabled. Shaders must implement such functionality themselves if it is desired.! Varying variables defined in a vertex shader are per-vertex values that are output from the vertex processor.! An application can communicate directly with a vertex shader in two ways:! by using attribute variables and! by using uniform variables GLSL - Language Overview! Some concepts:! Attribute variables are expected to change frequently and may be supplied by the application as often as every vertex.! Applications can pass arbitrary vertex data to a vertex shader with user-defined attribute variables. Applications can pass standard vertex attributes (color, normal, texture coordinates, position, etc.) to a vertex shader with built-in attribute variables.! An application communicates directly with a fragment shader with uniform variables.! Uniform variables are expected to change relatively infrequently (at a minimum, they are constant for an entire graphics primitive). 11

12 GLSL - Language Overview! SUMMARY! The language is based on the syntax of C; Basic structure and many keywords are the same as in C.! Vectors and matrices are included in the language as basic types.! Type qualifiers attribute, uniform, and varying are added to describe variables that manage shader I/O.! Variables of type attribute allow the communication of frequently changing values from the application to the vertex shader.! Variables of type varying are the output from a vertex shader and the input to a fragment shader.! Variables of type uniform allow the application to provide relatively infrequently changing values to both vertex shaders and fragment shaders.! The data type sampler is added for accessing textures. GLSL - Language Overview! To install and use OpenGL shaders 1. Create one or more shader objects by calling glcreateshader. 2. Provide source code for these shaders by calling glshadersource. 3. Compile each of the shaders by calling glcompileshader. 4. Create a program object by calling glcreateprogram. 5. Attach all the shader objects to the program object by calling glattachshader. 6. Link the program object by calling gllinkprogram. 7. Install the executable program as part of OpenGL's current state by calling gluseprogram. 12

13 GLSL - Implementation! GLSL is built into OpenGL drivers! The graphics driver contains an optimizing compiler for a highlevel language! Targeting a complex, dedicate processor! What could possibly go wrong?! Test your shaders on hardware from different vendors!! GLSL shaders compiled to hardware-dependent! All details are hidden from the OpenGL application programmer! Provides very little visibility into compiled result! NVIDIA s Cg Toolkit contains compiler (cgc) for Cg and GLSL code GLSL Data Types! Scalars! float a single single-precision floating-point scalar! int declares a single integer number! uint an unsigned integer! bool declares a single Boolean number! double a single double-precision floating point scalar! These declare variables, as is familiar from C/C++.! float f;! float g, h = 2.4;! int NumTextures = 4;! bool skipprocessing; 13

14 GLSL Data Types! Vectors! Vector data types built into language! Supports swizzling, masking, and operators! Swizzling/mask example: foo.zyx = foo.xxy! Operators like +, -, *, and / do component-wise operations! Also supports vector-with-scalar operations! Type names! Floating-point vectors: vec2, vec3, vec4! Integer vectors: ivec2, ivec3, ivec4! Boolean vectors: bvec2, bvec3, bvec4! Double-precision vectors: dvec2, dvec3, dvec4! Standard library support! dot, length, normalize, reflect, etc.! sin, cos, etc. GLSL Data Types! Vectors details! Special features of vectors include component access that can be done either through field selection (as with structures) or as array accesses.! vec3 position = position (1.0, 2.0, 3.0)! it can be considered as the vector (x, y, z);! position.x will select the first component of the vector.! Aggregate initializiers aren t allowed vec3 position = { 1.0, 2.0, 3.0 } 14

15 GLSL Data Types! Vectors (or Arrays)! Arrays of any type can be created.! For example, vec4 points[]; // points is an array of unknown size vec4 points[10]; // points is now an array of size vec4 points[]; // points is an array of unknown size points[2] = vec4(1.0); // points is now an array of size 2 points[7] = vec4(2.0); // points is now an array of size 7 GLSL Data Types! Vectors details! The following names are available for selecting components of vectors:! x, y, z, w Treat a vector as a position or direction! r, g, b, a Treat a vector as a color! s, t, p, q Treat a vector as a texture coordinate! vec3 position = position (1.0, 2.0, 3.0) position.z! vec3 color= color(1.0, 0.0, 0.0) color.r! vec4 texture= texture(1.0, 0.0, 0.0, 1.0) texture.t 15

16 GLSL Data Types! Vectors details vec4 v4; v4.rgba; // is a vec4 -> v4, v4.rgb; // is a vec3, v4.b; // is a float, v4.xy; // is a vec2, v4.xgba; // is illegal vec4 pos = vec4(1.0, 2.0, 3.0, 4.0); vec4 swiz = pos.wzyx; // swiz = (4.0, 3.0, 2.0, 1.0) vec4 dup = pos.xxyy; // dup = (1.0, 1.0, 2.0, 2.0) pos.xw = vec2(5.0, 6.0); // pos = (5.0, 2.0, 3.0, 6.0) pos.wx = vec2(7.0, 8.0); // pos = (8.0, 2.0, 3.0, 7.0) vec3 v, u; float f; v = u + f; v.x = u.x + f; v.y = u.y + f; v.z = u.z + f; is equivalent to vec3 v, u, w; w = v + u; is equivalent to w.x = v.x + u.x; w.y = v.y + u.y; w.z = v.z + u.z; GLSL Data Types! Vectors details! To compare two vectors! The functions: equal, notequal, lessthan,! a vector can be turned into a scalar Boolean with:! The functions: any or all.! Example: vec4 u, v;!...! if (any(lessthan(u, v)))!...! 16

17 GLSL Data Types! Matrices! Built-in types are available for matrices of floating-point numbers.! There are 2x2, 3x3, and 4x4 sizes. Non-square matrices: mat4x2, etc.! Operator * does matrix-by-vector and matrix-by-matrix multiplication! You may access a matrix as an array of column vectors! If transform is a mat4, transform[2] is the third column of transform.! The resulting type of transform[2] is vec4.! Column 0 is the first column.! transform[3][1] is the second component of the vector forming the fourth column of transform.! Just remember that the first index selects the column, not the row, and the second index selects the row. mat4 m = mat4(3.0); // initializes the diagonal to all 3.0! vec4 v;! v = m[1]; // places the vector (0.0, 3.0, 0.0, 0.0) into v! GLSL Data Types! Samplers! GLSL provides a simple opaque handle to encapsulate lookup of textures. These handles are called SAMPLERS.! The sampler types available are:! sampler1d Accesses a one-dimensional texture! sampler2d Accesses a two-dimensional texture! sampler3d Accesses a three-dimensional texture! samplercube Accesses a cube-map texture! sampler1dshadow Accesses a one-dimensional depth texture with comparison! sampler2dshadow Accesses a two-dimensional depth texture with comparison 17

18 GLSL Data Types! Samplers! For example, a sampler could be declared as uniform sampler2d Grass;! This variable can then be passed into a corresponding texture lookup function to access a texture: vec4 color = texture2d(grass, coord); where coord is a vec2 holding the two-dimensional position used to index the grass texture, and color is the result of doing the texture lookup. GLSL Data Types! Structures! GLSL provides user-defined structures similar to C.! For example, struct light { vec3 position; vec3 color; }; light ceilinglight; 18

19 GLSL Data Types! Initializers and Constructors! A shader variable may be initialized when it is declared. For example: float a, b = 3.0, c;! Constant qualified variables must be initialized. const int Size = 4; // initializer is required! Attribute, uniform, and varying variables cannot be initialized when declared. attribute float Temperature; // no initializer allowed, // the vertex API sets this uniform int Size; // no initializer allowed, // the uniform setting API sets this varying float density; // no initializer allowed, the vertex // shader must programmatically set this GLSL Data Types! Initializers and Constructors! There are constructors for all the built-in types (except samplers) as well as for structures. Some examples: vec4 v = vec4(1.0, 2.0, 3.0, 4.0); ivec2 c = ivec2(3, 4); vec3 color = vec3(0.2, 0.5, 0.8); vec4 color4 = vec4(color, 1.0) struct light { vec4 position; struct tlightcolor { vec3 color; float intensity; } lightcolor; } light1 = light(v, tlightcolor(color, 0.9)); 19

20 GLSL Data Types! Initializers and Constructors! For matrices, the components are written in column major order. For example, mat2 m = mat2(1.0, 2.0, 3.0, 4.0); vec3 v = vec3(0.6); is equivalent to vec3 v = vec3(0.6, 0.6, 0.6); //makes a 2x2 identity matrix mat2 m = mat2(1.0); is equivalent to // makes a 2 x 2 identity matrix mat2 m = mat2(1.0, 0.0, 0.0, 1.0); vec4 v = vec4(1.0); vec2 u = vec2(v); //the first two components of v initialize u GLSL Data Types! Qualifiers and Interface to a Shader! The following is the list of qualifiers:! attribute - For frequently changing information, from the application to a vertex shader;! uniform - For infrequently changing information, from the application to either a vertex shader or a fragment shader;! varying - For interpolated information passed from a vertex shader to a fragment shader;! const - For declaring nonwritable, compile-time constant variables, as in C; If no qualifier is specified when a variable (not a function parameter) is declared, the variable can be both read and written by the shader. 20

21 GLSL Data Types! Flow Control! Looping can be done with for, while, and do-while, just as in C++.! Variables can be declared in for and while statements, and their scope lasts until the end of their substatements.! The keywords break and continue also exist and behave as in C.! Selection can be done with if and if-else, just as in C++, with the exception that a variable cannot be declared in the if statement.! Selection by means of the selection operator (?:) is also available, with the extra constraint that the second and third operands must have exactly the same type.! As in C, the right-hand operand to logical and (&&) is not evaluated if the left-hand operand evaluates to false, and the right-hand operand to logical or ( ) is not evaluated if the left-hand operand evaluates to true. GLSL Data Types! Functions - Calling Conventions! To specify which parameters are copied when, prefix them with the qualifier keywords in, out, or inout.! For something that is just copied into the function but not returned, use in.! The in qualifier is also implied when no qualifiers are specified.! To say a parameter is not to be copied in but is to be set and copied back on return, use the qualifier out.! To say a parameter is copied both in and out, use the qualifier inout.! in Copy in but don't copy back out; still writable within the function! out Only copy out; readable, but undefined at entry to function! inout Copy in and copy out! The const qualifier can also be applied to function parameter (i.e. only for in). 21

22 GLSL Data Types! Qualifiers! Shaders are excepted to process inputs and write outputs! Type qualifiers identify these special variables! Vertex input qualifier: attribute! Vertex-fragment interface qualifier: varying! Shader parameters initialized by driver: uniform! out for vertex shader varying;! in for fragment shader varying One problem with GLSL is deprecation! GLSL - Other Details! C preprocessor functionality available! Has its own extension and version mechanism! Entry function must be named main()! See GLSL manual for more details. 22

23 GLSL Summary! Applications can provide data to shaders with userdefined attribute variables and user-defined uniform variables.! Standard OpenGL attributes can be accessed from within a vertex shader by means of built-in attribute variable names;! A variety of OpenGL state is accessible from either vertex shaders or fragment shaders by: uniform variables;! Vertex shaders communicate results: output variables and built-in varying variables;! Fragment shaders obtain the results from: fragment shader input variables and built-in varying variables;! Fragment shaders communicate results: output variables;! Built-in constants are accessible from within both types of shaders. Vertex Shader Inputs & Outputs Credits: Mark Kilgard (CS 354), University of Texas 23

24 Fragment Shader Ins & Outs Credits: Mark Kilgard (CS 354), University of Texas API Process for Creating GLSL Programs! Create & compile vertex & fragment shader! Attach shaders & link program Vertex Shader Program glcreateprogram glattachshader glattachshader gllinkprogram gluseprogram Credits: Mark Kilgard (CS 354), University of Texas glcreateshader glshadersource glcompileshader Fragment Shader glcreateshader glshadersource glcompileshader 24

25 Consider a Light Map Shader x = Precomputed light Surface color lit surface! Multiple two textures component-wise Credits: Mark Kilgard (CS 354), University of Texas Images from: Light Map with Fixed Function OpenGL API GLuint lightmap; GLuint surfacemap; glactivetexture(gl_texture0); glenable(gl_texture_2d); glbindtexture(gl_texture_2d, lightmap); gltexenvi(gl_texture_env, GL_TEXTURE_ENV_MODE, GL_MODULATE); glactivetexture(gl_texture1); glenable(gl_texture_2d); glbindtexture(gl_texture_2d, surfacemap); gltexenvf(gl_texture_env, GL_TEXTURE_ENV_MODE, GL_MODULATE); gldrawarrays(...); Credits: Mark Kilgard (CS 354), University of Texas 25

26 Light Map with Fixed Function OpenGL API GLuint lightmap; GLuint surfacemap; glactivetexture(gl_texture0); glenable(gl_texture_2d); Tell fixed function we are using texture mapping glbindtexture(gl_texture_2d, lightmap); gltexenvi(gl_texture_env, GL_TEXTURE_ENV_MODE, GL_MODULATE); glactivetexture(gl_texture1); glenable(gl_texture_2d); glbindtexture(gl_texture_2d, surfacemap); gltexenvf(gl_texture_env, GL_TEXTURE_ENV_MODE, GL_MODULATE); gldrawarrays(...); Tell fixed function how to combine textures Credits: Mark Kilgard (CS 354), University of Texas Light Map Shader Example in GLSL! Write a fragment shader in GLSL #version 330 uniform sampler2d lightmap; uniform sampler2d surfacemap; in vec2 fs_txcoord; out vec3 out_color; void main(void) { } float intensity = texture2d(lightmap, fs_txcoord).r; vec3 color = texture2d(surfacemap, fs_txcoord).rgb; out_color = intensity * color; Credits: Mark Kilgard (CS 354), University of Texas 26

27 Light Map Shader Example in GLSL! Write a fragment shader in GLSL #version 330 uniform sampler2d lightmap; uniform sampler2d surfacemap; GLSL version 3.3 Textures (input) in vec2 fs_txcoord; out vec3 out_color; void main(void) { } Per-fragment input shader output one channel intensity float intensity = texture2d(lightmap, fs_txcoord).r; vec3 color = texture2d(surfacemap, fs_txcoord).rgb; out_color = intensity * color; three channel color modulate Credits: Mark Kilgard (CS 354), University of Texas Switching the Application to use GLSL Shaders! Recall the fixed function light map in C/C++! What code can be eliminated? GLuint lightmap; GLuint surfacemap; glactivetexture(gl_texture0); glenable(gl_texture_2d); glbindtexture(gl_texture_2d, lightmap); gltexenvi(gl_texture_env, GL_TEXTURE_ENV_MODE, GL_MODULATE); glactivetexture(gl_texture1); glenable(gl_texture_2d); glbindtexture(gl_texture_2d, surfacemap); gltexenvf(gl_texture_env, GL_TEXTURE_ENV_MODE, GL_MODULATE); Credits: Mark Kilgard (CS 354), University of Texas 27

28 Switching the Application to use GLSL Shaders " Added code to use GLSL shaders GLuint lightmap; GLuint surfacemap; GLuint program; glactivetexture(gl_texture0); glbindtexture(gl_texture_2d, lightmap); glactivetexture(gl_texture1); glbindtexture(gl_texture_2d, surfacemap); gluseprogram(program); gldrawarray(...); Credits: Mark Kilgard (CS 354), University of Texas Careful: What s not shown! This example cuts a number of corners! The example leaves out code for! Initializing and loading the image data for the two textures! The vertex shader that outputs the varying fs_txcoord texture coordinate set! GLSL shader compilation and linking code to create the program object! Setting the sampler units of lightmap and surfacemap to point at texture units 1 and 2! Use gluniform1i for this Credits: Mark Kilgard (CS 354), University of Texas 28