vrj::PfDrawManager Class Reference

Concrete singleton class for API-specific Draw Manager for OpenGL Performer. More...

#include <vrj/Draw/Pf/PfDrawmanager.h>

Inheritance diagram for vrj::PfDrawManager:

[legend]Collaboration diagram for vrj::PfDrawManager:

[legend]List of all members.

Public Member Functions
virtual void	sync ()
	Blocks until the end of the frame.
virtual void	draw ()
	Postcondition: Calls pfFrame()
pfScene *	getRootWithSim ()
	Returns the Simulator SceneGraph so that PfBasicSimulator can add/update the Head and Wand.
virtual void	setApp (App *_app)
	Sets the app the draw whould interact with.
virtual void	initAPI ()
	Postcondition: Calls pfInit() and sets up the system.
void	initChanGroupAttribs (pfChannel *masterChan)
	Initializes the parameters of the master channel.
virtual void	addDisplay (Display *disp)
	Callback when display is added to display manager.
virtual void	removeDisplay (Display *disp)
	Callback when display is removed to display manager.
virtual void	closeAPI ()
	Shuts down the drawing API.
virtual void	updatePfProjections ()
	Updates all the projections for the displays.
void	debugDump (int debugLevel)
	Helper function that finds the pfDisp given a channel.
void	debugDumpPfDisp (pfDisplay *pf_disp, int debugLevel)
virtual bool	configCanHandle (jccl::ConfigElementPtr element)
	Can the handler handle the given element?
Protected Member Functions
virtual bool	configAdd (jccl::ConfigElementPtr element)
	Adds the element to the configuration.
virtual bool	configRemove (jccl::ConfigElementPtr element)
	Removes the element from the current configuration.
bool	configDisplaySystem (jccl::ConfigElementPtr element)
	Sets up display system related attributes.
void	callAppChanFuncs ()
	Calls all the application channel callbacks.
void	updatePfProjection (pfChannel *chan, Projection *proj)
	Postcondition: chan has its view matrix set to the Performer.
void	initPerformerGraph ()
	Helper function to create the base scene graph stuff.
void	initAppGraph ()
	Helper that (re)loads the application's scene graph into the active scene(s).
void	initPipes ()
	Initializes all the pipes that may need to be used.
pfPipe *	getPfPipe (unsigned pipe_num)
	Gets a Performer pipe.
std::vector< int >	getMonoFBConfig (vrj::Display *disp)
	Returns the needed mono frame buffer config.
std::vector< int >	getStereoFBConfig (vrj::Display *disp)
	Returns the needed stereo frame buffer config.
void	configFrameBuffer (vrj::Display *disp, std::vector< int > &attrs)
	Adds frame buffer configuration options to the given vector based on the given vrj::Display object's OpenGL frame buffer configuration.
	PfDrawManager ()
virtual	~PfDrawManager ()
	vprSingletonHeader (PfDrawManager)
Display helpers
Helpers for releasing a display and the associated cruft.
void	releaseDisplay (pfDisplay &disp)
void	releaseViewport (pfDisplay &disp, pfViewport &vp)
pfPipeWindow *	allocatePipeWin (unsigned pipeNum)
void	releasePipeWin (pfPipeWindow *pipeWin, unsigned pipeNum)
Protected Attributes
unsigned int	mNumPipes
	The number of Performer pipes.
std::vector< pfPipe * >	mPipes
	Performer pipes we have opened.
std::vector< std::string >	mPipeStrs
	The X11 names of the pipes.
bool	mPfHasForked
	Performer has forked its processes already.
std::vector< std::vector< pfPipeWindow * > >	mPipeWindows
	List of (available) pipe windows grouped by pipe num.
Performer State
PfApp *	mApp
	The user application.
std::vector< pfDisplay >	mDisplays
	All Performer displays.
std::vector< PfInputHandler * >	mPfInputHandlers
	Input Handlers for all Performer windows.
std::vector< pfChannel * >	mSurfChannels
std::vector< pfChannel * >	mSimChannels
	List of sim displays.
pfChannel *	mSurfMasterChan
	Master channel.
pfChannel *	mSimMasterChan
	Master channel for simulators.
Scene graph nodes
mRoot | mSceneGroup -- mSceneRoot -- app scene / mRootWithSim mHeadDCS \ / mSimTree | mWandDCS
pfScene *	mRoot
	Root of performer tree to render.
pfGroup *	mSceneRoot
	Root of scene to render (changes at run-time).
pfGroup *	mSceneGroup
	The group node with only sceneRoot under it.
pfScene *	mRootWithSim
	The root with the simulator group & the sceneRoot.
Friends
void	PFconfigPWin (pfPipeWindow *pWin)
void	PfDrawFunc (pfChannel *chan, void *chandata, bool left_eye, bool right_eye, bool stereo)
void	PfAppFunc (pfChannel *chan, void *chandata)
Classes
struct	pfDisplay
struct	pfDisplay_disp
struct	pfViewport
	The channels associated with a viewport. More...

---

Detailed Description

Concrete singleton class for API-specific Draw Manager for OpenGL Performer.

Responsible for all Performer rendering and windowing.

Definition at line 77 of file PfDrawManager.h.

---

Constructor & Destructor Documentation

vrj::PfDrawManager::PfDrawManager

(

)

[inline, protected]

Definition at line 364 of file PfDrawManager.h.

      : mApp(NULL)
      , mSurfMasterChan(NULL)
      , mSimMasterChan(NULL)
      , mPfHasForked(false)
      , mRoot(NULL)
      , mSceneRoot(NULL)
      , mSceneGroup(NULL)
      , mRootWithSim(NULL)
   {;}

