Glossary
Prev |  | Next

## Glossary

alias

  An alternate extension for a file type as processed by the pfdLoadFile() utility. For example, VRML “`.wrl`” files are in a sense an alias for Open Inventor “`.iv`” files since the Open Inventor loader can read VRML files as well. Once the alias is established, files with alternate extensions will be loaded by the designated loader.

application buffer

  The main (and usually only) buffer of `libpf` data structures such as the nodes in the scene graph. Alternate buffers may be created and data can be constructed in these new buffers from parallel processes to support high-performance asynchronous database paging during real-time simulation.

arena

  An area (allocation area) from which shared memory is allocated. Usually the arena is the default one created by pfInit() or pfInitArenas(), but some objects (for example, those in `libpr`) may be created in any arena returned by acreate(). OpenGL Performer calls that accept an arena pointer as an argument can also accept the NULL pointer, indicating that the memory should be allocated from the heap. See also heap.

asynchronous database paging

  Asynchronous database paging, an advanced method of scene-graph creation, allows desired data to be read from a disk or network connection and OpenGL Performer internal data structures to be built for this data using one or more processes running on separate CPUs rather than performing these tasks in the application process. Once the data structures are created in these database processes, they must be explicitly merged into the application buffer.

attribute binding

  The binding of an attribute specifies how often an attribute is specified and the scope of each specification. For example, given a collection of triangles for rendering, a color can be specified with each vertex of each triangle, with each triangle, or once for the entire collection of triangles.

base geometry

  The object with the lowest visual priority in a pfLayer node's list of children. This would be the runway, for example, in a runway and stripes airport database example. See also layer geometry.

bezel

  The beveled border region surrounding any item, but most notably, around the edge of a CRT monitor.

billboard

  Geometry that rotates to follow the eyepoint. This is often simply a single texture-mapped quadrilateral used to represent an object that has roughly cylindrical or spherical symmetry, such as a tree or a puff of smoke, respectively. OpenGL Performer supports billboards that can rotate about an axis for cylindrical objects or a point for spherical objects.

binning

  The action of the sort phase of `libpf`'s cull traversal that segregates drawable geometry into major sections (such as opaque and transparent) before the per-bin sorting based on the contents of associated pfGeoStates so that state changes can be reduced by drawing groups of similar geometry sequentially while still drawing semitransparent objects in the desired order within the frame.

bins

  The unique collections into which the cull traversal segregates drawable geometry. The number of bins is defined by calls to pfChanBinSort() and pfChanBinOrder(). Typical bins are those for opaque and transparent geometry, where opaque objects are rendered first for superior image quality when using blended transparency.

blur margin

  A parameterized value used to control blurring and flickering of textures.

bounding volume

  A convex region that encompasses a geometric object or a collection of such objects. OpenGL Performer pfGeoSets have axis-aligned bounding boxes, which are rectangular boxes whose faces are along the X, Y, or Z axes. Each OpenGL Performer pfGeode has a bounding sphere that contains the bounding box of each pfGeoSet in the pfGeode. OpenGL Performer group nodes have hierarchical bounding spheres that contain (bound) the geometry in their descendent nodes. The purpose of bounding volumes is to allow a quick test of a region for being off-screen or out of range of intersection search vectors.

buffer scope

  All OpenGL Performer nodes are created in a pfBuffer, either the primary application buffer or in an alternate returned by pfNewBuffer(). Only one pfBuffer is considered “current,” and this buffer can be selected using pfSelectBuffer(). All new nodes are created in the current pfBuffer and will be visible only in the current buffer until that pfBuffer is merged into the application buffer using pfMergeBuffer(). A process cannot access nodes that do not have scope in its current buffer except through the special “buffer” commands: pfBufferAddChild(), pfBufferRemoveChild(), and pfBufferClone(). Thus, they are said to have buffer scope.

