Programmable shader. Hanyang University

Transcription

1 Programmable shader Hanyang University

2 Objective API references (will be skipped) Examples Simple shader Phong shading shader

3 INTRODUCTION

4 GLSL(OPENGL SHADING LANGUAGE)

5 Scalar Data types Structure Structures are similar to that of C language. Vectors and matrices Matrices are column-major ordered. Array A 1-D array is only supported. Dynamic allocation of memory is not available. The length() method can be used to return the length of an array.

6 Qualifiers Type qualifiers Usage

7 Operators

8 Constructors Constructors are special functions primarily used to initialize variables, especially of multicomponent data types, including structures and arrays. They can also be used as expressions. A single scalar value is assigned to all elements of a vector. You can mix and match scalars, vectors, and matrices in your constructor, as long as you end up with enough components to initialize the entire data type. Any extra components are dropped. Matrices are constructed in column-major order. If you provide a single scalar value, that value is used for the diagonal matrix elements, and all other elements are set to 0. Type conversions are performed only using constructors.

9 Another way to get at individual vector components or matrix components is to use array subscript notation. vec v4 = (1.0, 2.0, 3.0, 4.0); v4[2], v4.b, v4.z, v4.p All of them are the ways to access the third component of v4. For matrices, providing a single array index accesses the corresponding matrix column as a vector. Providing a second array index accesses the corresponding vector component. Component selectors(swizzling) Individual components of a vector can be accessed by using dot notation along with {x,y,z,w}, {r,g,b,a}, or {s,t,p,q}. You cannot mix and match selectors from the different notations. You can use the component selectors to rearrange the order of components or replicate them. You can also use them as write masks on the left side of an assignment to select which components are modified.

10 Flow control Loops for, while, and do/while loops are all supported with the same syntax as in C/C++, and they can be nested. if/else You can use if and if/else clauses to select between multiple blocks of code. These conditionals can also be nested.

11 Function All shaders must define a main function, which is the place where execution begins. void main() { } Subroutines Arrays are allowed as arguments, but not as return types. Structures are allowed as arguments and return types. There are 4 optional qualifiers for arguments. Recursive functions are not allowed.

12 VERTEX SHADER

13 Vertex shader Inputs Matrices for geometric transformations and A set of vertex attributes including vertex coordinates, normal vector, vertex color, material properties, texture coordinates, and so on. Processing Vertex transformation the vertex position is transformed from object space to clip space. Lighting Texture Coordinate Generation and Transformation Outputs Clip-space position, front-facing and back-facing primary and secondary colors, texture coordinates, User-defined varying variables.

14 Application Moving vertices Morphing Wave motion Fractals Particle systems Skinning Lighting More realistic lighting models Cartoon shaders

15 Built-in vertex shader variables Built-in attribute input variables Vertex attributes are fed by calling functions such as glvertex*(), glnormal*(), glcolor*(), gltexcoord*(), and so on.

16 Built-in vertex shader variables Special output variables Varying output variables They will be interpolated and passed to fragment shader.

17 Simple vertex shader void main() { gl_position = gl_modelviewprojectionmatrix*gl_vertex; gl_frontcolor = gl_color; } Vertex coordinates which are specified by glvertex*() function are transformed to clip coordinates by the matrix gl_modelviewprojectionmatrix, which is produced by multiplying modelview matrix and projection matrix. The prefix gl_ indicates built-in variable.

18 FRAGMENT SHADER

19 Fragment shader Inputs Fragment Data whose values are produced by interpolating between outputs of vertex shader. front-facing and back-facing primary and secondary colors, texture coordinates, user-defined varying variables, Processing Texture lookup, color sum and blending, fog, Outputs Fragment color and depth

20 Application Per fragment lighting calculations Texture mapping environment mapping bump mapping Image processing

21 Built-in fragment shader variables Input variables Output Variables

22 Simple fragment shader void main() { gl_fragcolor = gl_frontcolor; } gl_frontcolor is produced by interpolating vertex colors which are the output of vertex shader. The prefix gl_ indicates built-in variable.

23 SETUP FOR USING GLSL SHADER

24 Examples: Gouraud shading vs Phong shading Gouraud shading Phong shading

25 Conventional OpenGL rendering pipeline Only support modified Phong illumination model for lighting calculation. Only support Gouraud shading for shading faces. Interpolate vertex shades across each polygon. It may be less efficient than programmable pipeline Programmable pipeline allows to avoid unnecessary operations and produce more compact program.

26 glew library OpenGL extensions are needed in order to use GLSL shader. GLEW(OpenGL Extension Wrangler) library allows to use extension functionalities of OpenGL. You can get at or from SDKs which provided by graphics hardware vendors (such as nvidia OpenGL SDK). Install glew.h, glew32.lib, and glew.dll files in the same manner as installing the glut library. At first, call glewinit() function which bind the function pointers declared in glew.h header file to the extension functions implemented in graphics driver.