vrj::PfDrawManager::~PfDrawManager

(

)

[protected, virtual]

Definition at line 93 of file PfDrawManager.cpp.

References mPfInputHandlers.

{
   //TODO: Add thread safety.
   for ( std::vector<PfInputHandler*>::iterator itr = mPfInputHandlers.begin();
         itr != mPfInputHandlers.end() ; itr++)
   {
      delete *itr;
   }
   mPfInputHandlers.clear();
}

---

Member Function Documentation

void vrj::PfDrawManager::sync

(

)

[virtual]

Blocks until the end of the frame.

Precondition:

None.

Postcondition:

The frame has been drawn.

Implements vrj::DrawManager.

Definition at line 156 of file PfDrawManager.cpp.

References vrjDBG_DRAW_MGR().

{
   vprDEBUG(vrjDBG_DRAW_MGR,vprDBG_VERB_LVL)
      << "vrj::PfDrawManager::sync\n" << vprDEBUG_FLUSH;
   pfSync();
}

void vrj::PfDrawManager::draw

(

)

[virtual]

Postcondition:

Calls pfFrame()

Precondition:

None.

Postcondition:

Frame has been triggered to begin drawing.

Implements vrj::DrawManager.

Definition at line 166 of file PfDrawManager.cpp.

References callAppChanFuncs(), mPfInputHandlers, and updatePfProjections().

{
   vprDEBUG(vprDBG_ALL,vprDBG_VERB_LVL)
      << "[vrj::PfDrawManager::draw()] calling appChanFuncs\n"
      << vprDEBUG_FLUSH;
   callAppChanFuncs();

   updatePfProjections();

   vprDEBUG(vprDBG_ALL,vprDBG_VERB_LVL)
      << "[vrj::PfDrawManager::draw] calling pfFrame()\n" << vprDEBUG_FLUSH;

   pfFrame();

   for (std::vector<PfInputHandler*>::iterator itr = mPfInputHandlers.begin() ;
        itr != mPfInputHandlers.end() ; itr++)
   {
      (*itr)->checkEvents();
   }
}

pfScene* vrj::PfDrawManager::getRootWithSim

(

)

[inline]

Returns the Simulator SceneGraph so that PfBasicSimulator can add/update the Head and Wand.

Definition at line 153 of file PfDrawManager.h.

   {
      return mRootWithSim;
   }

void vrj::PfDrawManager::setApp

(

App *

_app

)

[virtual]

Sets the app the draw whould interact with.

Precondition:

None

Postcondition:

self'.app = _app

Implements vrj::DrawManager.

Definition at line 213 of file PfDrawManager.cpp.

References initAppGraph(), mApp, and mPfHasForked.

{
   //vprASSERT(app != NULL);
   mApp = dynamic_cast<PfApp*>(_app);
   if(mPfHasForked)
      initAppGraph();         // If pf is already started, then intialize the app scene graph

}

void vrj::PfDrawManager::initAPI

(

)

[virtual]

Postcondition:

Calls pfInit() and sets up the system.

We should call pfInit().

Configure process model.
Configure multi-pipe model.
Then call pfConfig to start the MP stuff.
Sets up channels and pWins.

Note:

Fork happens here.

Implements vrj::DrawManager.

Definition at line 228 of file PfDrawManager.cpp.

References configDisplaySystem(), vrj::DisplayManager::getDisplaySystemElement(), initAppGraph(), initPerformerGraph(), initPipes(), mApp, vrj::DrawManager::mDisplayManager, mNumPipes, mPfHasForked, mRoot, mRootWithSim, mSceneRoot, vrj::PfApp::preForkInit(), and vrjDBG_DRAW_MGR().

{
   pfInit();
   pfuInitUtil();
   
   // XXX: This call should really be triggered by a change in draw manager or something
   vprASSERT(mDisplayManager != NULL);
   configDisplaySystem(mDisplayManager->getDisplaySystemElement());    // Configure all the display system stuff

   mApp->preForkInit();

   vprDEBUG_BEGIN(vrjDBG_DRAW_MGR,vprDBG_STATE_LVL)
      << "[vrj::PfDrawManager::initAPI()] Entering." << std::endl
      << vprDEBUG_FLUSH;

   // Set params for Multi-pipe and Multiprocess
   pfMultipipe(mNumPipes);

#ifdef VPR_OS_Linux
   // Multi-processing with Performer on SMP Linux machines is unstable, and
   // there is not much of a performance gain to splitting App, Cull, and Draw
   // up among multiple processes on a single-processor machine.
   pfMultiprocess(PFMP_APPCULLDRAW);
#else
   // If we are running in a cluster then we must run in single process mode.
   if(jccl::ConfigManager::instance()->isElementTypeInPendingList("cluster_manager") ||
      jccl::ConfigManager::instance()->isElementTypeInActiveList("cluster_manager"))
   {
      vprDEBUG_BEGIN(vrjDBG_DRAW_MGR, vprDBG_STATE_LVL)
         << "PfDrawManager::initAPI() Running Performer in single process to ensure cluster synchronization."
         << std::endl << vprDEBUG_FLUSH;
      // Single process mode.
      pfMultiprocess(PFMP_APPCULLDRAW);
   }
   else
   {
      // Multiple process mode.
      pfMultiprocess(PFMP_APP_CULL_DRAW);
   }
#endif

// We can not init head and wand model loaders since they are loaded in PfBasicSimInterface
//   initLoaders();          // Must call before pfConfig

   // --- FORKS HERE --- //
   pfConfig();
   
   // Initialize shared memory for utility libraries
   pfuInit();

   mPfHasForked = true;

   // Initialize the pipes that the system may need
   // If we don't do this, then pf automatically give each pipe a big black channel
   initPipes();

   initPerformerGraph();        // Create the other scene graph nodes
   if(mApp != NULL)
      initAppGraph();           // App was already set, but pf was not loaded.  So load graph now


   vprASSERT(mRoot != NULL && "We have a NULL root in PfDrawManager");
   vprASSERT(mRootWithSim != NULL && "We have a NULL sim root scene in PfDrawManager");
   vprASSERT(mSceneRoot != NULL && "We have a NULL root scene in PfDrawManager");

   //pfFrame();

   // Dump the state
   // debugDump(vprDBG_CONFIG_LVL);

   vprDEBUG_END(vrjDBG_DRAW_MGR,vprDBG_STATE_LVL)
      << "[vrj::PfDrawManager::initAPI()] Exiting." << std::endl
      << vprDEBUG_FLUSH;
}

