Lecture 5 Vertex and Fragment Shaders-1. CITS3003 Graphics & Animation

Transcription

1 Lecture 5 Vertex and Fragment Shaders-1 CITS3003 Graphics & Animation E. Angel and D. Shreiner: Interactive Computer Graphics 6E Addison-Wesley 2012

2 Objectives The rendering pipeline and the shaders Data types, qualifiers, built-in variables, and functions in shaders Applications that can be done on Vertex shader Fragment shader Vertex and fragment shaders examples How the application program and vertex shader work together 2

3 GLSL A Quick Review OpenGL Shading Language Part of OpenGL 2.0 and up High level C-like language New data types are provided, e.g. o Matrices o Vectors As of OpenGL 3.1, application programs must provide shaders (as no default shaders are available) 3

4 The Rendering Pipeline and the shaders Where the vertex and fragment shaders are on the rendering pipeline: application program display (Vertex shader) (Fragment shader) The goal of the vertex shader is to provide the final transformation of mesh vertices to the rendering pipeline. The goal of the fragment shader is to provide the colour to each pixel in the frame buffer. 4

5 Data Types in Shaders C types: int, float, bool Vectors: Each element is a float vec2, vec3, vec4; Also int (ivec) and boolean (bvec) Matrices: mat2, mat3, mat4 Stored by columns Standard referencing m[row][column] C++ style constructors vec2 a = vec2(3.0, 2.0); vec3 b = vec3(a, 1.0); 5

6 Pointers There are no pointers in GLSL We can use C structs which can be copied back from functions Because matrices and vectors are basic types, they can be passed into and output from GLSL functions, e.g. mat3 func(mat3 a); 6

7 GLSL Qualifiers GLSL has many of the same qualifiers such as const as C/C++ In GLSL, we need other qualifiers due to the nature of the rendering pipeline Qualifiers that can be used in shader programs (GLSL code) include: attribute, uniform, varying (these are storage qualifiers) highp, medium, lowp, precision (these are precision qualifiers) in, out (these are parameter qualifiers) We consider variables that can change o Once per primitive o Once per vertex o Once per fragment o At any time in the application Reminder: vertex attributes are interpolated by the rasterizer into fragment attributes 7

8 Storage Qualifiers

9 Qualifier Constant The qualifier const is used the same as in Java. It specifies that the value assigned to a variable is constant and cannot be changed. The variable is read only. Here are a legal and illegal statement. // a vector assigned a value const vec4 point = vec4(1.0, 2.0, 3.0, 1.0); // illegal statement because the variable must be assigned a value const float time; The qualifier const is used for variables that are compile-time constants or for function parameters that are read-only. 9

10 The Qualifier attribute The qualifier attribute is used to declare variables that are shared between a vertex shader and the application program; typically, vertex coordinates passed to the vertex shader, e.g., application program attribute vec4 vposition; Attribute display (Vertex shader) (Fragment shader) Vertex attributes are used to specify per vertex data. They typically provide data such as the object space position, the normal direction and the texture coordinates of a vertex. Variables declared using the attribute qualifier are not changeable in the vertex shader, i.e., they are read only Variables declared using this qualifier must be initialized in the application program. 10

11 The Qualifier uniform The qualifier uniform is used to declare variables that are shared between a shader and the application program. application program Uniform display (Vertex shader) (Fragment shader) Variables declared using this qualifier can appear in the vertex shader and the fragment shader and they must have a global scope. Since both shaders share the same name space, if a uniform variable is used in both shaders, its declaration must be identical in both. 11

12 The Qualifier uniform (cont.) uniform variables are used to describe global properties that affect the scene to be rendered, e.g. projection matrix, light source position, etc. They can be used to describe properties (e.g., colour, materials) of the object. E.g., uniform mat4 projection; uniform float temperature; Similar to the qualifier attribute, variables declared as uniform are not changeable within the vertex shader or the fragment shader. However, their values can change in the application program. For each frame to be rendered, their new values are passed to the shader(s). 12