channel

  A visual channel specifies how a geometric scene should be rendered to the display device. This includes the viewport area on the screen as well as the location, orientation, and field of view associated with the viewer or camera.

channel group

  A set of channels that share attributes such as the eyepoint or callbacks. When a shared attribute is set on any member of the group, all members get the new value. Channel groups are most commonly used for adjacent displays making up a panorama.

channel share mask

  A bit mask indicating the attributes that are shared by all channels in a channel group. Typical shared attributes are field of view, view specification, near and far clipping distances, the scene to be drawn, stress parameters, level of detail parameters, the earth/sky model, and swapbuffer timing.

children

  OpenGL Performer's hierarchical scene graph of pfNodes has internal nodes derived from the pfGroup class, and each node attached below a pfGroup type node is known as a child of that node. The complete list of child nodes are collectively termed the children of that node.

class hierarchy

  The source through which OpenGL Performer classes are defined. This class hierarchy defines the data elements and member functions of these data types through the notion of class inheritance.

class inheritance

  Class inheritance describes the process of defining one object as a special version of another. For example, a pfSwitch node is a special version of a pfGroup node in that it has control information about which children are active for drawing or intersection. In all other respects, a pfSwitch has the same capabilities as a pfGroup, and the OpenGL Performer API supports this notion directly in both the C and C++ API by allowing a pfSwitch node to be used wherever a pfGroup is called for in a function argument. This same flexibility is supported for all derived types.

clipped

  Geometry is said to be clipped when some or all of its geometric extent crosses one or more clipping planes and the portion of the geometry beyond the clipping plane is mathematically trimmed and discarded.

clipping planes

  The normal clipping planes are those that define the viewing frustum. These are the left, right, top, bottom, near, and far clipping planes. All rendered geometry is clipped to the intersection of the half-spaces defined by these planes and only the portion inside all six is displayed by the graphics hardware.

clip texture

  This entity virtualizes MIPmapped textures using hardware and software support so that only the texels in the region close to the viewer (known as the clipped region) need to be loaded in texture memory. Also known as ClipMaP.

cloned instancing

  The style of instancing that creates a (possibly partial) copy of a node hierarchy rather than simply making a reference to the parent node. This allows pfDCS nodes and other internal nodes to be changed in the copy without changing those in the original. Also see shared instancing.

cloning

  Making a copy of a data structure recursively copying down to some specified level. In OpenGL Performer pfCopy() creates a shallow copy. pfClone() creates a deeper copy that creates new copies of internal nodes but not of leaf nodes. This means that the pfDCS, pfSwitch, and other internal nodes in the cloned hierarchy are separate from those in the original.

compiled mode

  OpenGL Performer pfGeoSets are designed for rapid immediate-mode rendering and in most situations outperform OpenGL display list usage. In those cases where GL display lists are desired, pfGeoSets may be placed in compiled mode, whereby a GL display list will be created the first time the pfGeoSet is rendered and this display list will be used for subsequent renderings until the pfGeoSet compiled mode flag is explicitly reset. Once a pfGeoSet is compiled, any changes to its data arrays by the pfMorph node or other means will not be effective until the compiled-mode flag is cleared.

complex pixels

  Pixels for which several different geometric primitives contribute to the pixel's assigned color value. Such pixels are rare in typical scenes and only exist at edges of polygons unless multisample blending is in use. When this blending mode is used, all pixels rendered as neither fully opaque nor fully transparent are complex pixels.

cost tables

  OpenGL Performer contains texture download cost tables, which DTR uses to estimate the time it will take to carry out those texture subloads.

critically damped

  A closed-loop control system notion where the feedback transfer function is just right: not so slow that the system goes out of range before correction is applied and not so fast that overcorrection causes rapid swings or variation. This should be the goal of any user-specified stress management function.

cull

  See culling.

cull volume visualization

  The visual display of the culling volume, usually the same as the viewing frustum, to which the scene is culled before rendering. Normally the projected culling volume fills the display area. By rendering with a larger field of view or from an eyepoint that differs from the origin of the frustum, the tightness of culling can be determined for database tuning. The culling volume itself is often drawn in wireframe.