void vrj::PfDrawManager::initChanGroupAttribs

(

pfChannel *

masterChan

)

Initializes the parameters of the master channel.

Definition at line 838 of file PfDrawManager.cpp.

Referenced by addDisplay().

{
   //masterChan->setNearFar(0.05, 10000.0f);      // XXX: Look here near far information

   vprASSERT(masterChan != NULL);

   /*  Original code for reference
    * masterChan->setShare(PFCHAN_NEARFAR | PFCHAN_EARTHSKY |
    *                    PFCHAN_STRESS | PFCHAN_LOD | PFCHAN_SWAPBUFFERS |
    *                    PFCHAN_APPFUNC | PFCHAN_SCENE | PFCHAN_CULLFUNC | PFCHAN_STATS_DRAWMODE );
    */

   //
   // Set the Channel attribs based on cur settings
   //
   unsigned cur_share = masterChan->getShare();          // Get current setting, and OR the new stuff on
   unsigned turn_on = ( PFCHAN_NEARFAR | PFCHAN_EARTHSKY |
                        PFCHAN_STRESS | PFCHAN_LOD | PFCHAN_SWAPBUFFERS |
                        PFCHAN_APPFUNC | PFCHAN_SCENE | PFCHAN_CULLFUNC |
                        PFCHAN_STATS_DRAWMODE);
   unsigned turn_off = (   PFCHAN_FOV |
                           PFCHAN_VIEW |
                           PFCHAN_VIEW_OFFSETS |
                           PFCHAN_DRAWFUNC );

   masterChan->setShare((cur_share | turn_on) &(~turn_off));

   //masterChan->setTravFunc(PFTRAV_APP, PfAppFunc);
   //masterChan->setShare(PFCHAN_NEARFAR | PFCHAN_EARTHSKY |
   //                     PFCHAN_STRESS | PFCHAN_SWAPBUFFERS |
   //                     PFCHAN_APPFUNC | PFCHAN_CULLFUNC );
}

void vrj::PfDrawManager::addDisplay

(

Display *

disp

)

[virtual]

Callback when display is added to display manager.

Precondition:

Must be in kernel controlling thread. Must have already initialized Performer.

Implements vrj::DrawManager.

Definition at line 368 of file PfDrawManager.cpp.

References allocatePipeWin(), vrj::PfInputHandler::config(), vrj::DrawSimInterface::config(), debugDump(), vrj::PfDrawManager::pfDisplay::disp, vrj::Display::getConfigElement(), vrj::Viewport::getConfigElement(), vrj::Display::getGlFrameBufferConfig(), getMonoFBConfig(), vrj::Display::getName(), vrj::Display::getNumViewports(), vrj::Viewport::getOriginAndSize(), vrj::Display::getOriginAndSize(), getPfPipe(), vrj::Display::getPipe(), getStereoFBConfig(), vrj::Display::getViewport(), initChanGroupAttribs(), vrj::DrawSimInterface::initialize(), vrj::Viewport::isActive(), vrj::Viewport::isSimulator(), vrj::Display::isStereoRequested(), vrj::Viewport::isSurface(), mDisplays, mPfHasForked, mPfInputHandlers, mRoot, mRootWithSim, mSimChannels, mSimMasterChan, mSurfChannels, mSurfMasterChan, PFconfigPWin, vrj::PfDrawFuncMonoBackbuffer(), vrj::PfDrawFuncStereoLeft(), vrj::PfDrawFuncStereoRight(), vrj::PfDrawManager::pfViewport::PRIMARY, vrj::PfDrawManager::pfDisplay::pWin, vrj::PfDrawManager::pfViewport::SECONDARY, vrj::SimViewport::setDrawSimInterface(), vrj::Display::shouldDrawBorder(), vrj::Display::shouldHideMouse(), vrj::PfDrawManager::pfDisplay::viewports, and vrjDBG_DRAW_MGR().

