Some More on the Lighting Code

• Hidden Surface Removal
  • We have discussed backface removal (check the angle of the normal to the viewing angle.
  • Hidden surface removal is when you remove one surface which is obscured by another.
  • In general hidden surface removal is complex.
    • Sorting the polygons, and clipping and ...
  • Once we have lighting, we can do an easy hidden surface removal
    • Add an additional element to the frame buffer.
    • Called the depth or z buffer.
    • Reset the depth buffer to infinity at the beginning of a draw.
    • The "z" position of the pixel needs to be calculated
      • But this is a natural extension to Bresenham's
    • When a pixel is drawn for the first time.
      • Set the depth in the depth buffer to be the projected z value for that pixel.
      • Draw the pixel.
    • To draw any other pixel at that location
      • If the z value is further than the stored z value, throw away the pixel.
      • Otherwise update the z buffer and replace (overwrite) the existing pixel.
  • This is called z-buffering
  • To do this in OpenGL
    • Get a display mode which supports it.
    • glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
    • Turn depth buffering on.
    • glEnable(GL_DEPTH_TEST);
    • Before displaying, clear the depth buffer bit.
    • glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);;
  • An alternative method would be a depth sorting method applied to primitives.
    • This would occur after the primitives have been translated to NDC.
    • Objects could be sorted so that further away objects are drawn first.
      • This is fine as long as polygons do not intersect.
      • But if polygons intersect, they must be clipped.
    • The objects are then drawn from far to near.
      • The closer objects will be drawn on top of the further objects.
    • This is sometimes called the painter's algorithm
• While we are on the topic
  • void glFrontFace(GLenum mode);
  • GL_CCW or GL_CW
  • GL_CCW is the default.
  • glEnable(GL_CULL_FACE) is required.
• A uniform vector
  • I made ambient_G a vec3
  • The transfer from the application to the shader was a little strange.
  • For scalers

    if (diffLoc > 0) {
         glUniform1i(diffLoc,diffuse_G);
    }
    

  • For vectors a different call is needed.

    if (ambLoc > 0) {
         glUniform3fv(ambLoc,1,ambient_G);
    }
    

  • void glUniform3fv( GLint location, GLsizei count, const GLfloat *value);
    • location and value as before
    • The count is the number of vectors to transfer.
• While dealing with uniforms
  • void glGetProgramiv(GLuint program, GLenum pname,GLint * params);
  • This code was lifted, but I didn't record from where.
    • Returns information about a program.
    • In the code below, we ask for the number of active attributes.
    • But you can ask for GL_ACTIVE_UNIFORMS, and other items.
  • void glGetActiveAttrib( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
    • The same can be done for uniforms.
    • You can query for the maximum string length, so the hard coded 16 is probably not best.
    • Type: GL_FLOAT, GL_FLOAT_VEC2, GL_FLOAT_VEC3, GL_FLOAT_VEC4, GL_FLOAT_MAT2, GL_FLOAT_MAT3, or GL_FLOAT_MAT4
    • size: the size of the unit in the type of unit.

    void PrintAttribs(GLuint prog) {
      int count;
      glGetProgramiv(prog, GL_ACTIVE_ATTRIBUTES, &count);
      printf("Active Attributes: %d\n", count);
      GLint size; // size of the variable
      GLenum type; // type of the variable (float, vec3 or mat4, etc)
    
      const GLsizei bufSize = 16; // maximum name length
      GLchar name[bufSize]; // variable name in GLSL
      GLsizei length; // name length
    
      for (int i = 0; i < count; i++)
      {
          glGetActiveAttrib(prog, (GLuint)i, bufSize, &length, &size, &type, name);
          cout << "Attribute " << i << " is " << type
               << " and is called " << name << endl;
    
      }
      return;
    }
    

• I was wrong about Gouraud Shading
  • In Gouraud the color is calculated at the vertices
  • Then interpolated between
  • As opposed to Phong where the computation is done per pixel
• Some additional notes
  • Attributes (and I assume uniforms)
    • Are not active unless the value is used in a real computation.
    • The so just declaring the variable in the shader is insufficient.
    • You can not bind to a non-active uniform (or attribute)
• Normalize your vectors.
• Speaking of normal vectors
  • This is another reason we love triangles.
    • All points are co-plainer, so there is a single surface normal.
  • If you use non-uniform scaling
    • You can not use the usual transformation matrix.
    • This is mentioned in the book twice
    • And a great tutorial is here
    • 
    • 
  • There are numerous solutions.
  • In the book, they maintain different matrices.
• Look at the shaders starting on 366