pfCompositor(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
NAMEpfCompositor - Set and get pfCompositor definition parameters.
FUNCTION SPECIFICATION
#include <Performer/pf/pfCompositor.h>
pfCompositor::pfCompositor(int netId);
static pfType* pfCompositor::getClassType(void);
static int pfCompositor::getNumHWCompositors(void);
static int pfCompositor::getHWCompositorNetworkId(int c);
static int pfCompositor::getHWCompositorNumInputs(int c);
static int pfCompositor::getHWCompositorInputType(int c, int i);
static char* pfCompositor::getHWCompositorInputPipeName(int c,
int i);
static int pfCompositor::getHWCompositorInputNetworkId(int c,
int i);
static pfCompositor*
pfCompositor::getHWCompositorPfCompositor(int c);
static int pfCompositor::getNumCompositedPipes(void);
static int pfCompositor::getNumCompositors(void);
static pfCompositor*
pfCompositor::getCompositor(int i);
int pfCompositor::getNetworkId(void);
void pfCompositor::autoSetup(int num_inputs);
int pfCompositor::addChild(char* pipe_name);
int pfCompositor::addChild(pfCompositor *comp);
int pfCompositor::getNumChildren(void);
int pfCompositor::getChildType(int index);
pfCompositor* pfCompositor::getChildCompositor(int index);
pfPipe* pfCompositor::getChildPipe(int index);
Page 1
pfCompositor(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
char* pfCompositor::getChildPipeName(int index);
int pfCompositor::getChildPipeId(int index);
pfCompositor* pfCompositor::getParent(void);
int pfCompositor::getNumActiveChildren(void);
int pfCompositor::setNumActiveChildren(int n);
void pfCompositor::setViewport(float left, float right,
float bottom, float top);
void pfCompositor::getViewport(float *left, float *right,
float *bot, float *top);
void pfCompositor::setVal(int what, float val);
float pfCompositor::getVal(int what);
void pfCompositor::setMode(int what, int val);
int pfCompositor::getMode(int what);
void pfCompositor::setLoadBalancer(pfLoadBalance *balancer);
pfLoadBalance* pfCompositor::getLoadBalancer(void);
void pfCompositor::setChildViewport(int i, float left,
float right, float bot, float top);
void pfCompositor::getChildViewport(int i, float* l,
float* r, float* b, float* t);
void pfCompositor::resetChildrenViewports(void);
pfPipe* pfCompositor::getMasterPipe(void);
int pfCompositor::getMasterPipeId(void);
int pfCompositor::getNumPipes(void);
pfPipe* pfCompositor::getPipe(int p);
pfPipeWindow* pfCompositor::getPWin(int p);
pfChannel* pfCompositor::getChan(int p, int c);
pfCompositor* pfCompositor::getRoot(void);
Page 2
pfCompositor(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
void pfCompositor::setChannelClipped(int chan_num,
int clip );
unsigned char pfCompositor::getChannelClipped(int chan_num);
int pfCompositor::setAntialiasJitter( int n,
float* jitter );
int pfCompositor::getAntialiasJitter( int n,
float* jitter );
static uint pfCompositor::getDefaultChanShareMask(void);
static void pfCompositor::setDefaultChanShareMask(uint mask);
PARENT CLASS FUNCTIONS
The OpenGL Performer class pfCompositor is derived from the parent class
pfObject, so each of these member functions of class pfObject are also
directly usable with objects of class pfCompositor. This is also true
for ancestor classes of class pfObject.
void* pfObject::operator new(size_t);
void* pfObject::operator new(size_t, pfFluxMemory *fmem);
void pfObject::setUserData(void *data);
void pfObject::setUserData(int slot, void *data);
void* pfObject::getUserData(pfObject *obj);
void* pfObject::getUserData(pfObject *obj, int slot);
int pfObject::getNumUserData();
Since the class pfObject is itself derived from the parent class
pfMemory, objects of class pfCompositor can also be used with these
functions designed for objects of class pfMemory.
void* pfMemory::getData(const void *ptr);
pfType * pfMemory::getType();
int pfMemory::isOfType(pfType *type);
int pfMemory::isExactType(pfType *type);
const char * pfMemory::getTypeName();
int pfMemory::copy(pfMemory *src);
int pfMemory::compare(const pfMemory *mem);
void pfMemory::print(uint which, uint verbose, char *prefix,
FILE *file);
int pfMemory::getArena(void *ptr);
void* pfMemory::getArena();
int pfMemory::ref();
int pfMemory::unref();
int pfMemory::unrefDelete();
int pfMemory::unrefGetRef();
int pfMemory::getRef();
Page 3
pfCompositor(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
int pfMemory::checkDelete();
int pfMemory::isFluxed();
void * pfMemory::getArena();
int pfMemory::getSize();
DESCRIPTION
A compositor is a hardware device that takes a number of video inputs and
combines them to produce a single video output. The video inputs can be
divided spatially or blended together to form one output.
The pfCompositor class transparently distributes rendering across
multiple hardware pipes and combines their outputs by either feeding them
to a hardware compositor device, or through software composition.
Several different spatial composition modes are supported, as well as an
Anti-Alias mode in which channel frustums on composited pipes are
slightly jittered and the outputs blended together by the hardware
compositor.
pfCompositor also supports dynamic load balancing. When enabled, the
spatial subdivision of the compositor's inputs will be updated on each
frame based on the load of each contributing pfpipe. Load balancing is
disabled by default, and can be enabled through setMode .
During initialization, the pfCompositor class will perform a system
topology query to determine the availability of hardware compositors.
The results of this query can be examined by the application through the
following static methods:
getNumHWCompositors returns the number of available hardware compositors
found on the system.
getHWCompositorNetworkId returns the network Id of the c-th hardware
compositor, or -1 if c is not a valid index.
getHWCompositorNumInputs returns the number of inputs physicaally
connected to the c-th hardware compositor. Each input can either be a
single-pipe or the output of another hardware compositor. If c is not a
valid index, -1 is returned.
getHWCompositorInputType returns PFCOMP_INPUTTYPE_PIPE if the i-th input
of the c-th hardware compositor is a single-pipe, or
PFCOMP_INPUTTYPE_COMPOSITOR if it is another hardware compositor. If c is
not a valid index, 0 is returned.
If the i-th input of the c-th hardware compositor is a single-pipe,
getHWCompositorInputPipeName returns the string identifying the Display
of that pipe (eg ":0.0"). If c or i are not valid indices, or if the i-
th input of the c-th compositor is not a single-pipe, NULL is returned.
If the i-th input of the c-th hardware compositor is a compositor,
getHWCompositorInputNetworkId returns its network Id. If c or i are not
Page 4
pfCompositor(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
valid indices, or if the i-th input of the c-th compositor is not a
compositor, -1 is returned.
getHWCompositorPfCompositor returns a pointer to the pfCompositor object
managing the c-th hardware compositor, if one exists. Otherwise, or if c
is not a valid index, NULL is returned.
The pfCompositor class makes it extremely easy to configure and manage
multiple graphics pipes. Most of the work is done transparently behind
the scenes through a mechanism of automatic call-propagation.
All the application has to do is create a pfCompositor object before
pfConfig, then after pfConfig, obtain a pointer to the compositor's
master pipe, and treat it as if it were a single-pipe.
Currently only one full-screen pfPipeWindow is supported on composited
pfPipes. Only the pfPipeWindow on compositor's master pipe should be
created by the application. pfPipeWindows on compositor's slave pipes
will be created automatically.
Similarly, the application should only create pfChannels on compositor's
master pipe. Channels will automatically be created on all other
composited pipes.
By default, most methods of the pfChannel class have no effect if called
on compositor slave channels (ie pfChannels on compositor slave pipes).
Instead, the application should address channels in compositor master
pipe alone, and methods will automatically propagate to all associated
compositor slaves.
The global mask specifying which pfChannel methods will be propagated by
default can be queried through GetCompositorDefaultChanShareMask and can
be set through SetCompositorDefaultChanShareMask. Below is a list of all
valid compositor-share tokens which can be combined (using the logical
'or' operator) to form the mask argument:
PFCOMP_SHARE_FOV
PFCOMP_SHARE_VIEW
PFCOMP_SHARE_NEARFAR
PFCOMP_SHARE_SCENE
PFCOMP_SHARE_STRESS
PFCOMP_SHARE_STRESSFILTER
PFCOMP_SHARE_LOD
PFCOMP_SHARE_EARTHSKY
PFCOMP_SHARE_SWAPBUFFERS
PFCOMP_SHARE_VIEW_OFFSETS
PFCOMP_SHARE_STATS_DRAWMODE
PFCOMP_SHARE_APPFUNC
PFCOMP_SHARE_CULLFUNC
PFCOMP_SHARE_DRAWFUNC
PFCOMP_SHARE_VIEWPORT
PFCOMP_SHARE_SWAPBUFFERS_HW
Page 5
pfCompositor(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
PFCOMP_SHARE_CULL_VOLUME
PFCOMP_SHARE_GSTATE
PFCOMP_SHARE_PRICLASS_LIST
PFCOMP_SHARE_LPOINTFUNC
PFCOMP_SHARE_POSTLPOINTFUNC
PFCOMP_SHARE_BIN_ORDER
PFCOMP_SHARE_TRAV_MODE
A pfCompositor is created through new pfCompositor(netId), where netId is
the network Id identifying the hardware compositor device that will be
managed by the new pfCompositor. If netId is PFCOMP_SOFTWARE, no hardware
compositor device will be involved, and composition will be carried out
through software readbacks.
We will refer to pfCompositors utilizing software composition as software
compositors, while pfCompositors associated with a hardware compositor
device will be referred to as hardware compositors.
A global list of all pfCompositors that have been created is maintained
by the pfCompositor class. getNumCompositors returns the number of
pfCompositor objects in this list.
getCompositor returns a pointer to the i-th pfCompositor object from the
global list of pfCompositors. pfCompositors are added to this list in the
order they are created.
getNetworkId will return the network Id identifying the hardware
compositor device managed by a pfCompositor object, or PFCOMP_SOFTWARE if
the pfCompositor uses software composition.
addChild(pipe_name) adds a pipe child to a pfCompositor. If the
pfCompositor is a hardware compositor, pipe_name must match the display
string of one of the hardware pipes physically connected to the
compositor device. If the compositor is a software compositor, then
pipe_name can be any valid display string. The pfPipes configured by the
software compositor will be created on the specified displays through
calls to pfPipe::setWSConnectionName. pipe_name can also be "" (empty
string) for software compositors, in which case pipes will be created on
the default screens (:0.0, :0.1, etc).
addChild(comp) adds a compositor child to a pfCompositor, creating a
compositor hierarchy. Currently only hardware compositor parents and
software compositor children are supported. Care must be taken in
configuring compositor hierarchies to ensure that the first child of the
software compositor child (its master pipe) is physically connected to
the compositor device managed by the parent pfCompositor.
The following example creates a compositor hierarchy managing 8 pipes,
with a single hardware compositor as root, and four software compositors,
each managing two pipes, as inputs. Here we assume that the hardware
Page 6
pfCompositor(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
compositor has a networkId of 0, and pipes :0.0, :0.1, :0.2 and :0.3 are
physically connected to it:
pfCompositor *hwcomp, *swcomp;
hwcomp = new pfCompositor(0);
swcomp = new pfCompositor(PFCOMP_SOFTWARE);
swcomp->addChild(":0.0");
swcomp->addChild(":0.4");
hwcomp->addChild(swcomp);
swcomp = new pfCompositor(PFCOMP_SOFTWARE);
swcomp->addChild(":0.1");
swcomp->addChild(":0.5");
hwcomp->addChild(swcomp);
swcomp = new pfCompositor(PFCOMP_SOFTWARE);
swcomp->addChild(":0.2");
swcomp->addChild(":0.6");
hwcomp->addChild(swcomp);
swcomp = new pfCompositor(PFCOMP_SOFTWARE);
swcomp->addChild(":0.3");
swcomp->addChild(":0.7");
hwcomp->addChild(swcomp);
autoSetup can be used to easily configure a pfCompositor with the desired
number of inputs. For hardware compositors, num_inputs cannot exceed the
number of inputs physically connected to the hardware device. A zero or
negative value of num_inputs will cause all physically connected inputs
to be configured. For software compositors, num_inputs will be clamped
to the number of available hardware pipes. If num_inputs is less than
one, all available hardware pipes on the system will be configured.
Note that autoSetup will take no action at all if pfCompositor already
has one or more children.
autoSetup(-1) is called within pfConfig for all pfCompositor objects, in
order to automatically configure them if the application has not done so
already.
getNumCompositedPipes returns the total number of pfPipes which are (or
will be) managed by pfCompositor objects. This is known with certainty
only after pfConfig, as until then pipes may be added to existing
compositors. However, if called before pfConfig, this method will
attempt to make a reasonable guess by assuming that pfCompositors with no
explicitely assigned children will end up being (automatically)
Page 7
pfCompositor(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
configured with all the inputs which are physically connected to them.
This can be useful when an application creates one or more single pipes
in addition to pipes managed by pfCompositors. In such cases the
application is required to make a call to pfMultipipe providing the total
number of pipes to be created. getNumCompositedPipes will quickly return
the total number of composited pipes, to which the desired number of
single-pipes may be added.
getNumChildren returns the number of children (inputs) that have been
added to a pfCompositor. Each child can either be a single-pipe or a
pfCompositor. getChildType returns PFCOMP_INPUTTYPE_PIPE if the i-th
child is a single pipe, or PFCOMP_INPUTTYPE_COMPOSITOR if it is a
pfCompositor. If i is not a valid index, 0 is returned.
If the i-th child of a pfCompositor is a pfCompositor, getChildCompositor
will return a pointer to it. If i is not a valid index, or if the i-th
child is not a compositor, NULL is returned.
If the i-th child of a pfCompositor is a single-pipe, getChildPipe will
return a pointer to it (This can only be called after pfConfig);
getChildPipeName will return its display-string. Note that for software
compositors, getChildPipeName will return an empty string ("") for all
children unless a display string was explicitely assigned by application
through a call to addChild(pipe_name). getChildPipeId returns the
Performer Id of the pipe-child, and should only be called after pfConfig.
getParent returns a pointer to a pfCompositor parent (another
pfCompositor) if the first has been added to the latter as a child
through a call to addChild(comp). If a pfCompositor has no parent, NULL
is returned.
Not all configured children must partecipate to composited image at all
times. The pfCompositor class supports dynamic changes to the number of
active children through setNumActiveChildren. There must be at least one
active child, and no more than the total number of configured children.
getNumActiveChildren returns the number of currently active children.
Note that children are activated from first to last, meaning that when
there are n active children, these will be children 0 to (n-1); thus
child 0 is always active.
getMasterPipe returns a pointer to the master pfPipe for a pfCompositor.
The master pipe is the pipe that the application should use to create a
pipe-window and one or more channels. pfPipeWindows and pfChannels are
created automatically on all other composited pipes (slave pipes) by the
pfCompositor class.
In a single-tier compositor (one with no compositor parent and no
compositor children), the master pipe will be its first child. In a
compositor hierarchy, all pfCompositors will share a single master pipe.
Page 8
pfCompositor(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
getMasterPipeId returns the Performer pipe Id of pfCompositor's master
pipe.
Each pfCompositor object maintains a list of all the pfPipes contributing
to its output. This includes all single-pipe children, as well as all
pipes connected to compositor-children.
getNumPipes returns the total number of pfPipes contributing to a
pfCompositor. For a single-tier compositor, this is equal to the number
of its children. In a compositor hierarchy, pipes contributing to leaf-
compositors (bottom of the hierarchy) also contribute to root-compositor,
so if called on the root-compositor of a compositor hierarchy,
getnumPipes will return the total number of pipes in hierarchy.
getPipe returns a pointer to the p-th pfPipe in a pfCompositor's pipe-
list. If p is an invalid index, NULL is returned.
getPWin returns a pointer to the pfPipeWindow on the p-th pipe in a
pfCompositor's pipe-list. Currently only one (fullscreen) pipe-window is
supported on composited pipes. If p is an invalid index, NULL is
returned.
getChan returns a pointer to the c-th pfChannel on the p-th pipe in a
pfCompositor's pipe-list. If p or c are invalid indices, NULL is
returned.
getRoot returns a pointer to the pfCompositor at the root of the
compositor hierarchy to which compositor belongs. For a parent-less
pfCompositor, getRoot will return a pointer to the compositor itself.
For a compositor-child, getRoot will return parent->getRoot.
A pfCompositor requires a pfLoadBalance object for carrying out load
balancing computations. The pfLoadBalance class determines the resulting
workload for each of the compositor's children. The behavior can be
customized by subclassing pfLoadBalance and overriding the appropriate
methods. A pfCompositor can use a customized pfLoadBalance object
specified through the setLoadBalancer method. If a load balancer is not
specified, one will be automatically created and used.
getLoadBalancer returns a pointer to the pfLoadBalancer object used by
the compositor.
See the pfLoadBalance manual page for more information.
setMode accepts the following tokens as its first argument:
PFLOAD_BALANCE
Enables or disables dynamic load balancing. The second argument
must be PF_ON or PF_OFF.
Page 9
pfCompositor(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
PFCOMP_CLIPPING
Enables or disables channel-clipping for all channels on all
pipes managed by this compositor. By default, channel-clipping
is enabled, and the viewports of pfChannels in composited pipes
are clipped to the screen region assigned to each pipe by the
compositor. If channel- clipping is disabled, all pipes will
render all channels in their full (original) size. Note that
clipping is not carried out when in AntiAlias mode.
PFCOMP_SWAPBARRIER
Specifies the swap_barrier to which pipes contributing to
pfCompositor should bind. The second argument should be a valid
swap_barrier id (see glXQueryMaxSwapBarriersSGIX). By default,
all pfCompositors will bind to swap_barrier 1 (if the
swap_barrier extension is supported). Binding to swap_barrier
can be disabled by passing a value smaller than 1. If the
specified barrier_id is out of range, the call to setMode has
no effect.
PFCOMP_COMPOSITION_MODE
Specifies the composition mode used by the pfCompositor. The
second argument can be one of:
PFCOMP_COMPMODE_HORIZ_STRIPES PFCOMP_COMPMODE_VERT_STRIPES
PFCOMP_COMPMODE_LEFT_TILES PFCOMP_COMPMODE_RIGHT_TILES
PFCOMP_COMPMODE_BOTT_TILES PFCOMP_COMPMODE_TOP_TILES
PFCOMP_COMPMODE_ANTIALIAS
All composition modes are valid for any number of active children. This
is how one to four inputs are laid out for each composition mode:
PFCOMP_COMPMODE_HORIZ_STRIPES:
_____________ ______________ ______________ ______________
| | | | | | | 3 |
| | | 1 | | 2 | |______________|
| | | | |______________| | 2 |
| 0 | |______________| | 1 | |______________|
| | | | |______________| | 1 |
| | | 0 | | | |______________|
| | | | | 0 | | 0 |
|_____________| |______________| |______________| |______________|
PFCOMP_COMPMODE_VERT_STRIPES:
_____________ ______________ ______________ _______________
| | | | | | | | | | | | | |
| | | | | | | | | | | | | |
| | | | | | | | | | | | | |
Page 10
pfCompositor(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
| 0 | | 0 | 1 | | 0 | 1 | 2 | | 0 | 1 | 2 | 3 |
| | | | | | | | | | | | | |
| | | | | | | | | | | | | |
| | | | | | | | | | | | | |
|_____________| |_______|______| |____|____|____| |___|___|___|___|
PFCOMP_COMPMODE_LEFT_TILES:
_____________ ______________ ______________ _______________
| | | | | | | | | | |
| | | | | | | 2 | | | 3 |
| | | | | | | | | 1 |________|
| 0 | | 0 | 1 | | 0 |________| | | |
| | | | | | | | |______| |
| | | | | | | 1 | | | 2 |
| | | | | | | | | 0 | |
|_____________| |_______|______| |_____|________| |______|________|
PFCOMP_COMPMODE_RIGHT_TILES:
_____________ ______________ ______________ ______________
| | | | | | | | | | |
| | | | | | 2 | | | | 3 |
| | | | | | | | | 1 |_______|
| 0 | | 0 | 1 | |_______| 0 | | | |
| | | | | | | | |______| |
| | | | | | 1 | | | | 2 |
| | | | | | | | | 0 | |
|_____________| |______|_______| |_______|______| |______|_______|
PFCOMP_COMPMODE_BOTT_TILES:
_____________ ______________ ______________ ______________
| | | | | | | | | |
| | | 1 | | | | | 2 | 3 |
| | | | | 1 | 2 | | | |
| 0 | |______________| | | | |_____|________|
| | | | |_______|______| | | |
| | | 0 | | | | 0 | 1 |
| | | | | 0 | | | |
|_____________| |______________| |______________| |_______|______|
PFCOMP_COMPMODE_TOP_TILES:
_____________ ______________ ______________ ______________
| | | | | | | | |
| | | 1 | | 0 | | 2 | 3 |
| | | | |______________| | | |
| 0 | |______________| | | | |_____|________|
| | | | | | | | | |
| | | 0 | | 1 | 2 | | 0 | 1 |
| | | | | | | | | |
|_____________| |______________| |______|_______| |_______|______|
Page 11
pfCompositor(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
getMode can be called to query pfCompositor values. The following tokens
are allowed:
PFLOAD_BALANCE
The returned value is 1 if dynamic load balancing is enabled, 0
if it is disabled.
PFCOMP_CLIPPING
The returned value is 1 if channel-clipping is enabled, or 0 if
it is disabled.
PFCOMP_SOFTWARE
The returned value is 1 if pfCompositor uses software
composition, or 0 if pfCompositor controls a hardware
compositor device.
PFCOMP_SWAPBARRIER
The returned value is the index of the swap_barrier to which
pipes will bind (or have bound). If binding to swap barriers
has been (or will be) skipped, return value is 0.
PFCOMP_COMPOSITION_MODE
The returned value is the current composition moce used by the
pfCompositor and can be one of:
PFCOMP_COMPMODE_HORIZ_STRIPES PFCOMP_COMPMODE_VERT_STRIPES
PFCOMP_COMPMODE_LEFT_TILES PFCOMP_COMPMODE_RIGHT_TILES
PFCOMP_COMPMODE_BOTT_TILES PFCOMP_COMPMODE_TOP_TILES
PFCOMP_COMPMODE_ANTIALIAS
setVal currently only accepts PFLOAD_COEFF, and passes the value onto the
pfLoadBalance class. This coefficient determines how quickly the balancer
transitions from the current state to the desired balanced state. This
load-balancing filter coefficient should be in the range (0..1]. The
smaller its value, the slower load balancing follows pipe load, and the
less noise-sensitive it is.
getVal also only accepts PFLOAD_COEFF, and returns the current value of
the filter coefficient used by the pfLoadBalance object associated with
the pfCompositor.
setViewport specifies the screen-space bounds of the region managed by a
pfCompositor. The viewports assigned to all pipes managed by this
compositor will be clipped to this region. The default viewport for a
pfCompositor is: 0.0, 1.0, 0.0, 1.0 (the whole screen). setViewport
should not be called for compositor-children in compositor hierarchies
Page 12
pfCompositor(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
(use setChildViewport on parent compositor instead).
getViewport returns the screen-space bounds of the region managed by a
pfCompositor.
setChildViewport specifies the screen-space bounds of the 2d region
assigned to the i-th child of the pfCompositor. The specified viewport is
automatically clipped to the viewport of the compositor, and aligned
horizontally to a four-pixel boundary (required by hardware compositor
devices). The default viewports of a pfCompositor's children are
determined based on the number of active children and on the current
composition mode (see setMode above).
Note that when dynamic load balancing is active, setting children
viewports through setChildViewport will have no effect.
getChildViewport returns the screen-space bounds of the 2d region managed
by the i-th child of the pfCompositor. This region will always be
contained by the viewport of the pfCompositor itself.
Note that all viewports are specified in normalized screen coordinates,
with 0.0,0.0 being the bottom-left corner of the screen, and 1.0,1.0
being the top-right corner.
setChannelClipped specifies whether channel-clipping should be enabled
for the i-th channel. Channel clipping is enabled on all channels by
default. Channel clipping is not performed if it is globally disabled
through a call to setMode. Disabling clipping on a pfChannel can be
useful in certain situations. For example, perfly's GUI channel has
clipping disabled and is rendered entirely on master pipe. Note that
perfly also assignes a non-full-screen viewport to the pfCompositor when
the GUI is displayed.
getChannelClipped returns 1 if channel-clipping is enabled for the i-th
channel, or 0 otherwise (or if i is not a valid index).
A pfCompositor maintains a list of jitter patterns to be used for
AntiAlias mode depending on the number of active children. A jitter
pattern is encoded as an array of sub-pixel offsets, with two floats
(horizontal and vertical offset) for each contributing child.
setAntialiasJitter specifies the jitter pattern to be used for anti-alias
composition, when there are n active children. jitter must point to an
array of floats containing 2*n values, specifying sub-pixel offsets
(horizontal and vertical) for each of the n contributing inputs.
getAntialiasJitter returns the jitter pattern to be used for anti-alias
composition when there are n active children. jitter must point to an
array of floats with at least 2*n elements, which will contain the
queried jitter values on return.
Page 13
pfCompositor(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
BUGS
Compositor hierarchies are not supported in Performer 3.2
SEE ALSO
pfLoadBalance, pfChannel, pfMultipipe, glXQueryHyperpipeNetworkSGIX,
glXBindHyperpipeSGIX, glXBindSwapBarrierSGIX
Page 14