27 Setup Steps Step 1: Create Shaders Create handles to shaders Step 2: Specify Shaders load strings that contain shader source Step 3: Compiling Shaders Actually compile source (check for errors) Step 4: Creating Program Objects Program object controls the shaders Step 5: Attach Shaders to Programs Attach shaders to program obj via handle Step 6: Link Shaders to Programs Another step similar to attach Step 7: Enable Program Finally, let GPU know shaders are ready

28 App Setup (SetupRC function) GLhandleARB vshader, fshader, prog; // handles to objects // Step 1: Create a vertex & fragment shader object vshader = glcreateshaderobjectarb(gl_vertex_shader_arb); fshader = glcreateshaderobjectarb(gl_fragment_shader_arb); // Step 2: Load source code strings into shaders glshadersourcearb(vshader, 1, &VS_String, NULL); glshadersourcearb(fshader, 1, &FS_String, NULL); // Step 3: Compile the vertex, fragment shaders. glcompileshaderarb(vshader); glcompileshaderarb(fshader); // Step 4: Create a program object prog = glcreateprogramobjectarb(); // Step 5: Attach the two compiled shaders glattachobjectarb(prog, vshader); glattachobjectarb(prog, fshader); // Step 6: Link the program object gllinkprogramarb(prog); // Step 7: Finally, install program object as part of current state gluseprogramobjectarb(prog);

29 Loading shader source codes GLhandleARB vshader, fshader, prog; // handles to objects // Step 1: Create a vertex & fragment shader object vshader = glcreateshaderobjectarb(gl_vertex_shader_arb); fshader = glcreateshaderobjectarb(gl_fragment_shader_arb); // Step 2: Load source code strings into shaders glshadersourcearb(vshader, 1, &VS_String, NULL); glshadersourcearb(fshader, 1, &FS_String, NULL); // Step 3: Compile the vertex, fragment shaders. glcompileshaderarb(vshader); glcompileshaderarb(fshader); // Step 4: Create a program object prog = glcreateprogramobjectarb(); // Step 5: Attach the two compiled shaders glattachobjectarb(prog, vshader); glattachobjectarb(prog, fshader); // Step 6: Link the program object gllinkprogramarb(prog); // Step 7: Finally, install program object as part of current state gluseprogramobjectarb(prog);

30 ... Error checking GLhandleARB vshader, fshader, prog; // handles to objects // Step 1: Create a vertex & fragment shader object vshader = glcreateshaderobjectarb(gl_vertex_shader_arb); fshader = glcreateshaderobjectarb(gl_fragment_shader_arb); // Step 2: Load source code strings into shaders glshadersourcearb(vshader, 1, &VS_String, NULL); glshadersourcearb(fshader, 1, &FS_String, NULL); // Step 3: Compile the vertex, fragment shaders. glcompileshaderarb(vshader); glcompileshaderarb(fshader); // Step 4: Create a program object prog... = glcreateprogramobjectarb();... // Step 5: Attach the two compiled shaders glattachobjectarb(prog, vshader); glattachobjectarb(prog, fshader); // Step 6: Link the program object gllinkprogramarb(prog); // Step 7: Finally, install program object as part of current state gluseprogramobjectarb(prog);

31 Vertex shader (phong_shading.vert)

32 Uniform Inputs

33 Attribute inputs

34 output Outputs

35 Fragment shader (phong_shading.frag)

36 Uniform inputs

37 Attribute inputs

38 void RenderScene(void) { glclear(gl_color_buffer_bit GL_DEPTH_BUFFER_BIT); glenable(gl_lighting); gllightmodelfv(gl_light_model_ambient,ambientlight); gllightfv(gl_light0,gl_ambient,ambientlight); gllightfv(gl_light0,gl_diffuse,diffuselight); glenable(gl_light0); glenable(gl_color_material);... glrotatef(xrotlight, 1.0f, 0.0f, 0.0f); glrotatef(yrotlight, 0.0f, 1.0f, 0.0f); gllightfv(gl_light0,gl_position,lightpos); glpopmatrix(); glcolormaterial(gl_front, GL_AMBIENT_AND_DIFFUSE); glmaterialfv(gl_front, GL_SPECULAR,materialSpecular); glmateriali(gl_front,gl_shininess,100); glcolor3f(0.0f, 1.0f, 0.0);

39 // Fixed-pipeline rendering on the left glviewport(0, 0, width/2, height); gluseprogramobjectarb(0); glutsolidteapot(100.0); // Programmable rendering on the right glviewport(width/2, 0, width/2, height); gluseprogramobjectarb(myshaderprogram); glutsolidteapot(100.0); glbegin(gl_triangl ES) glnormal3f(...) glcolor3f(...) glvertex3f(...)

40 Set custom attribute/uniform values (without the gl_ prefix) The symbolic table for attribute/uniform variables is generated when a program is linked. Query the linked program object for the attribute/uniform variable specified by name and get the index of the variable. GLint i =glgetattriblocation(p, myattrib ) GLint j =glgetuniformlocation(p, myuniform ) Specify the value of the attribute/uniform variable for the current program object using the index. glvertexattrib1f(i,value) gluniform1f(j,value) glvertexattribpointer(i, ) // passing attributes using vertex array