Shader Fundamentals

• This material is from chapter 2 of your book.
• It is a study of a new programming language, GLSL
  • Open Gl's Shader Language.
• Your graphics program is normally split in two
  • The program on the CPU generates data and sets switches.
  • The programs on the GPU manipulate that data and transform it into images.
• The GPU is programmable in five different programmable shaders
  • The vertex shader starts with the data in the VBOs
    • Each vertex is processed as an independent item
    • This shader is mandatory in all programs.
    • We have seen the simplest version of this, just pass the points along.
    • We examine this shader in much more depth in chapter 3.
  • The Tessellation shader
    • Generates new vertex (and primitive) data
    • Essentially an operation on a primitive
    • Creates sub-primitives from existing primitives
    • 
    • Level of detail generation
    • Several examples include terrain generation, hair generation
    • I may play with this later.
  • The Geometry shader
    • After the Tessellation shader if activated.
    • Works on geometric primitives, not vertices.
    • Possibly convert one type of item to another.
    • Possibly discard some items
  • The Fragment shader
  • The Compute shader
    • Generic parallel processing stage.
• GLSL is based on C
  • Each shader is a stand alone "main" program
  • Which is invoked once for each type of data
    • Vertex shader is invoked once for each vertex in your program.
    • Geometry shader, once for each primitive
    • ...
  • Data is passed between using global variables

    attribute vec4 vPosition;
    
    void main() {
        gl_Position = vPosition;
        gl_PointSize = 5.0;
    }
    

  • In this case gl_Position and gl_PointSize
  • Users can also declare in and out variables which are passed between stages of the sahder.
  • Users can transfer data from the CPU program via uniform variables.
• The language: DataTypes
  • Both C++ style comments are supported.
  • Statements are terminated with a ;
  • Simple data types
    • float,
    • double
    • int
    • uint
    • bool
  • Declaration as in C/C++, including assignment.
    • Constants can be followed by u for unsigned
    • Or by f or lf for float and long float (double)
    • Booleans are true or false
  • GLSL does not do type coercion
    • int x = 3.0 results in

    • Shader compilation failed: 0:14(2): error: initializer of type float cannot be assigned to variable of type int
      	      

    • Page 39 has the following table

    • Type Needed	Implicit conversion from
      uint	int
      float	int,uint
      double	int, uint, float

    • All others are accomplished with type casts.
      • Which they call conversion constructors
      • int x = int(3.0);
  • Aggregate Types
    • Because of the nature of the task, there are both vector and matrix types

    • Base Type	2D vec	3D vec	4D vec	Matrix Types
      float	vec2	vec3	vec4	mat2 mat3 mat4 mat2x2 mat2x3 mat2x4 mat3x2 mat3x3 mat3x4 mat4x2 mat4x3 mat4x4
      double	dvec2	dvec3	dvec4	dmat2 dmat3 dmat4 dmat2x2 dmat2x3 dmat2x4 dmat3x2 dmat3x3 dmat3x4 dmat4x2 dmat4x3 dmat4x4
      int	ivec2	ivec3	ivec4	-
      uint	uvec2	uvec3	uvec4	-
      bool	bvec2	bvec3	bvec4	-

    • mat2 is a 2x2 of floats.
    • mat3x2 is a 3 column by two row matrix of floats.

    • vec4 color = vec4(red,green, blue, 1.0);

    • ivec3 silly = ivec3(color);

    • vec4 color = vec4(1.0);

      sets all four components to 1.0
    • Matrices initialized with a single value are diagonal
      • mat3 f=(1.0)

            | 1.0  0.0  0.0 |
        f = | 0.0  1.0  0.0 |
            | 0.0  0.0  1.0 |
        		  

      • OpenGl uses the column major (different from what you may have been taught)
      • mat3 f = (1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)

      •     | 1.0  4.0  7.0 |
        f = | 2.0  5.0  8.0 |
            | 3.0  6.0  9.0 |
        		

      • There are other examples in the book.
    • There are many ways to access these types
      • For four vectors:
      • As an array colors[0], colors[1], ... colors[3]
      • As a color structure colors.r, (rgba)
      • As a point colors.x (xyzw)
      • As a texture element (stpq)
      • For 3 vectors drop last letter
      • For 2 vectors drop last 2 letters
      • colors.gbra does what you would want it to.
      • colors.rrrr does too.
    • Both structures and arrays can be built.

      • struct Cell_T {
             int age;
             vec3 location
        };
        
        Cell_T a = CellT(0,10,20,30);
        		

      • Arrays are c style, but index out of bounds is a problem.
        • Have a .length method
• Storage Qualifiers
  • const as in C
  • in the variable is an input from another shader
  • out the variable should be output for use by another shader.
  • uniform the variable is passed to the shader by the application. It is constant across a primitive.
• Bridging between the application and the shaders.
  • GLint glGetUniformLocation(GLuint program, const GLchar *name);
    • The program is the result of LoadShaders
    • The string is the name of the uniform variable you want to connect to.
    • This returns a "pointer" to a uniform variable.
  • glUniform*
    • Sets the value of a uniform variable.
    • 1,2,3,4 - number of parameters
    • f, i, u - type of parameters
    • v - vector option
    • glUniform1f - one floating point in a variable
    • glUniform3fv - 3 floating point values in a vector
    • Also glUniformMatrix*
• The code for this section is here