OpenGL PERFORMER FAQs 1 thru 50

square72_blue.gif FAQs 1 thru 50 square72_blue.gif FAQs 101 thru 150 square72_blue.gif FAQs 101 thru 150  FAQs 151 thru 200 square72_blue.gif  


    This unofficial Opengl Performer FAQ Part 1 ( 1 thru 50) is provided by Gordon Tomlinson , I hope you find the information contained with these FAQ's useful and helpful

    OpenGL Performer™ is a powerful and comprehensive programming interface for developers creating real-time visual simulation and other performance-oriented 3D graphics applications. It simplifies development of complex applications used for visual simulation, manufacturing, simulation-based design, virtual reality, scientific visualization, interactive entertainment, broadcast video, architectural walk-through, and computer-aided design.


  1. What is OpenGL Performer
  2. What operating systems does Performer Support
  3. Does SGI Recommend Any Platforms
  4. How do I get Hold of OpenGL Performer
  5. Is OpenGL Performer freeware or Open Source
  6. How do I get Support for OpenGL Performer
  7. How to I get a license for OpenGL Performer
  8. How can I remove the Performer Logo from the Screen
  9. What is New In Open GLPerformer 3.1.1
  10. Where are the Books for OpenGL Performer
  11. How Does the OpenGL Performer Licensing Work
  12. Do I need license for all of my machines
  13. Can I use my license on any Operating
  14. Where is my license key stored
  15. What is FlexLM
  16. What are the major components of OpenGL Performer
  17. What is the libpf library
  18. What is the libpr library
  19. What is the libfdu library
  20. What is the libpfdb library
  21. What is the libpfui library
  22. What is the libpfx Library
  23. What is the libpfv Library
  24. What is the libpfutil Library
  25. What file format does Performer support
  1. Why Does my Application only Run at only 1-2hz
  2. What is a Pixel Format
  3. What does LOD stand for and What is a LOD
  4. What is a Symmetric Viewing Frustum
  5. What is an ASymmetric Viewing Frustum
  6. What is a Orthographic Viewing Frustum
  7. What are Isectors
  8. What is a Line Segment
  9. What are the Difference between Real-time and Animations
  10. How Can I Convert my 3d Models to an Performer Format
  11. How do I Calculate the Vertical Field of View
  12. How do I Calculate the Horizontal  Field of View
  13. What are "pfb"/ "pfa" files
  14. How do I create a "pfb" or "pfa"
  15. Are "pfb" files backwards compatible
  16. Should I keep my original files after converting to "pfb"
  17. How can I convert my "pfb" to OpenFlight
  18. What are the differences between PFPHASE_FREE / LIMIT / FLOAT / LOCK
  19. What is PFPHASE_FREE_RUN
  20. What is PFPHASE_LIMIT
  21. What is PFPHASE_FLOAT
  22. Whats is PFPHASE_LOCK
  23. Which Rendering Primitives are supported in OpenGL Performer
  24. How can I improve real-time performance
  25. Whats environment variable are there for OpenGL Performer




**   What is OpenGL Performerb


    OpenGL Performer™ is a powerful and comprehensive programming interface for developers creating real-time visual simulation and other performance-oriented 3D graphics applications. It simplifies development of complex applications used for visual simulation, manufacturing, simulation-based design, virtual reality, scientific visualization, interactive entertainment, broadcast video, architectural walk-through, and computer-aided design.

    OpenGL Performer provides the advanced features and innovative techniques that enable you to achieve peak performance and make optimal use of system capabilities and sophisticated 3D gfraphics features. It gives you the capability to scale easily to multiple processors and multiple graphics pipelines, deploy to a wide range of systems and price points, and be ready-made for the graphics systems of today and the future.

    OpenGL Performer is built atop the industry standard OpenGL® graphics library and, includes both ANSI C and C++ bindings. It forms the foundation of a powerful suite of tools and features for creating applications on all Silicon Graphics® systems running IRIX® 6.5 or later, 32-bit Intel® based systems with Linux®, and 32-bit Intel based systems with Microsoft® Windows® 2000 or Windows® XP.

    OpenGL Performer is an integral part of the SGI® Onyx® Series visualization systems and visual workstation simulation solutions from SGI and, in particular, provides interfaces to the advanced features of InfiniteReality® and UltimateVision™ class graphics. OpenGL Performer is the flexible, intuitive, toolkit-based solution for developers who want to optimize performance on SGI systems.


**  What operating systems does Performer Supportb


    OpenGL Performer is currenlty available of the following platforms

    • OpenGL Performer™ 3.x supports:
      • all SGI graphics systems running IRIX 6.5 or later
      • Intel 32-bit Intel systems running Red Hat® Linux® 8.0 and above, and
      • Windows® 2000,Windows XP, and above.
    • OpenGL Performer™ 2.5 supports:
      • all SGI systems running IRIX 6.5 or later,
      • s IA32-based systems with Linux. The Linux version was built and has been tested with Red Hat® Linux® versions 6.1, 6.2, 7.0, 7.1, and 7.2 on a variety of Intel® Pentium® based systems including the Silicon Graphics® 230, Silicon Graphics® 330, and Silicon Graphics® 550 workstations with the VPro™ graphics accelerator


** Does SGI Recommend Any Platforms  b

    SGI does not really recommend platforms per say but they do have system configurations that have pre-qualified and have  tested OpenGL Performer etc.