culling

  Discarding database objects that are not visible. Usually this refers to discarding objects located outside the current viewing frustum. This is done by comparing the bounding volume of these database objects with the six planes that bound the frustum. Objects completely outside may be safely discarded. See also occlusion culling.

data fusion

  OpenGL Performer's ability to read data in a variety of different database formats and convert it into the internal OpenGL Performer scene database format. Further, the ability of these different formats to provide special run-time behavior using callback functions or node subclassing and to have these different data formats all active in their native modes simultaneously.

database paging

  Loading databases from disk or network into memory for traversal during real-time simulation. Database paging is implicit in large area simulations due to the huge database sizes inherent in any high-resolution earth database. A frequent component of database paging is texture paging, in which new textures are downloaded to the graphics system at the same time new geometry is loaded from disk.

debug libraries

  OpenGL Performer libraries compiled with debugging symbols left in are known as debug libraries. These libraries provide greater and more accurate stack trace information when examining core dumps, such as during application development.

decal geometry

  Objects that appear “above” other objects in pfLayer geometry. In a runways-and-stripes example, the stripes would be the decal geometry. There can be multiple layers of decals with successively higher visual priorities. See layer geometry.

depth complexity

  The “pixel-rendering load” of a frame, which is defined as the total number of pixels written divided by the number of pixels in the image. For example, an image of two full-screen polygons would have a depth complexity of 2. It is often observed that different types of simulation images have predictable depth complexities with values ranging from a low of 2.5 for high altitude flight simulation to 4 or more for ground-based simulations. These figures can serve as a guide when configuring hardware and estimating frame rates for visual simulation systems. OpenGL Performer fill statistics provide detailed accounting and real-time visualization of depth complexity, as seen in Perfly.

displace decaling

  An implementation method for decal geometry that uses a Z-displacement to render coplanar geometry. The actual displacement used is a combination of a fixed offset and a range-based scaled offset, which are combined to produce the effective offset.

display list

  A list into which graphics commands are placed for efficient traversal. Both OpenGL Performer and the underlying OpenGL graphics library have their own display list structures.

DLL

  See dynamic link library.

draw mask

  A bitmask specified for both pfNodes and pfChannels, which together selects a subset of the scene graph for rendering. The node and channel draw masks are logically ANDed together during the CULL traversal, which prunes the node if the result is zero. Draw masks may be used to “categorize” the scene graph, where each bit represents a particular characteristic. Each node contains these masks, binary values whose bits serve as flags to indicate if the node and its children are considered drawable, intersectable, selectable, and so on. Most of these bits are available for application use.

drop

  Refers to frame processing. When in locked or fixed phase and a processing stage takes too long, the frame is dropped and not rendered. Dropped frames are a sure sign of system overload.

DSO

  See dynamic shared object.

dynamic

  Something that is updated automatically when one of its attributes or children in a scene graph changes. Often refers to the update of hierarchical bounding volumes in the scene graph.

dynamic link library (DLL)

  The Microsoft Windows equivalent of a DSO.

dynamic shared object (DSO)

  A library that is not copied into the final application executable file but is instead loaded dynamically (that is, when the application is launched). Since DSOs are shared, only one copy of a given DSO is loaded into memory at a time, no matter how many applications are using it. DSOs also provide the dynamic binding mechanism used by the OpenGL Performer database loaders.

Euler angles

  A set of three angles used to represent a rotation.

  See heading, pitch, and roll.

fade count

  The application sets a fade count to control the number of frames over which a new DTR level is faded in.

fixed frame rate

  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. Maintaining a fixed frame rate in databases of varying complexity is difficult and is the task of OpenGL Performer stress processing, which changes LOD scales based in measured system load.