{
   vprASSERT(disp != NULL);    // Can't add a null display
   vprASSERT((true == mPfHasForked) && "Trying to add display when performer has not been initialized");

   //  For the display
   //     -Create a pWin for it
   //     - For each viewport
   //        - Create viewport
   //        - Create channels for the viewports
   vprDEBUG_OutputGuard(vrjDBG_DRAW_MGR, vprDBG_STATE_LVL,
                        std::string("vrj::PfDrawManager: ---- Opening new Display --------\n"),
                        std::string("vrj::PfDrawManager: ---- Display Open (done) --------\n"));



   pfDisplay pf_disp;            // The pfDisplay to use
   pf_disp.disp = disp;

   vprDEBUG(vrjDBG_DRAW_MGR,vprDBG_CONFIG_LVL) << "\tDisplay is:" << (void*)(disp) << std::endl << vprDEBUG_FLUSH;
   vprDEBUG(vrjDBG_DRAW_MGR,vprDBG_CONFIG_LVL) << "\tPfDrawManager::add Display: Got Display:\n" << (*disp) << vprDEBUG_FLUSH;

   int xo, yo, xs, ys;
   pfPipe* pipe = getPfPipe(disp->getPipe());      // Get the pipe

   // Make sure we have a good pipe.  If not, there isn't anything we can do
   // to recover.
   if ( NULL == pipe )
   {
      vprASSERT(NULL != pipe);
      return;
   }

   // --- SETUP PWIN --- //
   pf_disp.pWin = allocatePipeWin(disp->getPipe());     //  new pfPipeWindow(pipe);
   vprASSERT(NULL != pf_disp.pWin);

   disp->getOriginAndSize(xo, yo, xs, ys);
   
   pf_disp.pWin->setOriginSize(xo, yo, xs, ys);

   // Setup window border
   if (disp->shouldDrawBorder())
      pf_disp.pWin->setName(disp->getName().c_str()); // Give the window a name
   else
      pf_disp.pWin->setMode(PFWIN_NOBORDER, 1);          // Get rid of that border

   jccl::ConfigElementPtr fb_elt = disp->getGlFrameBufferConfig();
   const int visual_id = fb_elt->getProperty<int>("visual_id");

   // If the user requested a specific visual ID, use it and ignore the rest
   // of the frame buffer configuration.
   if ( visual_id != -1 )
   {
      vprDEBUG(vrjDBG_DRAW_MGR, vprDBG_CONFIG_LVL)
         << "Requesting visual 0x" << std::hex << visual_id << std::dec
         << "." << std::endl << vprDEBUG_FLUSH;
      pf_disp.pWin->setFBConfigId(visual_id);
   }
   else
   {
      // Setup Frame Buffer config
      if (disp->isStereoRequested())                     // If we need stereo
      {
         std::vector<int> fb_config = getStereoFBConfig(disp);

#ifdef VJ_DEBUG
         // ouput debug info about the frame buffer config recieved
         vprDEBUG(vrjDBG_DRAW_MGR, vprDBG_VERB_LVL)
            << "[vrj::PfDrawManager::addDisplay()] Got Stereo FB config\n"
            << vprDEBUG_FLUSH;
         for ( unsigned int i = 0; i < fb_config.size(); ++i )
         {
            vprDEBUG_CONT(vrjDBG_DRAW_MGR, vprDBG_VERB_LVL)
               << "  " << fb_config[i] << vprDEBUG_FLUSH;
         }
#endif

         vprDEBUG(vrjDBG_DRAW_MGR, vprDBG_CONFIG_LVL)
            << "[vrj::PfDrawManager::addDisplay()] "
            << "Configuring stereo window attribs.\n" << vprDEBUG_FLUSH;
         pf_disp.pWin->setFBConfigAttrs(&(fb_config[0]));     // Configure framebuffer for stereo
      }
      else
      {
         // Get frame buffer config
         std::vector<int> fb_config = getMonoFBConfig(disp);

#ifdef VJ_DEBUG
         // ouput debug info about the frame buffer config recieved
         vprDEBUG(vrjDBG_DRAW_MGR,vprDBG_VERB_LVL)
            << "[vrj::PfDrawManager::addDisplay()] Got Mono FB config\n"
            << vprDEBUG_FLUSH;
         for ( unsigned int j = 0 ; j < fb_config.size(); ++j )
         {
            vprDEBUG_CONT(vrjDBG_DRAW_MGR,vprDBG_VERB_LVL)
               << "  " << fb_config[j] << std::endl << vprDEBUG_FLUSH;
         }
         vprDEBUG_CONT(vrjDBG_DRAW_MGR,vprDBG_VERB_LVL)
            << std::endl << vprDEBUG_FLUSH;
#endif

         vprDEBUG(vrjDBG_DRAW_MGR,vprDBG_CONFIG_LVL)
            << "[vrj::PfDrawManager::addDisplay()] "
            << "Configuring mono window attribs.\n" << vprDEBUG_FLUSH;
         pf_disp.pWin->setFBConfigAttrs(&(fb_config[0]));       // Configure a "norm" window
      }
   }

   // -- Set config info -- //
   pf_disp.pWin->setConfigFunc(PFconfigPWin);   // Set config function
   pf_disp.pWin->config();                      // Next pfFrame, config Func will be called

   // --- SETUP VIEWPORTS --- //
   // for(each viewport)
   //   - Allocate channels
   //   - Set draw functions
   //   - Setup master chans
   Viewport* viewport = NULL;
   unsigned num_vps = disp->getNumViewports();

   vprDEBUG(vrjDBG_DRAW_MGR, vprDBG_CONFIG_LVL) << "   Num viewports: " << num_vps << std::endl << vprDEBUG_FLUSH;
   for(unsigned vp_num=0; vp_num < num_vps; vp_num++)
   {
      viewport = disp->getViewport(vp_num);

      if(viewport->isActive())      // is viewport active
      {
         //Viewport::View view = viewport->getView();
         pfViewport pf_viewport;                         // The viewport to build up
         pf_viewport.viewport = viewport;
         float vp_ox, vp_oy, vp_sx, vp_sy;

         // Get channel info
         // Primary channel - (Left in stereo)
         viewport->getOriginAndSize(vp_ox, vp_oy, vp_sx, vp_sy);
         pf_viewport.chans[pfViewport::PRIMARY] = new pfChannel(pipe);
         pf_viewport.chans[pfViewport::PRIMARY]->setViewport(vp_ox, vp_ox+vp_sx, vp_oy, vp_oy+vp_sy);
         pf_disp.pWin->addChan(pf_viewport.chans[pfViewport::PRIMARY]);

         // Secondary channel - (Right in stereo)
         if(disp->isStereoRequested())
         {
            pf_viewport.chans[pfViewport::SECONDARY] = new pfChannel(pipe);
            pf_viewport.chans[pfViewport::SECONDARY]->setViewport(vp_ox, vp_ox+vp_sx, vp_oy, vp_oy+vp_sy);
            pf_disp.pWin->addChan(pf_viewport.chans[pfViewport::SECONDARY]);
         }

         // Set draw function
         if(disp->isStereoRequested())
         {
            pf_viewport.chans[pfViewport::PRIMARY]->setTravFunc(PFTRAV_DRAW, PfDrawFuncStereoLeft);
            pf_viewport.chans[pfViewport::SECONDARY]->setTravFunc(PFTRAV_DRAW, PfDrawFuncStereoRight);
         }
         else
         {
            pf_viewport.chans[pfViewport::PRIMARY]->setTravFunc(PFTRAV_DRAW, PfDrawFuncMonoBackbuffer);
         }

         // if surface ==> Setup surface channels
         if (viewport->isSurface())
         {
            vprASSERT(pf_viewport.chans[pfViewport::PRIMARY] != NULL);

            // Primary
            if(NULL == mSurfMasterChan)      // If NULL, then add us as the new one
            {
               mSurfMasterChan = pf_viewport.chans[pfViewport::PRIMARY];
               mSurfMasterChan->setScene(mRoot);
               initChanGroupAttribs(mSurfMasterChan);
               mSurfChannels.push_back(mSurfMasterChan);
            }
            else
            {
               mSurfChannels.push_back(pf_viewport.chans[pfViewport::PRIMARY]);
               mSurfMasterChan->attach(pf_viewport.chans[pfViewport::PRIMARY]);
            }

            // Secondary
            if(NULL != pf_viewport.chans[pfViewport::SECONDARY])
            {
               mSurfChannels.push_back(pf_viewport.chans[pfViewport::SECONDARY]);
               mSurfMasterChan->attach(pf_viewport.chans[pfViewport::SECONDARY]);
            }

         }
         // if sim ==> setup sim channels
         else if(viewport->isSimulator())
         {
            // -- Finish Simulator setup
            jccl::ConfigElementPtr vp_element = viewport->getConfigElement();

            SimViewport* sim_vp(NULL);
            sim_vp = dynamic_cast<SimViewport*>(viewport);
            vprASSERT(NULL != sim_vp);

            sim_vp->setDrawSimInterface(NULL);

            // Create the simulator stuff
            vprASSERT(1 == vp_element->getNum("simulator_plugin") && "You must supply a simulator plugin.");

            jccl::ConfigElementPtr sim_element =
               vp_element->getProperty<jccl::ConfigElementPtr>("simulator_plugin");

            vprDEBUG(vrjDBG_DRAW_MGR, vprDBG_CONFIG_LVL)
               << "PfDrawManager::addDisplay() creating simulator of type '"
               << sim_element->getID() << "'\n" << vprDEBUG_FLUSH;

            DrawSimInterface* new_sim_i =
               PfSimInterfaceFactory::instance()->createObject(sim_element->getID());

            // XXX: Change this to an error once the new simulator loading code is
            // more robust.  -PH (4/13/2003)
            vprASSERT(NULL != new_sim_i && "Failed to create draw simulator");
            sim_vp->setDrawSimInterface(new_sim_i);
            new_sim_i->initialize(sim_vp);
            new_sim_i->config(sim_element);


            vprASSERT(pf_viewport.chans[pfViewport::PRIMARY] != NULL);

            // Primary
            if(NULL == mSimMasterChan)        // If NULL, then make us the master
            {
               mSimMasterChan = pf_viewport.chans[pfViewport::PRIMARY];
               mSimMasterChan->setScene(mRootWithSim);       // Set the shared "normal" scene
               initChanGroupAttribs(mSimMasterChan);       // Setup the channel group attribs
               mSimChannels.push_back(mSimMasterChan);
            }
            else
            {
               mSimChannels.push_back(pf_viewport.chans[pfViewport::PRIMARY]);
               mSimMasterChan->attach(pf_viewport.chans[pfViewport::PRIMARY]);
            }

            // Secondary
            if(NULL != pf_viewport.chans[pfViewport::SECONDARY])
            {
               mSimChannels.push_back(pf_viewport.chans[pfViewport::SECONDARY]);
               mSimMasterChan->attach(pf_viewport.chans[pfViewport::SECONDARY]);
            }
         }

         // Add viewport to the display list
         pf_disp.viewports.push_back(pf_viewport);

      }  // is viewport active
   }     // for each viewport

   // -- Add new pfDisp to disp Vector -- //
   mDisplays.push_back(pf_disp);

   // Call pfFrame to cause the pipeWindow configured to be opened and setup.
   pfFrame();
   
   // This is neccessary because it may take a couple
   // frames for the window to fully open. This information was
   // found in "man pfPipeWindow".

   // Performer says that if you trigger a window from the applciation proccess
   // you must wait for the window to open during the draw process.
   while( !pfIsPWinOpen( pf_disp.pWin ) )
   {
      pfFrame();
      vpr::System::usleep( 500 ); 
   }

   PfInputHandler* new_input_handler = new PfInputHandler(pf_disp.pWin, disp->getName());
   
   // Configure the Performer window to accept events.
   jccl::ConfigElementPtr display_elt = disp->getConfigElement();
   new_input_handler->config(display_elt, disp);

   
   mPfInputHandlers.push_back(new_input_handler);

   if(pf_disp.disp->shouldHideMouse())
   {
      pfuLoadPWinCursor(pf_disp.pWin, PFU_CURSOR_OFF);
   }
   
   // Dump the state
   vprDEBUG(vrjDBG_DRAW_MGR, vprDBG_CONFIG_LVL)
      << "Reconfiged the pfDrawManager.\n" << vprDEBUG_FLUSH;
   //vprDEBUG(vrjDBG_DRAW_MGR, vprDBG_CONFIG_LVL) << (*this) << vprDEBUG_FLUSH;
   debugDump(vprDBG_CONFIG_LVL);
}

