#include <iostream.h>
#include <stdlib.h>
#include <Performer/pf.h>
#include <Performer/pf/pfChannel.h>
#include <Performer/pf/pfNode.h>
#include <Performer/pf/pfScene.h>
#include <Performer/pf/pfDCS.h>
#include <Performer/pf/pfGeode.h>
#include <Performer/pf/pfLightSource.h>
#include <Performer/pfutil.h>
#include <Performer/pfdu.h>
#include <Performer/pfui.h>
#include <Performer/pfui/pfiXformer.h>


pfiTDFXformer* xformer = NULL;
bool exitNow = false;
pfuEventStream events;

void 
handleEvents(void) 
{
  pfuGetEvents(&events);
  // process each of the events; dev is the kind of event, val is 
  // its value, such as a keyboard event with an ASCii value of 27. 
  for (int j=0; j < events.numDevs; ++j) { 
    int dev = events.devQ[j]; 
    if ( events.devCount[dev] > 0) { 
      switch ( dev ) {
      case PFUDEV_WINQUIT:
	exitNow = true;
	events.devCount[dev] = 0;
	break;
      case PFUDEV_KEYBD: {
	// process keyboard input 
	for (int i=0; i < events.numKeys; ++i ) { 
	  int key = events.keyQ[i];
	  if ( events.keyCount[key] ) {
	    switch (key) {
	    case 27: 
	      // escape key; exit program 
	      exitNow = true; 
	      break;
	    case 'r':
	      xformer->stop();
	      xformer->reset();
	      break;
	    default:
	      break;
	    }
	  }
	}
      }
      events.devCount[dev] = 0;
      break;
      case PFUDEV_REDRAW:
	events.devCount[dev] = 0;
	break;
      default:
	break;
      }
    
    } // devcount
  } // numDev
  events.numKeys = 0;
  events.numDevs = 0;

}

int
main (int argc, char *argv[])
{
  if (argc < 2)
    cout << "Usage: " << argv[0] << " <fichier>" << endl;
 
  pfInitArenas();
  
  // Initialize Performer
  pfInit();
  pfuInitUtil();
  pfiInit(); 
  pfMultiprocess( PFMP_APPCULLDRAW );			
  
  // Load all loader DSO's before pfConfig() forks 
  pfdInitConverter(argv[1]);
  
  pfConfig();			
    
  // Append to Performer search path, PFPATH, files in 
  //	    /usr/share/Performer/data */
  pfFilePath(".:/usr/share/Performer/data");
  
  pfNode *root = pfdLoadFile(argv[1]);
  if (root == NULL) {
    pfExit();
    exit(-1);
  }
  
  // determine extent of scene's geometry
  pfSphere bsphere;
  root->getBound(&bsphere);
  
  // Attach loaded file to a new pfScene
  pfScene* scene =new pfScene;

  //add a light
  scene->addChild(new pfLightSource);

  // recenter the model to (0,0,0)
  pfMatrix transfo;
  transfo.makeTrans(-bsphere.center[PF_X],
		    -bsphere.center[PF_Y],
		    -bsphere.center[PF_Z]);
  pfMatrix mscale;
  float scal = 1./bsphere.radius;
  mscale.makeScale(scal, scal, scal);
  transfo = transfo + mscale;
  pfSCS* recenter = new pfSCS(transfo);
  recenter->addChild(root);
  recenter->flatten(0);
  recenter->getBound(&bsphere);
  
  // adding a DCS for Trackball movement
  pfGroup* group = new pfGroup;
  group->addChild(recenter);
  pfDCS* dcs = new pfDCS;
  dcs->addChild(group);
  scene->addChild(dcs);
  
  // Configure and open window
  pfPipe *p = pfGetPipe(0);
  pfPipeWindow *pw = new pfPipeWindow(p);
  pw->setWinType(PFPWIN_TYPE_X);
  pfuInitInput(pw, PFUINPUT_X);
  pw->setName("simpl");
  pw->setOriginSize(30,30,500,500);
  pw->open();
  
  // Create and configure a pfChannel.
  pfChannel* chan = new pfChannel(p);
  chan->setScene(scene);
  chan->setFOV(45.0f, 0.0f);
  chan->setNearFar(0.1f, 100.0f * bsphere.radius);
  chan->setLODAttr(PFLOD_SCALE,2.15f);
  chan->setLODAttr(PFLOD_FADE,1.0f);
 
  // Init pos
  pfCoord	   view;
  view.xyz.copy(bsphere.center);
  view.xyz[PF_Y] -= 2.*bsphere.radius;
  view.hpr.set(0.0f,0.0f,0.0f);
  chan->setView(view.xyz, view.hpr);
  
  // Trackball
  pfuMouse mouse;
  xformer =  new pfiTDFXformer;
  xformer->setAutoInput(chan, &mouse, &events);
  xformer->setAutoPosition(chan, dcs);
  xformer->selectModel(PFITDF_TRACKBALL);
  xformer->setNode(group);
  xformer->setCoord(&view);
  xformer->setResetCoord(&view);


  // Global scene pre/post draw (affichage des stats)
  // scene->setTravFuncs(PFTRAV_DRAW, preDraw, postDraw);

  while (!exitNow)  {
    pfuGetMouse(&mouse);
    xformer->update();
    // Go to sleep until next frame time.
    pfSync();		
    // Initiate cull/draw for this frame.
    pfFrame();
    handleEvents();
  }
  // Terminate parallel processes and exit
  pfuExitInput();
  pfuExitUtil();
  pfExit();
}