Color in OpenGL

• The fragment shader is responsible for computing a fragment's color and depth values.
  • A fragment is a portion of a window, and a depth value (provided by previous states)
  • It is a reasonable place to compute lighting.
  • We have seen that gl_FragColor, a vec4 is the output.
  • It has access to all uniform variables.
  • And to varying variables as well
  • And to uniform variables.
  • It is given
    • vec 4gl_FragCoord, the coordinates of the pixel, along with depth.
    • bool gl_FrontFacing: If it is front facing or not.
    • vec2 gl_PointCoord, for sprites
• We will examine lighting functions in both the vertex and the fragment shaders.
• This discussion is based mostly on the red book.
• A little more on shader languages
  • Control Structures
    • if (be) {} else {}
    • switch (int) { case const: statements; break; ...default: statements; break; }
    • for(init;be;inc) { statements}
    • while(be) { statements}
    • do { statements} while (be);
  • break, return, continue as in c.
  • discard:
    • Only in fragment shader
    • Stop all processing of this fragment.
  • vec
    • Swizzling
      • addressed as .x, .y. .z, .w
      • or as .r, .g, .b, .a
      • can be mixed foo.xyz
      • foo.wzyx
      • assignment or access
    • Operators
      • Component-wise
        • max, min, (v,v) or (v,f)
        • clamp(v, a,b) return min(max(v,a),b)
        • mix(a,b,wb) return a*(1-wb)+b*wb
      • Others
        • cross(a,b) return a × b
        • dot(a,b) return a·b
        • length(a)
        • distance(a,b) return length(a-b)
        • normalize(a)
        • reflect(a,normal)
          • computes reflection ray
          • a incoming ray
          • n surface normal.
          • refract(a,n, r):
            • Computes the refracted ray
            • a is the incoming ray
            • n is the normal
            • r is the ratio refractive index from where the ray is coming from to the refractive index in the outgoing material.
  • An ambient shader is the easiest to produce.
    • We compute the ambient light source at a point by
    • I_a = k_a × L_a
    • L_a describes the ambient light source.
    • L_a = [0,0,0] => all ambient light is absorbed
    • k_a = [1,1,1] => all ambient light is reflected
    • From the red book

    • vshader.glsl
      in vec4 VertexColor
      in vec4 VertexPosition
      
      out vec4 color
      void main() {
          color = VertexColor 
          gl_Position = // calculation
      }
      
      fshader.glsl
      uniform vec4 Ambient
      in vec4 color
      int main () {
           gl_FragColor = min(color * Ambient, vec4(1.0))
      }
      	

    • With this, we need to be careful of the alpha component.
    • He suggests:

    • vec3 scatteredLight = vec3(Ambient)
      vec3 rgb = min(color.rgb * scatteredLight, vec3(1.0))
      gl_FragColor = vec4(rgb, color.a)
      	

    • He notes:
      • This could have been done in the vertex shader.
      • And it might have taken less time. (Fewer vertices)
      • And the results would have been the same.
      • But other techniques can not be done here.
  • Adding a directional light source
    • Assume the point light source is at a large distance from the objects.
    • Think Sun : so far that there is no distance, and the light is uniform.
    • It is at -LightDirection, or LightDirection is the direction towards the light.
    • The surface normal will be interpolated between vertices by the openGL pipeline during rasterization.
    • Remember I_d = k_d(l·n)L_d
      • k_d is the reflective property of the item.
      • L_d is the diffuse values of the light.
      • l is the LightDirection
      • n is the (interpolated ) surface normal at the point.

      • uniform vec3 LightDirection;
        uniform vec3 LightColor;
        uniform vec3 Ambient;
        
        in vec4 color;
        in vec3 Normal;
        
        void main() {
            float diffuse = max(0.0, dot(Normal, LightDirection));
        
            ..
            vec3 scatteredLight = Ambient + LightColor * diffuse;
            ...
        
            vec3 rgb = min (color.rgb*scatteredLight, vec3(1.0));
            gl_FragColor = vec4(rgb, color.a)
        }
        	     

    • We can add a Specular highlight as well
      • This involves an angle φ between the angle of perfect reflection and the viewer position.
      • For this light source, the angle can be computed in the application.
      • Or this can be computed as ψ, the half angle (see P 270-271)
      • I_s = k_sL_scos^αψ
        • k_s is a surface property.
        • L_s is a property of the light.
        • α is a property of the surface.

        uniform vec3 HalfVector;
        uniform float Shininess;
        uniform float Strength;
        ...
        
        float specular = max(0.0, dot(Normal, HalfVector));
        ..
        if (diffuse == 0.0) 
           specular = 0.0
        else
           specular = pow(specular,Shininess);
        ...
        vec3 reflectedLight = LightColor * specular * Strength;
        vec3 rgb = min (color.rgb*scatteredLight+reflectedLight, vec3(1.0));
        gl_FragColor = vec4(rgb, color.a)