void vrj::PfDrawManager::removeDisplay

(

Display *

disp

)

[virtual]

Callback when display is removed to display manager.

Precondition:

disp must be a valid display that we have.

Postcondition:

Window for disp is removed from the draw manager and child pipes.

Implements vrj::DrawManager.

Definition at line 689 of file PfDrawManager.cpp.

References mDisplays, releaseDisplay(), and vrjDBG_DRAW_MGR().

{
   // Find the pfDisplay
#ifdef VPR_OS_Windows
   // Visual C++ does not have std::compose1(), so we have to do this the
   // tedious, non-template-coolness way.
   std::vector<pfDisplay>::iterator disp_i;
   for ( disp_i = mDisplays.begin(); disp_i != mDisplays.end(); ++disp_i )
   {
      if ( disp == (*disp_i).disp )
      {
         break;
      }
   }
#else
   std::vector<pfDisplay>::iterator disp_i = std::find_if(mDisplays.begin(), mDisplays.end(),
                         std::compose1( std::bind2nd( std::equal_to<Display*>(),disp),
                                        pfDisplay_disp()) );
#endif


   if(mDisplays.end() == disp_i)
   {
      vprDEBUG(vrjDBG_DRAW_MGR, vprDBG_CRITICAL_LVL) << "ERROR: PfDrawManager::removeDisplay: Tried to remove a non-existant display\n" << vprDEBUG_FLUSH;
      return;
   }


   // Release the pfDisplay
   releaseDisplay(*disp_i);

   // Remove display from the list
   mDisplays.erase(disp_i);
}

