|
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
|
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.
|
2
What operating systems does Performer Support
|
|
3
Does SGI Recommend Any Platforms
|
SGI does not really recommend platforms per say but they do have system configurations that have pre-qualified and have tested OpenGL Performer etc.
|
4
How do I get OpenGL Performer
|
|
5
Is OpenGL Performer freeware or Open Source
|
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
|
6
How do I get Support for OpenGL Performer
|
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
|
7
How to I get a license for OpenGL Performer
|
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 Screen
|
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.
|
9
What is New In Open GLPerformer 3.1.1
|
|
10
Where are the Books for OpenGL Performer
|
SGI stopped shipping the printed documention for SGI Performer quite a while ago, like many niech market products manual are very expenisve to print, as such SGI provide the documents in PDF and HTML form and these can be found here
Hard copies can also be ordered directly from SGI see ordering info
|
11
How Does the OpenGL Performer Licensing Work
|
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 machines
|
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 Operating
|
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 stored
|
- 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
|
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 Performer
|
OpenGL Performer consists of two main libraries:
And then has a further six associated support libraries:
- libpfdu
- libpfdb
- libpfui
- libpfutil
- libpfx
- libpfv
|
17
What is the libpf library
|
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 library
|
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 library
|
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
|
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 library
|
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 Library
|
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
|
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 Library
|
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
|
Out the box OpenGL Performer supports the following file formats:( Check the documentation for the latest details)
flt
pfa
pfb
dxf
3ds
obj
dwb
lsa
lsb
bin
bpoly
byu
gds
gfo
im
irtp
iv
m
medit
nff
post
phd
poly
pts
ptu
s1k
sgf
sgo
spf
sponge
star
stla
stlb
sv
tri
unc
|
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-2hz
|
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 Format
|
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
http://developer.nvidia.com/object/nvpixelformat.html
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.
Alpha 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
Samples 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.
Stencil 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.
Accumulation 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 LOD
|
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
|
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
|
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.
Also see the following Viewing Frustum Overview Image
|
31
What is a Orthographic Viewing Frustum
|
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 Isectors
|
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 Segment
|
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
|
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 Format
|
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 View
|
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 View
|
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" files
|
"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"
|
"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 compatible
|
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"
|
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
|
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
|
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_RUN
|
PFPHASE_FREE_RUN 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_LIMIT
|
PFPHASE_LIMIT 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
|
PFPHASE_FLOAT 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_LOCK
|
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 Performer
|
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
|
|
50
Whats environment variable are there for OpenGL Performer
|
- 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,
- 7-INTERNAL_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
usage.
- 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.
|