flattening

  Flattening consists of taking multiple instances of a single object and converting them into separate objects (deinstancing) and then applying any static transformations defined by pfSCS nodes to the copied geometry; this action improves performance at a cost in memory space.

flimmering

  The visual artifact associated with improperly drawing coplanar Z-buffered geometry. For synonyms, consider flitter, flicker, sparkle, twinkle, and vibrate. One way to understand flimmering is to consider the screen space interpolation of Z-depth values, wherein a discrete difference of depth must be interpolated across a discrete number of pixels (or sub-pixels). When two polygons that would be coplanar in an infinite precision real-number context are considered in this discrete interpolation space, it is clear that the interpolated depth values will differ when the delta-Z to delta-pixels ratios are relatively prime. The image that results is essentially a Moirè pattern showing the modular relationship of the differences in the least significant bits of interpolated depth between the polygons. The `libpr` pfDecal() function and `libpf` pfLayer() node exist to handle the drawing of coplanar geometry without flimmering.

floating phase

  The style of frame overload management where the next frame after an overloaded frame is allowed to start at any vertical retrace boundary rather than being forced to wait for a specific boundary as in the LOCKED phase.

frame

  The term frame is used to mean “image” in most OpenGL Performer contexts. The image being rendered by the hardware is drawn into a “frame buffer” which is simply an image memory. This image, when delivered by video signals to a monitor or projector, exists as one or two video fields. In the one-field case, also known as non-interlaced, each row of the image is read from the frame buffer and generated as video in sequential order. In the interlaced method, the first field of display comprises alternate lines, one field for the odd lines and one field for the even lines. In this mode a frame consists of two fields, as the norm for NTSC broadcast video. Also, the frame is the unit of work in OpenGL Performer; the main loop in any Performer application consists of calls to pfFrame().

frame-accurate

  In a pipelined multiprocessing model, at any particular time the different stages of the pipeline are working on different frames. Data in the pipeline is called frame-accurate when a change made to the data in a particular frame is not visible in downstream stages of the pipeline until those stages begin processing that frame. Processing of `libpf` objects are frame-accurate because multiple copies of data are retained for the different pipeline stages.

free-running

  The unconstrained phase relationship of image generation where frame rendering is initiated as soon as the previous frame is complete without consideration of a minimum or maximum frame rate.

frustum

  A truncated pyramid—two parallel rectangular faces, one smaller than the other, and four trapezoidal faces that connect the edges of one rectangular face with the corresponding edges of the other rectangular face.

gaze vector

  The +Y axis from the eyepoint—informally, the direction the eye is facing.

graph

  A network of nodes connected by arcs. An OpenGL Performer scene graph is so termed due to its having this form. In particular, an OpenGL Performer scene graph must be an acyclic graph. See also scene graph.

graphics context

  The set of modes and other attributes maintained by OpenGL in both system software and the hardware graphics pipeline that defines how subsequent geometry is to be rendered. It is this information which must be saved and restored when drawing occurs in multiple windows on a single graphics pipeline.

graphics state elements

  Individual `libpr` state components, such as material color, line stipple pattern, point size, current texture definition, and the other elements that comprise the graphics context.

heading

  In the context of X-axis to the right, Y-axis forward, and Z-axis up, the heading is rotation about the Z-axis. This is the disturbing rotation that pivots your car clockwise or counterclockwise during a skid. Heading is also known as yaw, but OpenGL Performer uses the term heading to keep the H, P, and R abbreviations distinct from X, Y, and Z. Also see Euler angles.

heap

  The process heap is the normal area from which memory is allocated by malloc() when more memory is required; sbrk() is automatically called to increase the process virtual memory. Also see arena.

identity matrix

  A square matrix with ones down the main diagonal and zeroes everywhere else. This matrix is the multiplicative identity in matrix multiplication.

immediate-mode rendering

  Immediate-mode rendering operations are those that immediately issue rendering commands and transfer data directly to the graphics hardware rather than compiling commands and data into data structures such as display lists. See compiled mode.