**  How do I get OpenGL Performerb

    SGI's OpenGL Performer is available for download direclty from SGI's OpenGL Performer home pages.

    • OpenGL Performer 3.x for Irix, Linux and Windows downloads


**  Is OpenGL Performer freeware or Open Sourceb

    Currenlty  OpenGL Performer is not Freeware nore is it Open Source.

    OpenGL Performer is a commercial product whichs means you need to purchase a copy of the software.

    But SGI does provide a free fully working evaluation version. This evaluation version places a large 'Powered By Opengl Performer' logo on the screen, this is removed when the software is fully licensed.

    The lastest versions of the software will be available from the OpenGL Performer downloads pages

** How do I get Support for OpenGL Performerb

    SGI provides Professional technical support for OpenGL Performer, but this has to be purchased, see the SGI support pages

    Free  support can be found on several mailing list and user forums, not that although you can get help on these your not guaranteed to, if you have time and project critical questions I would highly recommend purchasing SGI's technical support


** How to I get a license for OpenGL Performer b

    License for SGI Performer are available only from SGI, you will need to Purchase a copy of OpenGL Performer or have a maintenance contract.

    Purchasing and Ordering details can be found on the SGI Performer pages


* 8  * How can I remove the Performer Logo from the Screenb


    The Performer Logo is displayed on all evaluations of OpenGL Performer. To remove this logo you need to have a valid run-time or developemnt license for Performer OpenGL which will be supplied by SGI when you Purchase a license for OpenGL Performer.


