pfVertexProgram(3pf) OpenGL Performer 3.2.2 libpr C++ Reference Pages
NAMEpfVertexProgram - class for specifying vertex programs
FUNCTION SPECIFICATION
#include <Performer/pr/pfVertexProgram.h>
pfVertexProgram::pfVertexProgram();
pfType * pfVertexProgram::getClassType(void);
PARENT CLASS FUNCTIONS
The OpenGL Performer class pfVertexProgram is derived from the parent
class pfGProgram, so each of these member functions of class pfGProgram
are also directly usable with objects of class pfVertexProgram. This is
also true for ancestor classes of class pfGProgram.
pfType * pfGProgram::getClassType(void);
int pfGProgram::loadProgram(const char *filename);
void pfGProgram::setProgram(const char *code);
void pfGProgram::setProgram(const char *code, int length);
void pfGProgram::getProgram(char **code);
int pfGProgram::getProgramLength();
int pfGProgram::getNativeProgramLength();
int pfGProgram::isValid();
Since the class pfGProgram is itself derived from the parent class
pfObject, objects of class pfVertexProgram can also be used with these
functions designed for objects of class pfObject.
void* pfObject::operator new(size_t);
void* pfObject::operator new(size_t, void *arena);
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 pfVertexProgram 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);
Page 1
pfVertexProgram(3pf) OpenGL Performer 3.2.2 libpr C++ Reference Pages
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();
int pfMemory::checkDelete();
int pfMemory::isFluxed();
void * pfMemory::getArena();
int pfMemory::getSize();
DESCRIPTION
The pfVertexProgram is a class derived from the class pfGProgram. The
class does not add any new method. Vertex programs are used by the GPU
to modify various parameters of each vertex. GPU is a programmable
graphics processing unit of a modern graphics hardware, used for example
in Onyx4. This GPU allows the user to specify a sequence of floating-
point 4-component operations that are executed for each vertex. These
operations transform an input set of per-vertex parameters to a set of
per-vertex result parameters.
A vertex program replaces the standard OpenGL set of lighting and texture
coordinate generation modes. Consequently the vertex program has to take
care of the basic transformation of vertex coordinates to the screen
coordinates, generating texture coordinatets, and applying the lighting
equation. On the other hand, this allows the user to modify the position
of each vertex, producing, for example, a displacement mapping. A
description of vertex program instruction set is beyond the scope of this
man page. You can find it in OpenGL extension registry at
http://oss.sgi.com/projects/ogl-sample/registry/ under
GL_ARB_vertex_program.
A pfVertexProgram is a sequence of assembly-like instructions that are
specified in a string, with new line character separating each
instruction, or from a text file. If the program is specified in a
string, you use method pfVertexProgram::setProgram. The first parameter
is the string defining the program. Optionally, you can specify the
length, in case you want to load only part of the string. If the program
is loaded from a text file, you use the method
pfVertexProgram::loadProgram.
You can apply the pfVertexProgram using pfVertexProgram::apply, but only
in the draw process. Once the pfVertexProgram has been applied, you can
query its state using the following methods:
pfVertexProgram::getProgramLength, which return the number of
instructions of the program, pfVertexProgram::getNativeProgramLength,
which returns the number of instructions used by the specific GPU, and
Page 2
pfVertexProgram(3pf) OpenGL Performer 3.2.2 libpr C++ Reference Pages
pfVertexProgram::isValid, which returns 1 if the program has been
successfully loaded into the GPU.
A pfVertexProgram is set and enabled in a pfGeoState. The user parameters
for vertex programs can be defined using the class pfGProgramParms. See
the pfGProgramParms man page and the sample code in
/usr/share/Performer/src/pguide/libpf/C++/gprogram.C.
SEE ALSO
pfGProgram, pfFragmentProgram, pfGProgramParms, pfGeoState, pfTexture,
pfObject.
Page 3