instancing

  An object in the scene is called instanced if there is more than one path through the scene graph that reaches it. Instancing is most commonly used to place the same model in more than one location by instancing it under more than one pfDCS transformation node.

intersection pipeline

  Like the rendering pipeline, OpenGL Performer supports a two-stage multiprocessing pipeline between the APP and ISECT processes. See also rendering pipeline.

latency

  The amount of time between an input and the response to that input. For example, rendering latency is usually defined as the time from which the eyepoint is set until the display devices scan out the last pixel of the first field corresponding to that eyepoint.

latency-critical

  Operations that must be performed during the current frame and that will reliably finish quickly. An example of this would be reading the current position of a head-tracking device from shared memory.

layer geometry

  Objects that appear “above” other objects in pfLayer geometry. In a runways-and-stripes example, the stripes would be the decal geometry. There can be multiple layers of decals with successively higher visual priorities. See also base geometry.

level of detail (LOD)

  The idea of representing a single object, such as a house, with several different geometric models (a cube, a simple house, and a detailed house, for example) that are designed for display at different distances. The models and ranges are designed such that the viewer is unaware of the substitutions being made. This is possible because distant objects appear smaller and thus can be rendered with less detail. The OpenGL Performer pfLOD node and the associated pfLODState implement this scheme.

`libpf`

  One of OpenGL Performer's two core libraries. `libpf` manages multiprocessing and scene graph traversals. Built on top of `libpr`. Multiple copies of `libpf` objects are automatically maintained so that the APP, CULL, and ISECT stages of the processing pipeline do not collide.

`libpfdu`

  OpenGL Performer's database utilities library. It is layered on top of `libpf` and `libpr` and includes functions for building and optimizing geometry before putting it into a scene graph.

`libpfutil`

  OpenGL Performer's general utility library, which is distributed in source form for both usage and information.

`libpr`

  One of OpenGL Performer's two core libraries. `libpr` manages graphics state and rendering, while also providing a number of math and shared memory utility functions. Provides the foundation for`libpf`. All processes share the same copy of `libpr` objects.

`libpr` classes

  The low-level structured data types of`libpr`. These objects—with the exception of pfCycleBuffers—lack the special multibuffered, multiprocess data-exclusion support that `libpf` objects provide.

light point

  A point of light such as a star or a runway light. Accurate display of light points requires that they attenuate and fog differently than other geometry (see punch through). In flight simulation, light points often have additional parameters concerning angular distributions of illumination.

load

  The processing burden of rendering a frame. This includes both processing performed on the host CPU and in the graphics subsystem. It is the maximum of these times (sum in single process mode) that is used to compute the system stress level for adjusting pfLODState values.

locked phase

  A style of frame-overload processing where drawing may only begin on specific vertical retraces, namely those that are an integer multiple of the basic frame rate.

morph attribute

  One of the collections of arrays of floating point data used in the pfMorph node's linear combination processing. This process multiplies each element of each source array by a changeable weight value for that source array and sums the result of these products to produce the destination array.

morphing

  The mathematical manipulation of pfGeoSet data (positions, normals, colors, texture coordinates) to cause a shape-shifting behavior. This is very useful for animated characters, continuous terrain level of detail, smooth object level of detail, and a number of advanced applications. In OpenGL Performer, morphing is provided by the pfMorph node.

multiple inheritance

  Deriving a class from more than one other class. This is in contrast to single inheritance in which a type hierarchy is a tree. OpenGL Performer does not use multiple inheritance.

multithreaded

  In the context of OpenGL Performer culling, multithreading is an option for increased parallelism when multiple pfChannels exist in a single OpenGL Performer rendering pipeline. In this case, multiple cull processes are created to work on culling the channels of a pfPipe in parallel. For example, a single OpenGL Performer pipeline stage (such as the CULL) is multithreaded when configured as multiple, concurrent processes. These “threads” are not arranged in pipeline fashion but work in parallel on the same frame.

