Using Per-Fragment Operations Effectively

Getting the Optimum Fill Rates

• Clear operations and screen-aligned glRect() calls that don't use the depth or stencil buffer have a maximum fill rate of 400 MB/sec

  The hardware accelerates drawing rectangles that have their vertical and horizontal edges parallel to those of the window. The OpenGL glRect() call--as opposed to IRIS GL rect()--specifies rectangles, but depending on the matrix transformations they may not be screen-aligned. If the matrices are such that the rectangle drawn by glRect() is screen-aligned, OpenGL detects that and uses the accelerated mode for screen-aligned rectangles.

• Use glShadeModel() with GL_FLAT whenever possible, especially for lines.

• Using dithering, shading, patterns, logical operations, writemasks, stencil buffering, and depth buffering (and alpha blending on some systems) slows down an application.

• Use glEnable() with GL_CULL_FACE to eliminate backfacing polygons, especially in modes that have slow fill rates, such as depth buffering and texturing (alpha-blending on some systems).

• In any OpenGL matrix mode, low-end systems check for transforms that only scale, and have no rotations or perspective. The system looks at the specified matrices, and if they only scale and have no rotation or perspective, performs optimizations that speed up transformation of vertices to device coordinates. One way to specify this is:

  glMatrixMode(GL_PROJECTION);

  glLoadIdentity();

  gluOrtho2D(0,xsize,0,ysize);

  glMatrixMode(GL_MODELVIEW);

  glLoadIdentity();

  glShadeModel(GL_FLAT);

  You also have to use a glVertex2fv() call to specify 2D vertices.

• Starting with IRIX 6.2, texture mapping speed is increased by about 10 times (compared to previous releases) when texture parameters are specified as follows:

  glEnable(GL_TEXTURE_2D);

  glTexParameter(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

  glTexParameter(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

  glTexParameter(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);

  glTexParameter(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

  glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);

  In addition, follow these guidelines:

  • For RGB textures, make sure the texture environment mode, set with glTexEnv(), is either GL_REPLACE_EXT or GL_DECAL.

  • For RGBA textures, make sure the texture environment mode is GL_REPLACE_EXT.

    Note that the above fast path does not work when stencil is enabled and when depth buffering and alpha testing are both on.

Note: Avoid using depth buffering whenever possible, because the fill rates for depth buffering are much slower. In particular, avoid using depth-buffered lines, as they are especially slow. The depth buffer is as large as the window, so use the smallest possible window to minimize the amount of memory allocated to the depth buffer. The same applies for stencil buffers.

Using Per-Fragment Operations Effectively

Pixel Formats and Types Using DMA on Low-End Systems

Format	Type
GL_RGBA	GL_UNSIGNED_BYTE
GL_ABGR_EXT	GL_UNSIGNED_BYTE
GL_COLOR_INDEX	GL_UNSIGNED_BYTE
GL_COLOR_INDEX	GL_UNSIGNED_SHORT

Note that GL_ABGR_EXT provides better performance than GL_RGBA on Indigo Entry systems but not on Indy or Indigo2 XL where the two perform about the same.

Here are some additional guidelines for optimizing pixel operations:

• Scrolling. When scrolling scenes, use glCopyPixels() to copy from one scene to the next.

  When you scroll something, such as a teleprompter text scroll or an EKG display, use glCopyPixels() to shift the part of the window in the scrolling direction, and draw only the area that's newly exposed.

  This is much faster than completely redrawing each frame.

• Minimizing calls. Make each pixel operation draw as much data as possible. For each call, a certain amount of setup is required; you cut down on that time if you minimize the number of calls.

• Zooming. Zoomed pixels can't use DMA. A 2 x 2 zoom is faster than other zoom operations.

• Depth and scissoring. Low-end systems use an accelerated algorithm that makes clearing the depth buffer virtually free. However, this has slowed enabling and disabling scissoring and changing the scissor rectangle. The larger the scissor rectangle, the longer the delay. Note that rendering while scissoring is turned on is fast; calling glEnable() and glDisable() with GL_SCISSOR and calling glScissor() is slow. This also includes pushing and popping attributes that may cause a scissor change.