void vrj::PfDrawManager::closeAPI

(

)

[virtual]

Shuts down the drawing API.

Implements vrj::DrawManager.

Definition at line 1169 of file PfDrawManager.cpp.

{
   // NOTE: We do not call pfExit() here because it would cause the whole
   // process to exit.  If users want to call pfExit(), they must do so on
   // their own at whatever time is appropriate for their application.
   pfuExitUtil();
}

void vrj::PfDrawManager::updatePfProjections

(

)

[virtual]

Updates all the projections for the displays.

Postcondition:

All windows have the projections correctly set.

Definition at line 1177 of file PfDrawManager.cpp.

References vrj::App::getDrawScaleFactor(), vrj::Viewport::getLeftProj(), vrj::Viewport::getRightProj(), vrj::Viewport::getView(), vrj::Viewport::isSimulator(), vrj::Viewport::LEFT_EYE, mApp, vrj::DrawManager::mDisplayManager, mDisplays, vrj::PfDrawManager::pfViewport::PRIMARY, vrj::Viewport::RIGHT_EYE, vrj::PfDrawManager::pfViewport::SECONDARY, vrj::Viewport::STEREO, updatePfProjection(), vrj::DisplayManager::updateProjections(), vrj::PfSimInterface::updateSimulatorSceneGraph(), and vrjDBG_DRAW_MGR().

Referenced by draw().

{
   vprDEBUG(vrjDBG_DRAW_MGR,vprDBG_VERB_LVL)
      << "[vrj::PfDrawManager::updatePfProjections()] Entering." << std::endl
      << vprDEBUG_FLUSH;

   // Update display projections
   float scale_factor = mApp->getDrawScaleFactor();
   mDisplayManager->updateProjections(scale_factor);

   // --- Update the channel projections --- //
   //for(each pfDisp)
   //   for(each viewport)
   //       update Performer specific stuff.
   for (unsigned disp_id=0;disp_id<mDisplays.size();disp_id++)    // each display
   {
      pfDisplay* cur_disp = &(mDisplays[disp_id]);

      vprASSERT(cur_disp->disp != NULL);
      for(unsigned vp=0;vp<cur_disp->viewports.size();vp++)       // each viewport
      {
         pfViewport* pf_vp = &(cur_disp->viewports[vp]);
         vprASSERT(pf_vp != NULL);
         vprASSERT(pf_vp->viewport != NULL);

         /*
         SurfaceViewport* surf_vp(NULL);
         */

         Viewport* cur_vp(pf_vp->viewport);
         Viewport::View view;

         // --- All viewports --- //
         //surf_vp = dynamic_cast<SurfaceViewport*>(pf_vp->viewport);
         //vprASSERT(surf_vp != NULL && "Could not cast supposedly surface display to SurfaceDisplay.");
         view = cur_vp->getView();

         if(Viewport::LEFT_EYE == view)
         {
            updatePfProjection(pf_vp->chans[pfViewport::PRIMARY], cur_vp->getLeftProj());
         }
         else if(Viewport::RIGHT_EYE == view)
         {
            updatePfProjection(pf_vp->chans[pfViewport::PRIMARY], cur_vp->getRightProj());
         }
         else if(Viewport::STEREO == view)
         {
            updatePfProjection(pf_vp->chans[pfViewport::PRIMARY], cur_vp->getLeftProj());
            updatePfProjection(pf_vp->chans[pfViewport::SECONDARY], cur_vp->getRightProj());
         }
         else
         {
            vprASSERT(false && "[vrj::PfDrawManager::updateProjections()] We don't have a valid display type, don't know what to do");
         }

         // Sim viewport
         if(cur_vp->isSimulator())
         {
            SimViewport*      sim_vp(NULL);
            PfSimInterface*   draw_sim_i(NULL);

            sim_vp = dynamic_cast<SimViewport*>(pf_vp->viewport);
            vprASSERT(sim_vp != NULL && "Could not cast supposed simulator display to SimDisplay.");

            draw_sim_i = dynamic_cast<PfSimInterface*>(sim_vp->getDrawSimInterface());
            vprASSERT(draw_sim_i != NULL && "Could not cast supposed simulator interface to PfSimInterface.");

            draw_sim_i->updateSimulatorSceneGraph();
         }

      }
   }
}