mutual exclusion

  Controlling access to a data structure so that two or more threads in a multiprocessing application cannot simultaneously access a data structure. Mutual exclusion is often required to prevent a partially updated data structure from being accessed while it is in an invalid state.

node

  An OpenGL Performer `libpf` data object used to represent the structure of a visual scene. Nodes are either leaf nodes that contain `libpr` geometry or are internal nodes derived from pfGroup that control and define part of the scene hierarchy.

nonblocking file access

  A method of obtaining data from a file without having to wait for any other processes to finish using the file. Such accesses involve a two-step transaction in which the application first indicates the task to be performed and is given a handle. This handle can later be used to inquire about the status of the file action: it is in progress, it has completed, or there has been an error.

non-degrading priorities

  Process priorities are used by the operating system to decide when and for how long processes should run. A non-degrading priority specifies that the process scheduling should not take into account how long the process has been running when deciding whether to let another process run. The use of non-degrading priorities is important for real-time performance.

occlusion culling

  The discarding of objects that are not visible because they are occluded by other closer objects in the scene, for example, a city behind a mountain. See also culling.

opera lighting

  The generic term for a powerful carbon-arc lamp producing an intense light such as that invented by John H. Kliegl and Anton T. Kliegl for use in public-staged events and cinematographic undertakings that is often mounted within a dual-gimballed exoskeletal framework to afford the lamp sufficient freedom of orientation that the projected beam can be made to track and highlight performers as they move across a stage. The temperature of the thermal plasma that develops between the carbon electrodes of such arc lamps can be determined by spectroscopic investigation of its dissociated condition and has been found to be between 20,000˚C and 50,000˚C. The term can also refer to a stage-lighting technique that projects an image of a background scene onto the stage or screen. Accurate visual simulation of both of these light types (as well as common vehicle headlights, airplane landing lights, and searchlights) is provided by the projected texture capability of the pfLightSource node.

overload

  A condition where the time taken to process a frame is longer than the desired frame rate allows. This causes the goal of a fixed-frame rate to be unattainable and, thus, is an undesired situation.

overrun

  A synonym for overload in the context of fixed frame rate rendering.

pair-wise morphing

  The geometric blending of two topologically equivalent objects. Usually this is done by specifying weights for each object, for example, 90% of object A plus 10% of object B. Each vertex in the resulting object is a linear interpolation between the vertices in the original object. See morphing.

parent

  The OpenGL Performer node directly above a given node is known as the parent node.

passthrough data

  Data that is passed down the steps in the rendering pipeline until it reaches a callback. Such data provides the mechanism whereby an application can communicate information between the APP, CULL, and DRAW stages in a pipelined manner without code changes in single-CPU and multiprocessing applications.

path

  A series of nodes from a scene graph's root down to a specific node defines a path to that node. When there are multiple paths to a node (thus, the scene graph is really a graph rather than a tree), this path can be important when interpreting an intersection or picking request. For example, if a car model uses instancing for the tires, just knowing that a tire is picked is not sufficient for further processing.

Perfly

  The application distributed with OpenGL Performer that serves as a demonstration program. For IRIX and Linux, it is installed in `/usr/sbin` as well as a programming example found in `/usr/share/Performer/src/sample/apps/C` and `/usr/share/Performer/src/sample/apps/C++` for the C and C++ versions, respectively. For Microsoft Windows, it is installed in `%PFROOT%\Bin` as well as a programming example found in `%PFROOT%\Src\sample\apps\C` and `%PFROOT%\Src\sample\apps\C++` for the C and C++ versions, respectively.

phase

  An application's synchronization mode—defining how the system behaves if the processing and drawing time for a given frame extends past the time allotted for a frame. See also locked phase and floating phase.

pipe

  Used to refer to both an OpenGL Performer software rendering pipeline and to a graphics hardware rendering pipeline, such as a RealityEngine. See rendering pipeline.