**  What is New In Open GLPerformer 3.1.1b


    The new features and capabilities for Performer 3.1.1 include the:

    • Parametric Curves & Surfaces - New node types have been added corresponding to the opRep class hierarchy of OpenGL Optimizer™. This includes support for 2d & 3d curve & surface types and related classes.
    • The PFB, CSB, and Inventor loaders have been updated to support the new data types. Pseudoloaders exist to modify tessellation parameters at load time. Many other utilities and samples have been added.
    • Subdivision surfaces - The new node type pfSubdivSurface has been added for Loop and Catmull-Clark subdivision surfaces. A subdivision surface is specified by a control mesh consisting of a set of connected faces, usually triangles or quads. The control mesh is stored as a pfMesh.
    • Small object culling - Small object culling is an automatic Level-of-Detail technique which removes objects from the scene whose projected size (in screen space) is less than a user-defined threshold. This can be added in user programs as a Cull Program, and 'perfly' now includes a "Cull Smaller Than" slider in the FOV panel.
    • Clip-Texture Emulation - A new implementation of Clip-Texture emulation has been added. The new emulation mode overcomes most of the limitations of the basic emulation mode, such as texture scintillation and geometry tessellation requirements. This new mode is automatically selected on systems with ARB_fragment_program support. The basic cliptexture emulation mode is selected on all other platforms (except on InfiniteReality, where hardware cliptexture's are used).
    • pfGeoArray : Vertex Array support - The pfGeoArray (short for "Geometry Array") is a new OpenGL Performer data structure aimed at replacing the existing pfGeoSet. GeoArrays allow the user to define new sets of attributes, in addition to the standard vertex coordinates, normals, texture coordinates, or colors. These attributes can be used by vertex or fragment programs applied to the primitives (see pfVertexProgram and pfFragmentProgram). Also, GeoArrays are rendered using vertex arrays and vertex objects making the rendering much more efficient. pfGeoArray can be up to 10 times faster than pfGeoSet.
    • Support for Vertex & Fragment Programs - Vertex programs and Fragment programs are used by the GPU to modify various parameters of each vertex or fragment (pixel), respectively, as they are being rendered. Such programs are a sequence of assembly-like instructions defined by the GL_ARB_vertex_program and GL_ARB_fragment_program extensions to OpenGL. OpenGL Performer 3.1 supports these extensions using the new state elements pfVertexProgram and pfFragmentProgram. In addition, the class pfGProgramParms is used to set changing parameters used by the programs.
    • Maya® Exporter - The Maya Exporter is a plug-in for Maya® 4.5 that exports Maya content to OpenGL Performer PFA and PFB file formats. The exporter currently supports basic geometry and state, as well as polygon meshes, nurbs and subdivision surfaces.
    • CATIA® v4 converter - The "cat2pfb" utility provides a run-time conversion from CATIA v4 format files to Performer PFB. CATIA v4 must be installed to use the converter.


* 10  * Where are the Books for OpenGL Performerb

* 11  * How Does the OpenGL Performer Licensing Workb

    OpenGL Performer 3.1 uses a node-locked, run-time licensing scheme in all versions (IRIX, Linux, and Windows) based upon a FlexLM license key. Both the web download and CD copy of OpenGL Performer includes a demo license key with certain restrictions.

    License keys are available for purchase from SGI. See the  ordering info section of SGI's web site fore more information.

    In addition to run-time licensing, other forms of licensing (OEM licenses, site licenses, etc) are available in certain cases for major accounts.

    See your SGI sales representative for more information.

    • Details about the license in OpenGL Performer 3.1:
    • Purchased licenses are node-locked, run-time licenses. This means one purchased license is valid for one system (e.g. one PC or one SGI host). A cluster of individual systems would require multiple licenses.
    • The (included) demo license allows complete operation of the OpenGL Performer toolkit -- no features are disabled -- but adds a "Powered by OpenGL Performer" logo banner to each frame. Purchased licenses have no such banner.
    • On IRIX and Linux, the license key itself is typically stored in /usr/share/Performer/license.dat. On Windows, typically C:\Program Files\Silicon Graphics\OpenGL Performer\license.dat
    • Licenses are OS-platform specific, e.g. a license for OpenGL Performer for IRIX is not valid for OpenGL Performer for Linux or Windows.
    • Many of the standard FlexLM end-user tools are included with the OpenGL Performer distribution in /usr/share/Performer/bin (%PFROOT%\Bin on Windows)


* 12  * Do I need license for all of my machinesb


    Yes you will need to have a separate license for each machine you need to run OpenGL Performer on.

    In general the SGI only provides Node-Locked licenses for OpenGL Performer although for lager corporate accounts they may provide site and network server license


* 13  * Can I use my license on any Operatingb

    Unfortunately no you cannot do this, as licenses are Operating system platform specific, e.g. a license for OpenGL Performer for IRIX is not valid for OpenGL Performer for Linux or Windows

* 14  * Where is my license key storedb

    • On IRIX and Linux, the license key itself is typically stored in /usr/share/Performer/license.dat.
    • On Windows, typically C:\Program Files\Silicon Graphics\OpenGL Performer\license.dat


* 15  *  What is Flex LM b


    FlexLM licensing is a technology from Globetrotter Software Inc. which SGI  uses to license the OpenGL Performer software.

    License files Keys are available only from SGI

    Note that Globetrotter was acquired by Macrovision  and FlexLM has been sucked into a product called FlexNet Publisher

* 16  * What are the major components of OpenGL Performerb


    OpenGL Performer consists of two main libraries:

      • libpf
      • libpr

    And then has a further six associated support libraries:

      • libpfdu
      • libpfdb
      • libpfui
      • libpfutil
      • libpfx
      • libpfv


* 17  * What is the libpf library b

    The basis of OpenGL Performer is the performance rendering library libpr. Which is a low-level library providing high-speed rendering functions based on pfGeoSets, efficient graphics state control using pfGeoStates, and other application-neutral functions

* 18  * What is the libpr libraryb

    Layered above libpr is libpf, which is a real-time visual simulation environment providing a high-performance multiprocessing database rendering system that takes best advantage of OpenGL symmetric multiprocessing CPU hardware.

    Note that beginning with OpenGL Performer 2.5, libpf and libpr are actually combined into a single file in the installation. However the logical distinction between the two still remains

* 19  *  What is the libfdu libraryb

    Libpfdu is the database utility library which provides functions for defining both geometric and appearance attributes of three-dimensional objects, encourages sharing of state and materials, and generates efficient triangle strips from independent polygonal input

* 20  * What is the libpfdb library b

    libpfdb the database library uses the facilities of libpfdu, libpf, and libpr to import database files in many  industry standard database formats.

* 21  * What is the libpfui libraryb

    The libpfui library contains user interface building blocks for creating manipulators and user-interface components common to many interactive applications. This library has both a C and C++ API and is OpenGL GL/OpenGL independent.


* 22  *  What is the libpfx Libraryb

    libpfx is new to OpenGL Perform 3.1.x, this is a experimental viewer class library,  libpfx supposed to provide an  easy to use interface for creating basic OpenGL Performer applications (Similar to the excellent Vega Lynx and Lynx Prime from MultiGen-Paradigm).

* 23  * What is the libpfv Library b


    The libpfv library provides a modular viewer providing a high-level infrastructure for rapid construction and extension of OpenGL Performer applications. It ships with an extensible collection of modules for display control, model manipulation, navigation, picking, and other customization.

* 24  *  What is the libpfutil Libraryb


    The libpfutil library is the OpenGL Performer utility library. It provides a collection of convenience routines implementing tasks such as smoke effects, MultiChannel Option support, graphical user interface tools, X and OpenGL GL event collection and management, and traversal functions

* 25  * What file format does Performer support b

    Out the box OpenGL Performer supports the following file formats:( Check the documentation for the latest details)





































    MultiGen OpenFlight v14 and above

    OpenGL Performer ASCII format

    OpenGL Performer fast binary format

    AutoDesk AutoCAD ASCII format

    AutoDesk 3DStudio binary data

    Wavefront Technologies data format

    Coryphaeus Software Designer's Workbench

    Lightscape radiosity solutions (ASCII)

    Lightscape radiosity solutions (binary)

    Minor SGI format used by powerflip

    Side Effects Software PRISMS binary

    Brigham Young University CAD/FEA data

    McDonnell-Douglas GDS things data

    Minor SGI format (radiosity output)

    Minor SGI format (OpenGL Performer example)

    AAI/Graphicon Interactive Real-Time PHIGS

    SGI Open Inventor/VRML 1.0

    University of Washington mesh data

    Medit Productions medit modeling tool

    Eric Haines' ray tracing test data format

    Minor SGI format (example gridded terrain loader)

    Minor SGI format (polyhedra)

    Side Effects Software PRISMS ASCII data

    University of Washington point data

    Minor SGI format (OpenGL Performer example)

    U.S. Army SIMNET databases (Texas Instruments)

    U.S. Navy standard graphics format

    Minor SGI format

    U.S. Navy simple polygon format

    Sierpinski sponge 3D fractal generator

    Yale University compact star chart data

    3D Structures Stereolithography (ASCII)

    3D Structures Stereolithography (binary)

    Format of John Kichury's i3dm modeler

    University of Minnesota Geometry Center data

    University of North Carolina data

* 26  *  Why Does my Application only Run at only 1-2hzb

    There can be many reasons that your simulation/application can be running at only 1-2 Hz or less.

    Typically this indicates that you may have dropped in to software rendering mode on your graphics card. This can happen when you set-up up Opengl and request your pixel format for the Opengl Window. Normally it means you have asked for a format or a setting that the card cannot support or does not support. I say cannot support as it may be that the resources of that card are limited when you request the pixel format, such as your resolution is too big for a 32bit z buffer, another Opengl has already consumed most of the resources etc. Or your requesting a setting not supported by your graphics card, you can find the formats supported by your cards with the following 

    On Irix you can use findvis on the command line to display the available bit plane configurations supported on the Irix system

    On Windows you can use a program from Nvidia to show the available bit plane configurations

    Then it might be a case you are trying to

    • display too much,
    • too many polygons
    • high screen resolutions
    • too many textures.
    • textures too big ( > 512,x512) ( for real-time try to stick below 512x512
    • Too many state changes
    • You Application is too complication making you CPU bound et
    • Your IO bound
    • Etc

    In this case you have to try and simply your application, reduce the data, reduce the applications work load, get fast machine, maybe use a multi-process machine, get better graphics, reduce your resolution etc


* 27  *  What is a Pixel Formatb

    Each Opengl window uses a frame buffer, which is a collection of bit plane's storing the information about each pixel. The organization of these bit plane's defines the quality of the rendered images and is known as a Pixel Format.

    Pixel formats are made up from different Bit plane's which allocate for features such as:

      • colour information (RGB)
      • Alpha (transparency)
      • depth buffer(Z-bits)
      • Samples
      • Accumulation RGB Buffer
      • Accumulation Alpha Buffer
      • Stencil
      • Buffer Mode (Single/Double(default))


    Note that support for the various pixel format  configurations and combinations are not uniform across different Windows Graphics cards, Linux Systems and  Irix systems.

    Vega will ask the system for a bit plane specification supplied through the Lynx Windows panel settings or through code, the request may not be granted. When the notification level (in Systems panel) is set to Info or higher, messages tell the user which bit plane configuration is actually being used

    There are generally two methods of specifying bit plane configuration.

    • The first is to request individual assignments in each bit plane category by selecting values for a collection of option menus
    • The second method is to specify the value of the OpenGL Pixel Format  that contains a configuration acceptable to your application

    On Irix you can use findvis on the command line to display the available bit plane configurations supported on the Irix system

    On Windows you can use a program from Nvidia to show the available bit plane configurations

    Color RGB
    Specifies the given number of bits for each of the Red, Green, and Blue components of each picture element. Larger values take longer to clear, and this may impact performance. Larger values per R,G,B produce smoother images because more colors are available. Vega runs in RGB or RGBA mode, not color index mode. 

    Some systems have storage of a fourth component, called alpha. This is used for transparency blending and storage of transparency values. It is possible to do some transparency methods without alpha planes. Alpha planes are required for any transparency method which requires that the current transparency level of a pixel be stored for later use.

    Depth Buffer Z Bits
    Depth information is stored in a Z-buffer. Larger numbers of bits allocated for the Z-buffer improve depth calculations and reduce "Z fighting". This effect occurs when the distance between two surfaces cannot be resolved within the numeric resolution. The image then flickers between the two surfaces. The near and far clipping plane distances also influence how the Z-bits store the depth information

    Some systems, support multi-sampling. This technique allows each screen pixel to be resolved from a set of pixel fragments rendered at a higher resolution. This allows smoother, less jagged, images to be rendered. These images are referred to as anti-aliased. Aliasing is an artifact of digital sampling. The higher the number of samples for multi-sampling are supplied, the higher the quality of the images. The number of multi-samples available on a system is influenced by the resolution to which the display is set. On windows system this may need to be set at the graphics driver level first.

    The Stencil defines the number of bit plane's allocated for the stencil buffer. The statistics screen describing the fill rate of an application requires that there be at least 4 stencil planes allocated for the window's visual.

    Species the number for red, green, and blue bits for an accumulation buffer, and also a number for alpha planes in the accumulation buffer. Some machines have hardware storage for accumulation buffers.


* 28  *  What does LOD stand for and What is a LODb

    LOD is an acronym for Level Of Detail (LOD)

    Basically the idea behind LOD processing is that objects which are barely visible don’t require a great amount of detail to be shown in order to be recognizable.

    Object are typically barely visible either because they are located a great distance from the eye point or because atmospheric conditions are obscuring visibility.

    Both atmospheric effects and the visual effect of perspective minimize the importance of objects at ever increasing ranges from the current observers eye point. The effect is that the perspective foreshortening of objects, which makes them appear to shrink in size as they recede into the distance.

    To improve performance and to save rendering time, objects that are visually less important in a frame can be rendered with less detail.

    The LOD approach optimizes the display of complex objects by constructing a number of progressively simpler versions of an object and selecting one of them for display as a function of range.

    An undesirable effect called popping occurs when the sudden transition from one LOD to the next LOD is visually noticeable.

    To remedy this SGI graphics platforms offer a feature known as Fade Level of Detail that smoothes the transition between LOD's by allowing two adjacent levels of detail to be sub-sample blended. This is now supported by most Scenegraphs, as long as there graphics support multi-sampling

    Here's a link to a Practical overview of an LOD 


* 29  * What is a Symmetric Viewing Frustum b


    The Symmetric frustum defines the perspective projection applied to all scene elements processed for a channel. The near clipping distance is used to form a plane called the near clipping plane. The far distance defines the far clipping plane.

    For the symmetric frustum, both these planes are perpendicular to the line of sight of the viewer. The horizontal and vertical FOV's (fields of view) determine the radial extent of the view into the scene. FOV's are entered as degrees for the full width of the view desired. Entering a -1 for either but not both FOV causes the system to aspect match that FOV axis.

    For example suppose the horizontal FOV is 45 degrees and the vertical is set to -1. Once the window and channel are sized, the system selects the appropriate FOV degree for the vertical FOV to maintain an aspect ratio equal to that of the channel viewport.

    See vpChannel and the Vega Prime Programmers Guide for further details.


* 30  * What is a Symmetric Viewing Frustum b

    An Asymmetric frustum or oblique projection is similar to the symmetric projection, except that the line connecting the center of the near face of the frustum with the eyepoint is not perpendicular to the near plane. That is, the line of sight is off-axis. This is useful for creating video walls, or matching the visual system to a specific video projection system, like a dome where the projection device is off axis to the screen.

    This type of perspective frustum requires six values to define it. Clicking on the Asymmetric Frustum option displays the six entry fields. The near and far values are the same as the symmetrical frustum.

    The left, right, bottom, and top values define the side planes of the frustum. They are the angle offset in degrees for the plane they represent.

    See vpChannel and the Vega Prime Programmers Guide for further details.

        Asymmetric frustum


    Also see the following Viewing Frustum Overview Image


* 31  *  What is a Orthographic  Viewing Frustum b

    The Orthographic projection is a non-perspective projection. This means objects appear to be the same size no matter what their distance is from the viewer. Generally used for a Map view or Hud overlay view

    The sides of the frustum are parallel to the line of sight of the viewer. The Near and Far distances define the near and far clipping planes.

    The Left, Right, Bottom, and Top values define the frustum side planes. These values bear a direct relationship to the scale of the object being viewed.

    See vpChannel and the Vega Prime Programmers Guide for further details.

    Also see the following Viewing Frustum Overview Image


* 32  *  What are Isectorsb


    Isectors provide the ability to handle collision detection between objects within a Scenegraphs and are an essential part of most visual simulations

    For example, a typical need is to obtain the current Height Above Terrain (HAT) information in a flight simulator or a driving simulator is determined by firing a vertical line segment from the aircraft or vehicle towards the terrain/ground and calculating the distance between the aircraft or vehicle and the intersection point on the ground.

    Another example is the use of an Isector to pick or selecthings in the scene, this is typically done using an Line of Site (LOS) isector


* 33  *  What is a Line Segmentb

    Generally in a line segment is talked about and used as part of an Isector which is used for collision detection.

    A line segment in this case is defined by 2 XYZ vectors a Begin and an End position. A vpIsector class such as vpIsectorLOS will position and orientate the line segment.

    Basically speaking  the Isector will traverse its target scene graph and test a nodes bounding spheres against the Line segments. If no intersection is found then the node and all the nodes children are a rejected, this allows for fast collision detection.

    If an intersection hit is encountered with the bounding sphere the test can them become more fine grained test of each child node for an intersection until the leaf geometry node is reached, then data on the collisions detected can be stored such as pointers to node, position of intersection, the normal perpendicular to the intersection etc. (This is of course an oversimplification of a more complicated process)


* 34  * What are the Difference between Real-time and Animation Applications b


    Animations are typically used for films, high resolution renderings, images for print, and pre-programmed demonstrations.

    Real-time applications are used in application where responding to user input is part of  the simulation, for example, during flight training and interactive architectural  demonstrations. Both real-time and animation applications simulate real and imaginary worlds with highly detailed models, produce smooth continuous movement, and render at a certain number of frames per second .

    Some of the main differences are: 

    • Real-time application frames are rendered in real time, which means the frames are continuously recalculated and rendered as the user changes direction and chooses where to move through the scene to view
    • Animation frames are pre-rendered, which means the animator sets the order of the frames and chooses the parts of the scene to view. Each frame can take hours to render
    • Real-time applications are highly interactive, and the user controls the movement of objects within the scene; animations do not allow for human interaction, and the user is a passive  participant 
    • The typical emphases of real-time applications are interactivity and purpose. Models in real-time applications typically have less detail than models that are used in animations to increase the rendering speed and shorten the latency period, which is the time delay from user input until the application makes an appropriate response. To achieve realistic real-time simulations, the latency period must be too short for the user to perceive
    • The emphases of animations are almost always non-interactive aesthetics and visual effects. Models in animations usually have much more details; mainly because the use of frames that pre-rendered ( which can take hours or days), the effect on drawing speed can be pre-determined
    • Real-time applications typically are displayed at various frame rates, which range typically require rate off 60 frames per second, this may change depending on application goals and screen complexity
    • While animations based applications usually display at standard 24 frames per second for every pre-rendered sequence of images ( which can take hours per frame compared 16.666 milliseconds for real-time at 60hz)



* 35  *  How Can I Convert my 3d Models to an Performer Formatb


    This would depend on what format your source models are in.

    Typically you should  be able to use a format conversion program such as Polytrans or Deep Exploration. These offer a good selection of import formats and the ability to output OpenFlight models.

* 36  *  How do I Calculate the Vertical Field of Viewb


    Here's one way that you could do this is along the following lines:

Formula :


    aspect_ratio = channel_width / channel_height

    width = tan ( horizontal_fov / 2.0 ) * 2.0 * near_clip

    height = width / aspect_ratio

    vertical_fov =  2.0 * atan(  height / ( 2.0 * near_clip  ))




* 37  *  How do I Calculate the Horizontal  Field of Viewb


    Here's one way that you could do this is along the following lines:


Formula :


    aspect_ratio  =  channel_height / channel_width

    height = tan ( vert_fov / 2.0 ) * 2.0 * near_clip

    width = height / aspect_ratio

    horizontal_fov =  2.0 * atan( width / ( 2.0 * near_clip  ))




* 38  *  What are "pfb"/ "pfa" filesb


    "pfb" and "pfa" are database file formats provided with OpenGL Performer. Performer provides both loaders and writers for this format

    "pfb", is binary database format, this is basically a binary dump of the scene-graph of a model or node, it is extremely fast to load this..

    The general practice is to convert you 3d models to pfb for your finished application

    "pfa" is an ASCII text format which is human readable, this is very slow loading and is generally used for debugging purposes

* 39  *  How do I create a "pfb" or "pfa"b


    "pfb" and "pfa" can be created using the pfconv tool or through code using pfdStoreFile, any file that OpenGL Performer can load can be converted to the "pfb" or "pfa" formats.

    The source for pfConv is provided with the OpenGL Performer on Windows can be found C:\Program Files\Silicon Graphics\OpenGL Performer\Src\conv.

* 40  *  Are "pfb" files backwards compatibleb

    Due to the binary nature of the "pfb" the files they can easily be come none compatible with newer versions of OpenGL Performer, requiring for the "pfb" files to be re-generated

* 41  *  Should I keep my original files after converting to "pfb"b

     Yes you should keep you original model sources files you used to create your "pfb" files. Due to the binary nature of the "pfb" the files, they  can easily be come none compatible with newer versions of OpenGL Performer, requiring for the "pfb" files to be re-generated

* 42  * How can I convert my "pfb" to OpenFlight b


    Currently there is no easy method to convert "pfb" files to MultiGen OpenFlight format. Generally OpenGL Performer files loading and writing is done through a plugin loader/save method and uses pfdLoadFile and pfdStoreFile respectively. Currently only the loader is defined for the OpenFlight format.

    As the OpenFlight format is a publicly published format then one could write there own pfdStoreFile writer. The MultiGen OpenFlight format specification can be found here.

* 43  *    What'sthe differences between PFPHASE_FREE / LIMIT/FLOAT / LOCK b


    Rendering images at a consistent chosen frame rate. Fixed frame rates are a central theme of visual simulation and are supported in OpenGL Performer using the PFPHASE_LOCK and PFPHASE_FLOAT modes.

    PFPHASE_FREE_RUN and PFPHASE_LIMIT maintain full synchronization among App Cull and Draw. This means that every App frame has the  corresponding Cull and Draw frames. Theses phases are useful for simple graphic programs.

    PFPHASE_FLOAT and PFPHASE_LOCK let Cull miss App frames, and let Draw miss Cull frames. This means that if Cull is too slow, App may produce more than a single frame before Cull is ready. Cull always takes the latest ready frame and skips all previous ones.

    Similarly, Cull may produce more than a single frame before Draw is ready. Draw always picks the latest ready frame from Cull and skips all previous ones. These phases reduce the latency between the latest App frame to the rendered Draw frame.

* 44  *  What is PFPHASE_FREE_RUNb

    wakes the App and Draw processes up on the next video field boundary after the Draw process finishes. It's the OpenGL Performer version of the usual run as-fast-as-I-can or as-slow-as-I-must mode that most simple graphics programs use.

* 45  *  What is PFPHASE_LIMITb

    wakes the App and Draw processes up on the next video field boundary after the Draw process finishes, but no earlier than the requested frame rate. It is very similar to PFPHASE_FREE_RUN, but never runs faster than the requested frame rate. It is useful for programs that run at a steady frame rate but have a few quick frames.

*  46  * What is PFPHASE_FLOAT b

    wakes the App up only on frame boundaries, i.e., time = n*(1/frame_rate). However, the Draw process "floats" with respect to the frame rate, wakes up on the next possible field boundary, and then calls swapbuffers() when it's done, regardless of whether it finished Drawing in time for the desired frame rate. Hence you see every frame that's Drawn to the backbuffer, but it may not Appear at exactly the time for which it was planned. If you never frame extend, it behaves like PFPHASE_LOCK.


* 47  *  Whats is PFPHASE_LOCKb

    PFPHASE_LOCK wakes the App and Draw up only on frame boundaries and only swaps on frame boundaries. The advantage is that each new image always Appears at precisely the time for which it was rendered. The disadvantage is that if the Draw process runs even slightly over a frame time, you skip that entire frame and are stuck with an outdated picture for an entire frame.


* 48  *  Which Rendering Primitives are supported in OpenGL Performerb

    OpengGL Performer currently supports the following primitives( see pfGeoSet man pages for upto date information)

      • Points (PFGS_POINTS)
      • Independent line segments (PFGS_LINES)
      • Connected line strips (PFGS_LINESTRIPS)
      • Flat connected line strips (PFGS_FLAT_LINESTRIPS)
      • Independent triangles (PFGS_TRIS)
      • Independent quadrilaterals (PFGS_QUADS)
      • Connected triangle strips (PFGS_TRISTRIPS)
      • Flat connected triangle strips (PFGS_FLAT_TRISTRIPS)
      • Connected triangle fans (PFGS_TRIFANS)
      • Flat connected triangle fans (PFGS_FLAT_TRIFANS)
      • Independent n-sided polygons (PFGS_POLYS)


* 49  *  How can I improve real-time performance b

    Some  things that you can do to be able to get the best performance out of your real-time 3D simulation include:


    • On Windows run as administrator
    • On Unix systems such as Irix or Linux run as Root
    • If you cannot run as root then use  account with root privileges for your application
    • Run Full screen and border less, windowed application are slower than full screen
    • Run only one Window per pipe, use multiple channels rather than multiple window
    • On Multiprocessor System lock processes to a process and give them non-degrading priorities
    • Only run your application
    • Don't run multiple graphics program on the same pipe graphics context switching is expensive
    • Run the release build of the application
    • Close all none essential services or program
    • Close any clocks, gr_osview, or other tools that may wake up and draw themselves
    • Close any messenger servers such as MSN or Yahoo
    • Close your virus checker ( or at least exclude the files in you Sim from the scan)
    • When multiprocessing, make sure the executable is on a local file system.
    • Store data on local file system if possible rather than network drives
    • Convert you models to a fast loading binary format such as pfb, vsb or fst etc.
    • Convert your textures to DDS available
    • Preload you texture if possible
    • Preload your models if possible
    • Reduce the ratios for the near and far clip plane use
    • Avoid sub-facing or decals, cut them in polygons are cheaper to draw
    • Keep textures to a power of 2
    • Keep texture size as small as possible
    • Don't exceed 512x512 for texture size currently cards struggle to move larger sizes
    • Combine textures together if possible 1 512x512 is better than 20 32x32 images
    • Keep the number LOD nodes to a minimum ( for APP/CPU bound applications )
    • Keep the number DCS/DOF nodes to minimum ( for APP/CPU bound applications )
    • Do flatten and clean you models (pre process to a fast binary format)
    • In your 3d models create a deep hierarchy rather than a flat
    • Make sure you models contain no no-planar or co-plane polygons
    • Use textures for detail rather than polygons
    • Add system memory the more the better 1gb min 2gb better more is great (memory is cheap)
    • Graphics memory get the best card you can 256mb min
    • Get a good CPU
    • Multiples CPU for Vega/Vega Prime and Performer really improves and shows there prowess
    • Use fast and local hard drive
    • Defrag your hard drives
    • Make sure you have the latest graphics driver ( although some times you may need to step back versions)
    • Turn Sync to Vertical retrace off on your card (if on you can only run as fast as the vertical retrace)
    • Avoid using glReadPixels as frame buffer reads are typically an expensive operation
    • Disable C++ exceptions in your compiler this could get your a 15% improvement
    • Try to keep the FOV small and the far clip as close as possible
    • Keep the number of Light sources to a minimum
    • Try to avoid deleting large time many times, if possible remove form the scene and keep in memory if need again or use a deferred
    • deletion scheme
    • For very large area databases you as mechanism such as LADBM and Virtual/Clip texturing
    • Avoid IO ( printf , cout etc ) were possible on windows create a non-console as  its expensive
    • Try to share material and colour state were ever possible ( Pre-process and again save in a fast binary format)
    • Try to use create geometry that can use triangle strips or meshes ( Pre-process and again save in a fast binary format)
      Make sure you are not generating any floating-point exceptions in your code
    • Put only latency-critical tasks between the applications AppSync() and drawFrame() calls
    • See you run-time API documentation for specific things you can do to improve performance with that API
    • Keep to a mimimun the use of Isectors each frame, these are quite expensive


* 50  *  Whats environment variable are there for OpenGL Performerb


    • PFPATH A colon separated list of directories in which to find Performer data files:
    • PFLD_LIBRARY_PATH and PFLD_LIBRARY{N32,64}_PATH A colon separated list of additional directories in which to find database loaders. These directories are searched before LD_LIBRARY_PATH.
    • PFNFYLEVEL The maximum allowed of OpenGL Performerprint message.
      • 1-FATAL,
      • 2-WARN,
      • 3-NOTICE,
      • 4-INFO,
      • 5-DEBUG,
      • 6-FP_DEBUG,
      • 100( uhhmm)
    • PFROOT Specifies an alternate installation 'root' for Performer files, to allow multiple versions of Performer to be installed on the same system. Use this any time you install Performer to a location other than the root(/).
    • PFSHAREDSIZE The size (in bytes) of the shared memory arena to create. This size will override any size specified with the pfSharedArenaSize function.
    • PFSHAREDBASE The address at which to place the shared memory arena. The address specified with this environment variable will override the address specified with pfSharedArenaBase.
    • _PF_FORCE_MULTIPROCESS The value of this environment variable (interpreted as an integer) overrides the parameter setting of the call to pfMultiprocess. This is useful for changing the multi-processing mode of an executable without a recompile. See man pfMultiprocess for details about parameter values.
    • PF_LPOINT_BOARD Pretend there is a calligraphic light point board for calligraphic debugging.
    • PFXDEBUG Turns on X Synchr onization for debugging. Very slow, but helpful if you are exiting with X Errors. Setenv PFXDEBUG 1, dbx the program, breakpoint in exit, run, look at stack trace when stopped.
    • PFMACHTYPE Force the gfx machine type to be the give token for debugging. Uses the values from /usr/include/sys/invent.h. (IRIX only)
    • PFASDLODSIZE Set the number of LODs to be constructed in pfASD using routines in pfdBuildASD.c. In general, a value less than 8 runs a lot faster and uses much less space than any value beyond 8 
    • PFTMPDIR sets the temporary directory location 
    • PFMEMDEBUG This variable sets up the trace on pfMemory
      • PFVIDEORATE Allows the video rate calculation logic tobe overridden with a user-specified value. Use with caution.
      • PFARENADEBUG This variable sets up tracing on shared arena creation & usage. Set to 1 for basic output, 2 for exhaustive output. (Linux only).
      • PFCULLSPINCOUNT If DRAW has finished previous frame, wait for DRAW to grab most recent buffer before updating it. This avoids hairy edge problems when the CULL is short and the DRAW wakes up just after the CULL has finished a new buffer.
      • PF_NO_FATAL_MESSAGEBOX On the Windows operating system, the default behavior of pfNotify when displaying a fatal error is to pop up an error message box. If this variable is set, the message box will not be displayed 
    • __PFTYPEMAGIC Allows changing the value used to detect a pfType header. Under typical operation, this should not be changed. This should be set to a hexadecimal string (e.g. 0xa25d2830b) if pfMemory::getMemory errors are occuring.
    • PF_MAX_ANISOTROPY an anisotropic filter of the value specified by PF_MAX_ANISOTROPY will be applied to pfTextures that do not set the degree of anisotropy. This is only valid for graphics hardware that support anisotropic texture filtering.
    • PF_ENABLE_MULTISAMPLE_VISUAL On Irix, Performer will try to ask for a multisample visual by default. On the commodity graphics cards that are often used under Linux, a multisample visual, if available, will cause a significant performance penalty. Therefore, under Linux, Performer does not ask for a multisample visual by default. If this environment variable is set under Linux, Performer will ask for a multisample visual.
    • _PF_NODE_FIND_REQUIRES_EXACT_TYPE This environment variable can be used to revert the behavior of pfNode::find (also called from within pfNodeLookup) to what it was before being fixed for pf3.0.1. The old behavior would carry out an exact type comparison (pfIsExactType) instead of using pfIsOfType as suggested by the manpages.
    • PF_FORCE_GUI_REDRAW This environment variable forces redraw of the gui created using libpfutil, used in perfly, for example. The gui disappears under windows on some graphics hardware and setting this environment variable fixes the problem.
    • PF_USE_VERTEX_BUFFER_OBJECTS By default pfGeoArrays try to use vertex buffer objects. By setting this environment variable to 0, Performer tries to use ATI's vertex array objects, if possible.
    • PF_MATERIAL_COLOR_COMPARE When pfGeoStates are optimized for single global gstate pfMaterials of all pfGeoStates are compared and collapsed into fewer pfMaterials, if possible. In Performer 3.0 and older, it was assumed that colors are used to change material diffuse and ambient color when color material is on. Thus those colors were ignored when comparing materials. Starting with Performer 3.1 all colors are used to compare pfMaterials because on newer hardware it is not advantageous to use color material mode. You can enable the old approach by setting this environment variable to 0.
    • _PF_KILL_XINPUT_PROC_ON_EXIT This environment variable can be set in order to override the default mechanism used by Performer for terminating the X-input-collection process fork'ed off by libpfutil, on exiting. The default behavior is to use signalling (ie the X-input process is notified of the death of its parent process and itself exits); However, this can cause system-hangs on RH9 SMP kernels, so an alternative method has been implemented, which consists in explicitely kill-ing the input process from the APP process prior to exit-ing. On SMP Linux kernels with version 2.4.20 or greater, this alternative method is selected by default. Note that this env variable can be set to 0 in order to force the signalling method, or set to 1 in order to force the explicit-kill method on any IRIX or Linux system. This environment variable has no effect on WIN32.
    • PF_CATCH_SIGINT_AND_EXIT This environment variable can be set in order to instruct Performer to intercept the SIGINT signal (received when user presses <ctrl>C on the shell) and to exit cleanly by calling pfExit. This prevents system freezes on Linux RH9 SMP kernels. By default, SIGINT will be intercepted on SMP Linux kernels with version 2.4.20 or greater. Setting this environment variable to 0 or 1 will override the default behavior on any IRIX and Linux systems. This environment variable has no effect on WIN32
    • PF_LOADER_FORCE_TESS This environment variable, when set, informs the pfb and csb loaders to tessellate the incoming geometry. When doing so it will use the default value for tessellating surfaces (0.0001) unless specified otherwise via the PF_DEFAULT_TESS_VALUE environment variable. In addition, one can use the ctol and ttol pseudo-loaders to gain finer control over the tessellation parameters and also control whether or not existing geometry should be retesssellated at load time. For more information consult the Programming Guide.
    • PF_NO_UNCOMPRESSED_TEXTURE By default, the graphics driver on Onyx 4 keeps both compressed and uncompressed copy of each texture. This requires addressing of more memory and it is easy to run out of address space in a 32-bit multi-pipe application. The driver can be forced not to keep the uncompressed copy of each texture and Performer does that. On the other hand, not having the uncompressed copy may cause problems when getImage is called. Thus the user can request the allocation of memory for an uncompressed version of each texture by setting the envi- ronment variable PF_NO_UNCOMPRESSED_TEXTURE to 0.





© Copyright 2003-2006 Gordon Tomlinson  All Rights Reserved.

All logos, trademarks and copyrights in this site are property of their respective owner.