void vrj::PfDrawManager::debugDump

(

int

debugLevel

)

Helper function that finds the pfDisp given a channel.

This function just loops through all the entries in the disps variable, looking for one that contains the channel. When it is found, it is returned.

Note:

The "cool" STL functor search didn't work for some reason.

Definition at line 1345 of file PfDrawManager.cpp.

References debugDumpPfDisp(), mApp, mDisplays, mRoot, mRootWithSim, and vrjDBG_DRAW_MGR().

Referenced by addDisplay().

{
   vprDEBUG_BEGIN(vrjDBG_DRAW_MGR,debugLevel)
      << "-- DEBUG DUMP --------- "
      << clrOutNORM(clrCYAN,"vrj::PfDrawManager: 0x")
      << std::hex << (void*)this << " ------------" << std::dec << std::endl
      << vprDEBUG_FLUSH;
   vprDEBUG_NEXT(vrjDBG_DRAW_MGR,debugLevel)
      << "App: 0x" << std::hex << (void*)mApp << std::dec << std::endl
      << vprDEBUG_FLUSH;
   vprDEBUG_NEXT(vrjDBG_DRAW_MGR,debugLevel)
      << "Scene: 0x" << std::hex << (void*)mRoot << std::dec << std::endl
      << vprDEBUG_FLUSH;
   vprDEBUG_NEXT(vrjDBG_DRAW_MGR,debugLevel)
      << "Sim scene: 0x" << std::hex << (void*)mRootWithSim << std::dec
      << std::endl << vprDEBUG_FLUSH;
   vprDEBUG_NEXT(vrjDBG_DRAW_MGR,debugLevel)
      << "Number of displays: " << mDisplays.size() << std::endl
      << vprDEBUG_FLUSH;

   for (std::vector<pfDisplay>::iterator i = mDisplays.begin(); i != mDisplays.end(); i++)
   {
      debugDumpPfDisp(&(*i),debugLevel);
   }

   vprDEBUG_END(vrjDBG_DRAW_MGR,debugLevel) << "-------- Dump end ----\n" << vprDEBUG_FLUSH;
}

void vrj::PfDrawManager::debugDumpPfDisp	(	pfDisplay *	pf_disp,
		int	debugLevel
	)

Definition at line 1374 of file PfDrawManager.cpp.

References vrj::PfDrawManager::pfDisplay::disp, vrj::PfDrawManager::pfDisplay::pWin, vrj::PfDrawManager::pfDisplay::viewports, and vrjDBG_DRAW_MGR().

Referenced by debugDump().

{
   vprDEBUG_BEGIN(vrjDBG_DRAW_MGR,debugLevel)
      << "Display: " << (void*)(pf_disp->disp) << std::endl << vprDEBUG_FLUSH;
   vprDEBUG_NEXT(vrjDBG_DRAW_MGR,debugLevel)
      << "pWin: " << (void*)(pf_disp->pWin) << std::endl << vprDEBUG_FLUSH;
   vprDEBUG_NEXT(vrjDBG_DRAW_MGR,debugLevel)
      << "visual ID: 0x" << std::hex << pf_disp->pWin->getFBConfigId()
      << std::dec << std::endl << vprDEBUG_FLUSH;

   for(unsigned vp=0; vp<pf_disp->viewports.size(); ++vp)
   {
      vprASSERT((pf_disp->viewports[vp].viewport != NULL) && "NULL viewport in pf_disp. Check if it was ever set.");

      vprDEBUG_NEXT(vrjDBG_DRAW_MGR,debugLevel) << "Viewport: " << vp << vprDEBUG_FLUSH;
      vprDEBUG_NEXT(vrjDBG_DRAW_MGR,debugLevel) << "      vp: " << *(pf_disp->viewports[vp].viewport) << vprDEBUG_FLUSH;

      for(int ch=0;ch<2;ch++)
      {
         pfChannel* cur_chan = pf_disp->viewports[vp].chans[ch];
         unsigned chan_mask(0);
         if(cur_chan != NULL)
            chan_mask = cur_chan->getShare();
         vprDEBUG_NEXT(vrjDBG_DRAW_MGR,debugLevel)
              << "chan:" << ch << " -- " << (void*)cur_chan
              << "  shared: FOV:" << (chan_mask & PFCHAN_FOV)
              << " Scene:" << (chan_mask & PFCHAN_SCENE)
              << " AppFunc:" << (chan_mask & PFCHAN_APPFUNC)
              << " SwapBuff:" << (chan_mask & PFCHAN_SWAPBUFFERS)
              << " SwapBuff-HW:" << (chan_mask & PFCHAN_SWAPBUFFERS_HW)
              << std::endl << vprDEBUG_FLUSH;
      }
   }

   vprDEBUG_CONT_END(vrjDBG_DRAW_MGR,debugLevel) << vprDEBUG_FLUSH;
}