13 The Qualifier varying The qualifier varying is used to declare variables that are shared between the vertex shader and the fragment shader. application program Varying display (Vertex shader) (Fragment shader) varying variables are used to store data calculated in the vertex shader and to pass down to the fragment shader. Again, because of the sharing of name space of the two shaders, varying variables must be declared identically in both shaders. 13

14 The Qualifier varying (cont.) The varying qualifier can only be used with floating point scalar, floating point vectors and (floating point) matrices as well as arrays containing these types. Example: the vertex shader can compute the colour of the incoming vertex and then pass the value to the fragment shader for interpolation. In both shaders: varying vec4 colour; 14

15 Precision Qualifiers

16 The Qualifiers highp, mediump, lowp, and precision The highp, mediump, and lowp qualifiers are used to specify the highest, medium, and lowest precision available for a variable. All these qualifiers can appear in the vertex and fragment shaders. In the fragment shader, the precision qualifier must precede the three qualifiers above. e.g. uniform mediump vec4 lightpos; precision lowp vec3 indices; In the vertex shader the use of a precision qualifier is optional. If no qualifier is given all variables are of highest precision. In the fragment shader a precision qualifier has to be used when declaring a variable unless a default precision has been defined for the specific type. 16

17 The Qualifiers highp, mediump, lowp, and precision The default precision for int, float, and vectors of these types is highp. The actual range corresponding to a precision qualifier is dependent on the specific application. Using a lower precision might have a positive effect on performance (frame rates) and power efficiency but might also cause a loss in rendering quality. The appropriate trade-off can only be determined by testing different precision configurations. 17

18 Parameter Qualifiers

19 The Qualifiers in, out & inout The qualifier in is used to mark a parameter as read-only when a function is declared. The qualifier out is used to mark a parameter as write-only when a function is declared. The qualifier inout is used to mark a parameter as read-write when a function is declared. int newfunction(in bvec4 abvec4, // read-only out vec3 avec3, // write-only inout int aint); // read-write The above function declaration shows the three possible parameter qualifiers. The usage of the read-only qualifier is not necessary since this is the default if no qualifier is specified. 19

20 The Qualifiers in and out The in and out qualifiers supersede the attribute and varying qualifiers in GLSL version 4.20 onward: attribute is replaced by in in the vertex shader varying in the vertex shader is replaced by out varying in the fragment shader is replace by in 20

21 Built-in variables in shaders gl_position o Its value must be defined in the vertex shader in vec4 vposition; void main() { gl_position = vposition; } The input vertex s location is given by the four-dimensional vector vposition whose specification includes the keyword in to signify that its value is input to the shader when the shader is initiated. There is one special state variable in our shader: gl_position, which is the position that will be passed to the rasterizer and must be output by every vertex shader. Because gl_position is known to OpenGL, we need not declare it in the shader. 21

22 Built-in variables in shaders gl_fragcolor o o (Vertex shader) Used only on the Mac (in Lab2.03) Its value must be defined in the fragment shader Each invocation of the vertex shader outputs a vertex Each fragment invokes an execution of the fragment shader. each execution of the fragment shader must output a color for the fragment void main() { gl_fragcolor = vec4(1.0, 0.0, 0.0, 1.0); } (R, G, B, Opacity) (Fragment shader) 22

23 Operators and Functions Standard C functions o Trigonometric o Arithmetic o Normalize, reflect, length Overloading of vector and matrix types mat4 A; vec4 b, c, d; c = b*a; // not implemented in Angel.h d = A*b; // a column vector stored as a 1d array 23

24 Swizzling and Selection Can refer to array elements by their indices using [] or by selection operator (.) with x, y, z, w r, g, b, a s, t, p, q vec4 m; m[2], m.b, m.z, and m.p are the same Swizzling operator lets us manipulate components easily, e.g., vec4 a; a.yz = vec2(1.0, 2.0); vec4 newcolour = v.bgra; // swap red and blue 24

25 References Interactive Computer Graphics A Top-Down Approach with Shader-Based OpenGL by Edward Angel and Dave Shreiner, 6 th Ed, 2012 Sec The Vertex Shader The InitShader Function A good reference on OpenGL shaders: