void glCallList( GLuint n );
|
Executes stored OpenGL commands from a display list. n is the display list identifier to execute.  An added benefit of display lists is the elimination of application branches and loops. A for loop, for example, at the machine level typically incurs the overhead of an increment, a compare, and a branch per loop iteration. Highly tuned applications often partially unwind loops to minimize this overhead. When creating a display list, the application executes the loop only while creating the list. OpenGL stores only the resulting OpenGL commands, which are executed with a glCallList() command as a fully unwound loop.
The drawback to display lists should be obvious. When creating a display list, OpenGL makes a copy of both the commands and their data, possibly creating a burden on memory. If memory is a scarce resource for your application, you should use display lists only for the most performance-critical portions of your code. 2.4.2. Face Culling The OpenGL face-culling feature discards filled primitives based on the direction they face. Applications typically use face culling to discard faces from the back of models. This boosts performance by not bothering to rasterize primitives that won't be visible in the final image. To use face culling, your application needs to enable it. You might also need to specify the faces that OpenGL should cull. OpenGL effectively uses the right-hand rule to determine whether a primitive is front- or back-facing. If the vertices are ordered counterclockwise, the primitive is front facing. Note that a front face can become a back face due to a modeling transformation or change in viewing angle. For this reason, OpenGL performs face culling in window-coordinate space. (Chapter 3, "Transformation and Viewing," describes all OpenGL coordinate spaces. For now, think of window coordinates as pixels onscreen.) To enable face culling, call glEnable( GL_CULL_FACE ). By default, this culls back faces, or faces with clockwise-ordered window-coordinate vertices. You can tell OpenGL to cull front faces instead by calling glCullFace ( GL_FRONT ). Typically, applications enable face culling when the application renders solid geometry with a complete hull. Many applications create geometry using the right-hand rule so that counterclockwise vertices define front faces. Not all applications behave this way, however, and it's common for 3D model files to store faces with a vertex ordering that doesn't match the OpenGL default. You can change this default with the glFrontFace() command. See "glFrontFace" in OpenGL® Reference Manual. For more information on face culling, see Chapter 2, "State Management and Drawing Geometric Objects," of OpenGL® Programming Guide. 2.4.3. Vertex Array Size Most OpenGL implementations can provide maximum performance only if the number of vertices stored in a vertex array is below an implementation-specific threshold. An application can store as many vertices in a vertex array as necessary, but if the number exceeds this threshold, performance could suffer. Applications can query this implementation-specific threshold with the following code: GLint maxVerts; glGetIntegerv( GL_MAX_ELEMENTS_VERTICES, &maxVerts );
When using glDrawRangeElements(), the minimum and maximum index parameters, start and end, should specify a range smaller than GL_MAX_ELEMENTS_VERTICES to obtain maximum performance. OpenGL implementations have a similar limit on the number of vertex array indexes. Applications can query this value by calling glGetIntegerv() and passing in GL_MAX_ELEMENTS_INDICES. The count parameter to both glDrawElements() and glDrawRangeElements() should be less than GL_MAX_ELEMENTS_INDICES to obtain maximum performance. Many applications disregard these upper limits and simply specify as many vertices and indices as necessary. If performance is a concern, however, modify your application to respect these limits where feasible. | 