OpenGL/Shaders

Shader programs

      /* Global variables - shared with fragment shader */
      varying vec3 normalPassOn?;

      /* Simple vertex shader program */
      void main() {
          vec4 vertex  = gl_Vertex + vec4( -1.0f, -1.0f, 0.0f, 0.0f );
          gl_Position  = gl_ModelViewProjectionMatrix? * vertex;
          normalPassOn? = gl_NormalMatrix? * gl_Normal;
      }

GLSL syntax

  float, int, bool
  vec2, vec3, vec4 [vectors - also ivec and bvec]
  mat2, mat3, mat4 [matrices]
  sampler          [textures]

  vec4 gl_Vertex;
  vec3 gl_Normal;
  vec4 gl_Color;
  mat4 gl_ModelViewProjectionMatrix?;

  vec4 gl_Position;

  vec4 gl_FragColor?;
  vec4 gl_FragDepth?;

OpenGL Integration

   GLchar * vertexProgram[] =
     {
       "/* Global variables - shared with fragment shader */           ",
       "varying vec3 normalPassOn?;                                     ",
       "                                                               ",
       "/* Simple vertex shader program */                             ",
       "void main() {                                                  ",
       "  vec4 vertex  = gl_Vertex + vec4( -1.0f, -1.0f, 0.0f, 0.0f ); ",
       "  gl_Position  = gl_ModelViewProjectionMatrix? * vertex;        ",
       "  normalPassOn? = gl_NormalMatrix? * gl_Normal;                  ",
       "}                                                              "
     };

   GLchar * fragmentProgram[] =
     {
       "/* Global variables - shared with vertex shader */          ",
       "varying vec3 normalPassOn?;                                  ",
       "                                                            ",
       "/* Simple fragment shader program */                        ",
       "void main() {                                               ",
       "  gl_FragColor? = vec4( 1.0f, 1.0f, 0.0f, 0.0f ) * dot( vec3(1.0f, 0.0f, 0.0f ), normalPassOn? );",
       "}                                                           "
     };

   GLuint createShader( int type, char ** program, int programLines )
   {
     GLint   error;
     GLenum  compileStatus;
     GLuint  shader;

       /* Create a Vertex shader */
       shader = glCreateShader?( type );

       /* Install the shader program */
       glShaderSource?( shader,
                       programLines,
                       program,
                       NULL );

       /* Compile and check status */
       glCompileShader?( shader );
       glGetShaderiv?( shader, GL_COMPILE_STATUS, &compileStatus );

       /* Compilation error handling */
       error = glGetError?();
       if ( error != 0 || !compileStatus )
         {
           GLchar    message[1024];
           GLsizei * messageSize;

           glGetShaderInfoLog?( shader, 
                               sizeof( message ),
                              &messageSize,
                               message );
           printf( "Error compiling shader.  Error code %x: %s\n", error, message );

           glDeleteShader?( shader );
           return 0;
         }
       printf( "Success\n" );
       return shader;
   }

   GLuint createShaderProgram?( void )
     {
       GLuint program        = glCreateProgram?();
       GLuint vertexShader   = createShader( GL_VERTEX_SHADER, vertexProgram, 
                                             sizeof( vertexProgram ) / sizeof( GLchar * ) );
       GLuint fragmentShader = createShader( GL_FRAGMENT_SHADER, fragmentProgram, 
                                              sizeof( fragmentProgram ) / sizeof( GLchar * ) );
       glAttachShader?( program, fragmentShader );
       glAttachShader?( program, vertexShader );
       glLinkProgram?( program );
       return program;
     }

Implementing the standard Model view with Shaders

 void main(void)
 {
     gl_Position = ftransform();
 }

  gl_Position = projection_matrix * modelview_matrix * vec4(vertex,1.0);

In general it is much much cheaper to do work in the vertex shader, because there are far fewer vertices than pixels.  So anywhere that plain old interpolation is good enough, you want to do it in the vertex.  Calculate as early as possible, rather than as close to when the value is needed as possible, unless you know you're going to texkill it more often than not.  (Of course, if you read a texture in, for bump mapping perhaps, then some stuff really has to wait until the pixel shader.)  --Vitenka (Everything is only useful in the pixel shader, when it comes down to it - that's the thing that draws on the (render surface) screen, after all.)

I can understand that I may want to do processing in the vertex shader, but why aren't gl_Color and friends *also* available in the fragment shader?  I would expect that everything I could read in the vertex shader would also automatically be accessible in the fragment shader.  Maybe this is an architectural hardware issue...  Also, I am confused by vec2( gl_MultiTexCoord0? ): surely this value changes on a pixel-by-pixel basis as it seems to be the XY offset into the texture buffer? - DDD

