Do not load any models in this member function. This sort of operation should be done within initScene().

The following application class is called simplePfApp. It is derived from vrj::PfApp and has custom initScene() and getScene() methods declared. Note that this application uses preForkInit() which will be discussed later. Refer to simplePfApp.h for the implementations of preForkInit() and setModel().

  1 class simplePfApp : public vrj::PfApp
    {
    public:
       simplePfApp();
  5    virtual ~simplePfApp();
    
       virtual void preForkInit();
       virtual void initScene();
       virtual pfGroup* getScene();
 10    void setModel(std::string modelFile);
    
    public:
       std::string    mModelFileName;
    
 15    pfGroup*       mLightGroup;
       pfLightSource* mSun;
       pfGroup*       mRootNode;
       pfNode*        mModelRoot;
    };

The implementation of initScene() is in simplePfApp.cpp. Within this method, we create the scene graph root node, the lighting node, and load a user-specified model. The implementation follows:

  1 void simplePfApp::initScene ()
    {
       // Allocate all the nodes needed
       mRootNode = new pfGroup;                                
  5 
       // Create the SUN light source
       mLightGroup = new pfGroup;                              
       mSun = new pfLightSource;
       mLightGroup->addChild(mSun);
 10    mSun->setPos(0.3f, 0.0f, 0.3f, 0.0f);
       mSun->setColor(PFLT_DIFFUSE, 1.0f, 1.0f, 1.0f);
       mSun->setColor(PFLT_AMBIENT, 0.3f, 0.3f, 0.3f);
       mSun->setColor(PFLT_SPECULAR, 1.0f, 1.0f, 1.0f);
       mSun->on();
 15 
       // --- LOAD THE MODEL -- //
       mModelRoot = pfdLoadFile(mModelFileName.c_str());       
    
       // -- CONSTRUCT STATIC STRUCTURE OF SCENE GRAPH -- //
 20    mRootNode->addChild(mModelRoot);                        
       mRootNode->addChild(mLightGroup);                       
    }

	First, the root node is constructed as a pfGroup object.
	Next, some steps are taken to create a light source for the application.
	Finally, the model is loaded using pfdLoadFile(), and the model scene graph root node is stored in mModelRoot. (The model loader must be initialized prior to calling pfdLoadFile(). This is done in preForkInit().)
	Finally, the model and the light source nodes are added as children of the root.

The Performer Draw Manager will call the application's getScene() method to get the root of the scene graph. The implementation of this method can be found in simplePfApp.h. The code is as follows:

pfGroup* simplePfApp::getScene ()
{
   return mRootNode;
}

The simplicity of this method implementation is not limited to the simple tutorial from which it is taken. All Performer-based VR Juggler applications can take advantage of this idiom where the root node is a member variable returned in getScene().

Prototype: public void preForkInit();

This member function allows the user application to do any processing that needs to happen before Performer forks its processes but after pfInit() is called. In other words, it is invoked after pfInit() but before pfConfig().

Prototype: public void appChanFunc(pfChannel* chan);

This method is called every frame in the application process for each active channel. It is called immediately before rendering (pfFrame()).

Prototype: public void configPWin(pfPipeWindow* pWin);

This method is used to initialize a pipe window. It is called as soon as the pipe window is opened.

Prototype: public std::vector<int> getFrameBufferAttrs();

This method returns the needed parameters for the Performer frame buffer. Stereo, double buffering, depth buffering, and RGBA are all requested by default.

Prototype: public void drawChan(pfChannel* chan,
                     void* chandata);

This is the method called in the channel draw function to do the actual rendering. For most programs, the default behavior of this function is correct. It makes the following calls:

chan->clear();
pfDraw();

Advanced users may want to override this behavior for complex rendering effects such as overlays or multi-pass rendering. (See the OpenGL Performer manual pages about overriding the draw traversal function.) This function is the draw traversal function but with the projections set correctly for the given displays and eye. Prior to the invocation of this method, chan is ready to draw.

Prototype: public void preDrawChan(pfChannel* chan,
                        void* chandata);

This is the function called by the default drawChan() member function before clearing the channel and drawing the next frame (pfFrame()).

Prototype: public void postDrawChan(pfChannel* chan,
                         void* chandata);

This is the function called by the default drawChan() member function after clearing the channel and drawing the next frame (pfFrame()).