pitch

  In the context of X-axis to the right, Y-axis forward, and Z-axis up, the pitch is rotation about the X-axis. This is the rotation that would raise or lower the nose of an aircraft. Also see Euler angles.

popping

  The term for the highly noticeable instantaneous switch from one level of detail to the next when morph or blend transitions are not used. This problem is distracting and should be eliminated in high-quality simulation applications.

process callbacks

  The mechanism through which a developer takes control of processing activities in the various OpenGL Performer traversals and major processing stages: the application traversal, the cull traversal, the draw traversal, and the intersection traversal all provide a mechanism for registered process callbacks. These are user functions that are invoked at the beginning of the indicated processing stage and in the process handling the traversal.

projective texturing

  A texture technique that allows texture images to be projected onto polygons in the same manner as a slide or movie projector would exhibit keystone distortion when images are cast non-obliquely onto a wall or screen. This effect is perfect for projected headlights and similar lighting effects.

prune

  To eliminate a node from further consideration during culling.

punch through

  Decreasing the rate at which intensely luminous objects such as light points are attenuated as a function of distance. Normal fogging is inappropriate for such objects because up close they are actually much brighter than can be rendered given the dynamic range of the framebuffer and raster display devices.

reference counting

  The counter within each pfObject and pfMemory object that keeps track of how many other data structures are referencing the particular instance. The primary purpose is to indicate when an object may be safely deleted because it is no longer referenced.

rendering pipeline

  An OpenGL Performer rendering pipeline, represented in an application by a pfPipe. Typically a rendering pipeline has three stages: APP, CULL, and DRAW. These stages may be handled in separate processes or combined into one or two processes.

right-hand rule

  Derived from a simple visual example for the direction of positive rotation about an axis, the right-hand rule states that the curled fingers of the right hand indicate the direction of positive rotation when the right hand is placed about the desired axis with the thumb pointing in the positive direction. The positive angle is the one that rotates the primary axes toward each other. For example, a positive rotation (counterclockwise) about the X-axis takes the positive Y-axis into the position previously occupied by the positive Z-axis.

roll

  In the context of X-axis to the right, Y-axis forward, and Z-axis up, the roll is rotation about the Y-axis. This is the rotation that would raise and lower the wings of an aircraft, leading to a turn. Also see Euler angles.

scene

  A collection of geometry to be rendered into a pfChannel.

scene complexity

  The complexity of the scene for rendering purposes, in particular the amount of geometry, transformations, and graphics state changes in the scene.

scene graph

  A hierarchical assembly of OpenGL Performer nodes linked by explicit attachment arcs that constitutes a virtual world definition for traversal and subsequent display.

search path

  A list of directory names given to OpenGL Performer to specify where to look for data files that are not specified as full path names.

sense

  An indication of whether a positive angle is interpreted as representing a clockwise (CW) or counterclockwise (CCW) rotation with respect to an axis. All CCW rotations in OpenGL Performer are specified by positive (+) angles and negative angles represent CW rotations.

shadow map

  A special texture map created by rendering a scene from the view of a light source and then recording the depth at each pixel. This Z-map is then used with projective texturing in a second pass to implement cast shadows. The entire process is automated by the OpenGL Performer pfLightSource node.

share groups

  The attributes that a slave share mask can track are divided into groups called share groups.

share mask

  The share mask associates master and/or slave cliptextures.

shared instancing

  The simplest form of instancing whereby two or more parent nodes share the same node as a child. In this situation, any change made to the child will be seen in each instance of that node. Also see cloned instancing.

shininess

  The coefficient of specular reflectivity assigned to a pfMaterial that governs the appearance of highlights on geometry to which it is bound.

siblings

  The name given to nodes that have the same parent in a scene graph.

skip

  Refers to frame processing. See drop.

sorting

  The grouping together of geometry with similar graphics state for more efficient rendering with fewer graphics state changes. OpenGL Performer sorts during scene graph traversal.