I believe it is deliberate that you have to specify which elements you pass to the fragment shader - in general if some are going to be ignored you want to not pass them, since register space is limited.  (Or, more usefully, you can process more pixels in parallel if you use fewer registers.)  However yes - everything changes on a per pixel basis.  But the hardware interpolates for you between the values passed in by the vertex shader.  You don't try to specify every pixel "You are this pixel in the texture", you specify each vertex's position in the texture and let the hardware lerp for you.  (Same for normals, lighting direction, world-position etc. etc. etc. though the exact methods of interpolation vary and sometimes need to be done manually in the fragment shader)  --Vitenka

Thanks - that makes more sense (although it does imply a certain level of "magic" to specify exactly what is in textureOffset each time the Fragment shader runs).  I assume that if I specify a triangle, there are implicitly three "textureOffsets" (one from each vertex), and the fragment shader sees a textureOffset somewhere in the middle of them.  Can I access the three vec2() values and dynamically choose which bit of texture to display should I happen to not want linear interpolation (e.g. if I want to draw the texture to look as though it is mapped onto a curved surface)? -- DDD

Right.  Your vertex format can have many different bits of data - typically you want to pass in a position (xyz) and a texture offset (uv) - that's how you get basic texture mapping.  I *think* you can specify several common types of interpolation in case you want to do something complex.  For what you are asking, what you actually want to do is work out a normal for each vertex (which could be uploaded as part of your vertex definition) that gets interpolated and you use that as part of a calculation done in the pixel shader.

If you want direct access to the vertex data... I'm not sure you can easily do that.  You can certainly FAKE it by, for example, sampling a texture in the pixel shader (textures contain images only by convention - you can have any data you want in there...)  I'm pretty sure that you can specify which interpolation method you want as well, though I'm not sure of the syntax.  --Vitenka 

Don't think of it as 'magic'.  Think of it like this:

(position, normal, tangent, colour, uv) per-vertex streams + big pile of shader constants

--> For every vertex, the Vertex shader transforms all of that into a new set of streams of your own defining

(screen position, z, uv, colour, whatever)

--> Now, the rasteriser works out, for every triangle, what each pixel should have

(doing frustum culling etc.)

and then interpolates to get the inputs to your pixel-shader.

--> For every pixel, the pixel shader runs - producing a final output colour and alpha and depth value (and maybe some other outputs, but usually just a colour)

Aha... I think I therefore understand the meaning of the "varying" keyword.  Each triangle results in three runs of the vertex shader, which means three normals, texture offsets, colours and lightings.  When the fragment shader is called, I have only one of each - representing a weighted average of the three vertex shader runs' outputs.  The sampler2D is uniform, because it is the same texture no-matter where in the triangle I am currently rendering.  I probably need to start playing with the textureOffsets in the fragment shader to see what happens if I try to deform a texture.  From what you are saying, I could even go as far as having two textures - one describing local curvature, one describing a flat image - and do some more complex mathematics to do non-flat image mapping.  Cheers! -- DDD

Indeed.  The search term you are looking for is "Bump mapping"  --Vitenka

Vertex Shader

   /* Global variables - shared with fragment shader */             
   varying vec3 normalVector;                                       
   varying vec2 textureOffset;                                      
   varying vec4 colour;                                             
   varying vec3 lighting;                                           

   /* Simple vertex shader program */                               
   void main() {                                                    
     vec4 lightSource;                                              
     vec4 vertex;                                                   
     vec4 lightPosition = gl_LightSource?[0].position;               

     /* Do some basic position processing */                        
     vertex = gl_Vertex + vec4( -1.0f, -1.0f, 0.0f, 0.0f );         
     gl_Position  = gl_ModelViewProjectionMatrix? * vertex;          

     /* Set up lighting and normal vectors */                       
     lightPosition = gl_LightSource?[0].position;                    
     lighting = vec3( lightPosition.x,                              
                      lightPosition.y,                              
                      lightPosition.z );                            
     normalVector = gl_NormalMatrix? * gl_Normal;                    

     /* Set up colour and texture positioning vectors */            
     colour  = gl_Color;                                            
     textureOffset = vec2( gl_MultiTexCoord0? );                     
   }

Fragment Shader

   /* Global variables - shared with fragment shader */             
   varying vec3 normalVector;                                       
   varying vec2 textureOffset;                                      
   varying vec4 colour;                                             
   varying vec3 lighting;                                           

   /* Passed parameters */                                          
   uniform sampler2D texture;                                       

   /* Simple fragment shader program */                             
   void main() {                                                    
     vec4 pixelColour = texture2D( texture, textureOffset );        
     pixelColour = (pixelColour * 4 + colour) / 5;                  
     gl_FragColor? = pixelColour                                     
                    * ( 4 + dot( lighting, normalVector ) ) / 5;    
   }                                                                

Common shader techniques