Geometry Shaders

Geometry shaders are the final programmable pipeline stage prior to the rasterization step that feeds the fragment shader. Regardless of the "GLenum mode" that was used on a glDrawArrays of glDrawElements call, the only shapes that actually are in the pipeline at that point are individual points, lines, or triangles. Geometry shaders allow the incoming shape to be modified in some way, including changing its type (e.g., point to triangle).

Geometry shaders are specific to a given input shape type (point, line, or triangle), hence care must be taken to have a geometry shader active only when a matching draw call has been used. For example, if I have a geometry shader that modifies an incoming triangle in some way, the shader can only be active (i.e., from a glUseProgram call) when a glDrawArrays or glDrawElements call has been made in which the type is some GL_TRIANGLE*. Errors will be recorded otherwise. It is common to have multiple shaders in an OpenGL program, and then to do a glUseProgram to establish the program needed for a given primitive call.

What follows is one simple example each of a "type-changing" and "type-preserving" geometry shader.

• Type-changing:
  Some multivariate datasets can be viewed as tables of numbers. We call each row a "point", and hence each point has m per-vertex attributes, where m is the number of columns in the table. Many visualization applications render such datasets as a "cloud" of points. Two of the m attributes are used as x and y coordinates; the remaining m-2 per-vertex attributes can then be used in a geometry shader to alter how each point is rendered. For example, I may use one of the attributes to decide whether to render the point as, say, a triangle, a square, or a star. (Because any given geometry shader can only produce one or more instances of a point OR a line OR a triangle, the square and star would be generated as two instances of triangles.) I may then use another attribute to determine the size of the triangle, square, or star. Other PVAs could continue to get passed on to the fragment shader where they could then be used to define color, texture, etc. as we have seen all along.

  The image on the right was generated this way. The VAOs and VBOs were created in the usual way on the CPU and sent to the GPU. The render callback then issued the call:

  glDrawArrays(GL_POINTS, 0, numPoints);

  PointsToTriangles.gsh: The bulk of the geometry shader that did the work described above. The C++ code that created the shader program is:

  ShaderIF::ShaderSpec glslProg[] =
  {
      { "shaders/PointsMV.vsh", GL_VERTEX_SHADER },
      { "shaders/PointsToTriangles.gsh", GL_GEOMETRY_SHADER },
      { "shaders/PointsMV.fsh", GL_FRAGMENT_SHADER }
  };
  
  ShaderIF* shaderIF = new ShaderIF(glslProg, 3);

• Type-preserving:
  Curved surfaces are typically approximated with networks of triangles. For a variety of reasons, it is sometimes useful to visualize this decomposition by slightly shrinking each triangle about its centroid. We see below an example of doing this with a sphere. The left image shows the sphere as it might normally be rendered. The right image shows the result of inserting a geometry shader that shrinks each incoming triangle by some amount and then outputs the shrunken triangle.

  shrinkTriangles.gsh: The geometry shader that did the work described above.