spacing

  The relative motion required to move the starting point for subsequent pfFont rendering after drawing a particular character pfGeoSet in a pfFont. This motion is a pfVec3 to allow arbitrary escapement for character sets that use vertical rather than horizontal text layouts. Note that for vertically oriented fonts, the origin should be such that motion by the spacing value crosses the character; in other words, the origin should be on the left for left-to-right fonts, at the top for top-to-bottom fonts, on the bottom for bottom-to-top fonts, and on the right for right-to-left fonts.

spatial organization

  The grouping together of geometric objects that are spatially close to each other in the scene graph. For optimal culling performance, the scene should be organized spatially.

sprite

  A transformation that rotates a piece of geometry, usually textured, so that it always faces the eyepoint.

stage

  This is a section of the OpenGL Performer software rendering pipeline, either application, culling, or drawing. Sometimes it is used to refer to either of the two non-pipeline tasks of intersection and asynchronous database processing.

state

  Refers to attributes used to render an object that are managed during traversal. State commonly falls into two areas: traversal state that affects which portions of the scene graph are traversed, and graphics state that affects how something is rendered. Graphics state includes the current transformation, the graphics modes managed by pfGeoStates, and other states such as stenciling.

stencil decaling

  An implementation method for pfLayer nodes that uses an extra bit per pixel in the frame buffer to record the Z-buffer pass or fail status of the base geometry. This bit is then used as a visibility determination (rather than the Z-buffer test) for each of the layers, which are rendered in bottom (lowest visual priority) to top (highest visual priority) order. Z-buffer updating is disabled during the stencil rendering operation and is restored when the pfLayer node has been completely rendered. Stencil-bit processing is the highest quality mode of pfLayer operation.

stress

  OpenGL Performer stress processing is the closed-loop feedback mechanism that monitors cull and draw times to determine how pfLODState range scale factors should be adjusted to compensate for system load in order to maintain a chosen frame rate.

subgraph

  A connected subset of a scene graph; usually, the set consisting of all descendents of a particular node.

texel

  Short for “texture element”—a pixel of a texture.

texture mapping

  Displaying a texture as though it were the surface of a given polygon.

tile

  A section of a spatially subdivided database or a rectangular subregion of a larger texture image.

transformation

  Homogeneous 4x4 matrices that define 3D transformations—some combination of scaling, rotation, and translation.

transition distance

  The distance at which one level-of-detail model is switched for another. When fading or morphing between levels-of-detail, the distance at which 50% of each model is rendered. See level of detail.

traversals

  One of OpenGL Performer's pre-order visitations of a hierarchical scene graph. Traversals for application, culling, and intersection processing are internal to `libpf` and user-written traversals are supported by the pfuTraverser tools.

traversing

  See traversals.

trigger routine

  A routine that initiates a traversal or the invocation of a callback in another process. pfCull() triggers the cull traversal. pfFrame() triggers processing for the current frame.

up vector

  The +Z axis of the eyepoint; it defines the display's “up” direction. Must be perpendicular to the gaze vector.

view volume visualization

  The display of the viewing frustum for a particular channel, usually done by rendering a wireframe version of the frustum with a different eyepoint or field-of-view. See cull volume visualization.

viewing frustum

  The frustum containing the portion of the scene database visible from the current eyepoint.

viewpoint

  The location of the camera or eye used to render the scene.

viewport

  The portion of the framebuffer used for rendering. Each pfChannel has a viewport in the framebuffer of its corresponding pfPipeWindow.

visual

  A construct that the X Window System uses to identify framebuffer configurations.

widget

  A manipulable or decorative element of a graphical user interface. Much of the programming for GUI elements is associated with defining the reaction of widgets to user-mouse and keyboard events.

window manager

  A special X Window System client that handles icons, window placement, and window borders and titles.

Prev | Table of Contents | Next
Chapter 26. Programming with C++ |  | Index