virtual bool vrj::PfDrawManager::configCanHandle

(

jccl::ConfigElementPtr

element

)

[inline, virtual]

Can the handler handle the given element?

Returns:

true if we can handle it; false otherwise.

Definition at line 211 of file PfDrawManager.h.

   {
      boost::ignore_unused_variable_warning(element);
      return false;
   }

virtual bool vrj::PfDrawManager::configAdd

(

jccl::ConfigElementPtr

element

)

[inline, protected, virtual]

Adds the element to the configuration.

Precondition:

configCanHandle(element) == true.

Returns:

false.

Definition at line 223 of file PfDrawManager.h.

   {
      boost::ignore_unused_variable_warning(element);
      vprDEBUG(vprDBG_ALL,vprDBG_CRITICAL_LVL)
         << "vrj::PfDrawManager::configAdd: configAdd is not supported.\n"
         << vprDEBUG_FLUSH;
      return false;
   }

virtual bool vrj::PfDrawManager::configRemove

(

jccl::ConfigElementPtr

element

)

[inline, protected, virtual]

Removes the element from the current configuration.

Precondition:

configCanHandle(element) == true.

Returns:

false.

Definition at line 237 of file PfDrawManager.h.

   {
      boost::ignore_unused_variable_warning(element);
      vprDEBUG(vprDBG_ALL,vprDBG_CRITICAL_LVL)
         << "vrj::PfDrawManager::configRemove: configRemove is not supported.\n"
         << vprDEBUG_FLUSH;
      return false;
   }

bool vrj::PfDrawManager::configDisplaySystem

(

jccl::ConfigElementPtr

element

)

[protected]

Sets up display system related attributes.

Precondition:

element is a config element of the "dispaySystem" type.

Note:

MUST be called before initDrawing.

This must be called by the draw manager because the element must be gotten from the draw manager.

Definition at line 107 of file PfDrawManager.cpp.

References mNumPipes, mPipeStrs, and vrjDBG_DRAW_MGR().

Referenced by initAPI().

{
   vprASSERT(element.get() != NULL);
   vprASSERT(element->getID() == std::string("display_system"));

   // ---- SETUP PipeStr's ---- //
   vprDEBUG_BEGIN(vrjDBG_DRAW_MGR,vprDBG_CONFIG_LVL)
      << "------------- PfDrawManager::config ----------------" << std::endl
      << vprDEBUG_FLUSH;
   mNumPipes = element->getProperty<unsigned int>("number_of_pipes");

   vprDEBUG(vrjDBG_DRAW_MGR,vprDBG_CONFIG_LVL) << "NumPipes: " << mNumPipes
                                            << std::endl << vprDEBUG_FLUSH;

   // Make sure that the user has specified a valid number of pipes in the
   // configuration. This becomes an issue normally since the default number of
   // pipes when creating a new display_system element is 0. It needs to be this
   // because we can not fill in the list of pipes with default values.
   if(mNumPipes < 1)
   {
      mNumPipes = 1;
   }

   for (unsigned int i=0;i<mNumPipes;i++)
   {
      std::string cur_disp_name = "-1";

      // NOTE: ConfigElements return the default value for a property if a value is
      //       not present. So if a pipe string is not specified for this pipe then
      //       it gets the default value of "-1".
      mPipeStrs.push_back(element->getProperty<std::string>("x11_pipes", i));

      if(mPipeStrs[i] == cur_disp_name)    // Use display env
      {
         std::string display_env;
         vpr::System::getenv("DISPLAY", display_env);

         if ( ! display_env.empty() )
         {
            mPipeStrs[i] = display_env;
         }
      }
      vprDEBUG(vrjDBG_DRAW_MGR,vprDBG_CONFIG_LVL) << "Pipe:" << i << ": "
                                               << mPipeStrs[i] << std::endl
                                               << vprDEBUG_FLUSH;
   }
   return true;
}

void vrj::PfDrawManager::callAppChanFuncs

(

)

[protected]

Calls all the application channel callbacks.

Definition at line 189 of file PfDrawManager.cpp.

References vrj::PfApp::appChanFunc(), mApp, and mDisplays.

Referenced by draw().

{
   // for(each display)
   //    for(each viewport)
   //       for(each channel)
   for(unsigned int dispIndex=0;dispIndex<mDisplays.size();dispIndex++)
   {
      for(unsigned vp=0;vp<mDisplays[dispIndex].viewports.size();vp++)
      {
         for(unsigned ch=0;ch<2;ch++)
         {
            if(mDisplays[dispIndex].viewports[vp].chans[ch] != NULL)
               mApp->appChanFunc(mDisplays[dispIndex].viewports[vp].chans[ch]);
         }
      }
   }
}

void vrj::PfDrawManager::updatePfProjection	(	pfChannel *	chan,
		Projection *	proj
	)			[protected]

Postcondition:

chan has its view matrix set to the Performer.

Equivalent of proj's projection data.

Definition at line 1255 of file