OpenGL Optimizer is a C++ toolkit for CAD applications. It enables interactive, robust visualization of large model databases. OpenGL Optimizer provides the following tools:
This guide describes each individual tool and explores how they work together, and explores issues and tools relevant for developing large visualization programs using OpenGL Optimizer.
This is not a reference manual but a guide. For complete details about elements of the library, consult the man pages and header files, and look at the example applications.
The OpenGL Optimizer tools are modular without strong interdependencies. After familiarizing yourself with the topics in Part I, “Getting Started,” you should be able to read profitably about any topic you pick from the table of contents. Cross-references within discussions guide you to related material.
Not every feature in every header file is documented in this guide. Also, some elements presented may differ slightly from the header files, due to late changes in the software. For further information about a specific class, see the man page for that class, which will be in the form op*(3), where op* is an OpenGL Optimizer class.
All classes and functions in the OpenGL Optimizer library have names that begin with the characters op followed by a string beginning with an upper-case letter.
All classes and functions in the Cosmo3D library have names that begin with the characters cs followed by a string beginning with an uppercase letter. Consult the Cosmo 3D Programmer's Guide for more information about any object whose name begins with cs.
This guide is divided into six parts and consists of seventeen chapters.
Part I, “Getting Started,” introduces OpenGL Optimizer by providing background information and discussing the basic components of a program.
Chapter 1, “OpenGL Optimizer Overview,”summarizes the challenges of large CAD visualization, characterizes in general terms the rendering task that the OpenGL Optimizer library facilitates, and surveys the tools OpenGL Optimizer provides to address bottlenecks at each stage of the graphics pipeline.
Chapter 2, “Basic I/O: Getting Started with OpenGL Optimizer,” introduces the main rendering tools and lists a minimal first program.
Part II, “High-Level Strategic Tools for Fast Rendering,” describes complete data processing methods for fast and coherent rendering of a large CAD database.
Chapter 3, “Sending Efficient Graphics Data to the Hardware,” discusses how to use display lists, vertex arrays, smaller vertex-data formats, connected geometric primitives.
Chapter 4, “Rendering Appropriate Levels of Detail,” discusses mesh simplifiers and a tool to insert level-of-detail nodes in the scene graph.
Chapter 5, “Culling Unneeded Objects From the Scene Graph,” discusses view-frustum culling, occlusion culling, and back-face culling.
Chapter 6, “Organizing the Scene Graph Spatially,” presents tools to reorganize the triangles in a scene graph to increase rendering speed.
Part III, “Specific Tools for Fast Rendering,” presents tools for two useful rendering tasks.
Chapter 7, “Interactive Highlighting and Manipulating,” describes how to interactively highlight and manipulate objects in a scene.
Chapter 8, “Efficient High-Quality Lighting Effects: Reflection Mapping,” presents good, approximate, fast lighting techniques, and techniques that provide very accurate lighting for reliable visual examination of model surfaces.
Part IV, “Managing and Rendering Higher-Order Geometric Primitives,” presents the set of tools for managing and rendering surfaces that are defined by mathematical equations.
Chapter 9, “Higher-Order Geometric Primitives and Discrete Meshes,” describes OpenGL Optimizer extensions to Cosmo3D geometric shapes,, for example, parametric surfaces and trimmed NURBS.
Chapter 10, “Creating and Maintaining Surface Topology,” describes tools to stitch together geometric primitives so that images do not have artificial cracks or breaks.
Chapter 11, “Rendering Higher-Order Primitives: Tessellators,” presents the tools you need to convert higher-order primitives into primitives that can be passed to the graphics hardware.
Part V, “Traversers, Low-Level Geometry Processing, and Multiprocessing,” describes tools that manipulate scene graph elements.
Chapter 12, “Traversing a Large Scene Graph,” describes tools that focus on scene-graph manipulations.
Chapter 13, “Manipulating Triangles and Rebuilding Renderable Objects,” describes the lower-level tools that perform the tasks discussed in Chapter 6.
Chapter 14, “Managing Multiple Processors,” describes the tools that allow you to easily manipulate a scene graph with several processors and coordinate manipulations of the scene graph.
Part VI, “Utilities and Troubleshooting,” describes tools and hints that are useful for developing OpenGL Optimizer applications.
Chapter 15, “Utilities,” presents several tools, such as error handlers and timers, to help polish an OpenGL Optimizer application.
Chapter 16, “Troubleshooting,” describes ways to avoid typical sticking points that occur when developing an OpenGL Optimizer application.
Part VII, “Appendices,” five appendixes complement the material:
Appendix A, “Installing OpenGL Optimizer,” guides you through installing OpenGL Optimizer (UNIX and Windows) and explains environment variable settings (UNIX only).
Appendix B, “OpenGL Optimizer Sample Applications,” discusses the available sample applications.
Appendix C, “opviewer Sample Application,” explains how to use opviewer, a sample application that allows developers to view and manipulate scene graphs, and contains a commented listing of the code.
Appendix D, “Scene Graph Tuning With the opoptimize Application,” briefly explores how to use opoptimize, a sample application that allows developers to optimizer their own programs in batch processing mode, and contains a commented listing of the code.
Appendix E, “Optimizer Class Hierarchy,” lists the class hierarchies for opViewer, opXMViewer, and Optimizer.
This guide also includes a glossary and an index.
