source: Swollen/swollen/main.cpp @ 115

/*
  SWWViewer

  An OpenSceneGraph viewer for pyVolution SWW files.
  copyright (C) 2004-2005 Geoscience Australia
*/

#include <osg/Group>
#include <osg/Material>
#include <osg/MatrixTransform>
#include <osg/Notify>
#include <osg/PositionAttitudeTransform>
#include <osg/StateAttribute>
#include <osgDB/FileNameUtils>

#include <project.h>
#include <SWWReader.h>
#include <bedslope.h>
#include <hud.h>
#include <keyboardeventhandler.h>
#include <directionallight.h>
#include <state.h>
#include <watersurface.h>
#include <customviewer.h>


// prototypes
osg::Transform* createSky(float radius, const std::string filename);
extern const char* version();


int main( int argc, char **argv )
{

   // use an ArgumentParser object to manage the program arguments
   osg::ArgumentParser arguments( &argc, argv );

   // set up the usage document
   std::string appname = arguments.getApplicationName();
   arguments.getApplicationUsage()->setDescription( appname );
   arguments.getApplicationUsage()->setCommandLineUsage("swollen [options] swwfile ...");
   arguments.getApplicationUsage()->addCommandLineOption("-help","Display this information");
   arguments.getApplicationUsage()->addCommandLineOption("-scale <float>","Vertical scale factor");
   arguments.getApplicationUsage()->addCommandLineOption("-tps <rate>","Timesteps per second");
   arguments.getApplicationUsage()->addCommandLineOption("-hmin <float>","Height below which transparency is set to zero");
   arguments.getApplicationUsage()->addCommandLineOption("-hmax <float>","Height above which transparency is set to alphamax");
   arguments.getApplicationUsage()->addCommandLineOption("-alphamin <float 0-1>","Transparency value at hmin");
   arguments.getApplicationUsage()->addCommandLineOption("-alphamax <float 0-1>","Maximum transparency clamp value");
   arguments.getApplicationUsage()->addCommandLineOption("-lightpos <float>,<float>,<float>","x,y,z of bedslope directional light (z is up, default is overhead)");
   arguments.getApplicationUsage()->addCommandLineOption("-nosky","Omit background sky");
   arguments.getApplicationUsage()->addCommandLineOption("-cullangle <float angle 0-90>","Cull triangles steeper than this value");
   arguments.getApplicationUsage()->addCommandLineOption("-texture <file>","Image to use for bedslope topography");
   arguments.getApplicationUsage()->addCommandLineOption("-version","Revision number and creation (not compile) date");

   // construct the viewer.
   CustomViewer viewer(arguments);

   // set up with sensible default event handlers
   viewer.setUpViewer( osgProducer::Viewer::STANDARD_SETTINGS );
   viewer.setClearColor( osg::Vec4(DEF_BACKGROUND_COLOUR) );
   //viewer.getCamera(0)->getRenderSurface()->setWindowRectangle(200,300,400,300);
   viewer.getCullSettings().setComputeNearFarMode( osg::CullSettings::COMPUTE_NEAR_FAR_USING_PRIMITIVES );


   // get details on keyboard and mouse bindings used by the viewer
   viewer.getUsage(*arguments.getApplicationUsage());

   // if user requested help, write it out to cout
   if( arguments.read("-help") )
   {
      arguments.getApplicationUsage()->write(std::cout);
      return 1;
   }

   // same for version info
   if( arguments.read("-version") )
   {
      std::cout << version() << std::endl;
      return 1;
   }


   // load sww file specified as final argument on command line (static bedslope
   // geometry only, per timestep height field geometry is done in loop below)
   int lastarg = arguments.argc()-1;
   std::string swwfile = arguments.argv()[lastarg];
   arguments.remove(lastarg);
   if( swwfile.substr(swwfile.size()-4,4).find(".sww",0) == -1 )  // ensure filename ends in .sww
   {
      std::cout << "Require last argument be an .sww file ... quitting" << std::endl;
      return 1; 
   }
   SWWReader *sww = new SWWReader(swwfile);
   if (sww->isValid() == false)
   {
      std::cout << "Unable to load " << swwfile << " ... is this really an .sww file?" << std::endl;
      return 1;
   }


   // relative directory to swollen binary
   if( osgDB::getFilePath(argv[0]) == "" )
      sww->setSwollenDir( std::string(".") );
   else
      sww->setSwollenDir( osgDB::getFilePath(argv[0]) );


   // default arguments and command line parameters
   float tmpfloat, tps, vscale;
   if( !arguments.read("-tps", tps) || tps <= 0.0 ) tps = DEF_TPS;
   if( !arguments.read("-scale", vscale) ) vscale = 1.0;
   if( arguments.read("-hmin",tmpfloat) ) sww->setHeightMin( tmpfloat );  
   if( arguments.read("-hmax",tmpfloat) ) sww->setHeightMax( tmpfloat );      
   if( arguments.read("-alphamin",tmpfloat) ) sww->setAlphaMin( tmpfloat );   
   if( arguments.read("-alphamax",tmpfloat) ) sww->setAlphaMax( tmpfloat );
   if( arguments.read("-cullangle",tmpfloat) ) sww->setCullAngle( tmpfloat );

   std::string bedslopetexture;
   if( arguments.read("-texture",bedslopetexture) ) sww->setBedslopeTexture( bedslopetexture );

   // root node
   osg::Group* rootnode = new osg::Group;

   // transform
   osg::PositionAttitudeTransform* model = new osg::PositionAttitudeTransform;
   model->setName("position_attitude_transform");

   // enscapsulates OpenGL state
   osg::StateSet* rootStateSet = new osg::StateSet;

   // Bedslope geometry
   BedSlope* bedslope = new BedSlope(sww);

   // Water geometry
   WaterSurface* water = new WaterSurface(sww);

   // Heads Up Display (text overlay)
   HeadsUpDisplay* hud = new HeadsUpDisplay();
   hud->setTitle("pyVolution SWW Viewer");


   // Lighting
   DirectionalLight* light = new DirectionalLight(rootStateSet);
   light->setPosition( osg::Vec3(1,1,1) );  // z is up

   std::string lightposstr;
   while (arguments.read("-lightpos",lightposstr))
   {
      float x, y, z;
      int count = sscanf( lightposstr.c_str(), "%f,%f,%f", &x, &y, &z );
      if( count == 3 ) light->setPosition( osg::Vec3(x,y,z) );  // z is up
      else osg::notify(osg::WARN) << "Invalid bedslope light position \"" << lightposstr << "\"" << std::endl;
   }



   // scenegraph hierarchy
   rootnode->setStateSet(rootStateSet);
   rootnode->addChild( hud->get() );
   rootnode->addChild( light->get() );
   rootnode->addChild(model);
   model->addChild( bedslope->get() );
   model->addChild( water->get() );


   // allow vertical scaling from command line parameter
   model->setScale( osg::Vec3(1.0, 1.0, vscale) );

   // surrounding sky sphere
   if( !arguments.read("-nosky") )
      rootnode->addChild( createSky(10.0, sww->getSwollenDir() + std::string("/sky_small.jpg") ));


   // add model to viewer.
   viewer.setSceneData(rootnode);
 
   // any option left unread are converted into errors to write out later.
   arguments.reportRemainingOptionsAsUnrecognized();
 
   // report any errors if they have occured when parsing the program aguments.
   if (arguments.errors())
   {
      arguments.writeErrorMessages(std::cout);
      return 1;
   }


   // register additional event handler
   KeyboardEventHandler* event_handler = new KeyboardEventHandler(sww->getNumberOfTimesteps(), tps);
   viewer.getEventHandlerList().push_front(event_handler);

 
   // create the windows and run the threads.
   viewer.realize();


   // initial camera position
   CustomTerrainManipulator* terrainmanipulator = viewer.getTerrainManipulator();
   terrainmanipulator->setNode( model );
   terrainmanipulator->setAutoComputeHomePosition( false );
   terrainmanipulator->setHomePosition(
      osg::Vec3d(0,-3,3),    // camera location
      osg::Vec3d(0,0,0),     // camera target
      osg::Vec3d(0,1,1) );   // camera up vector
   terrainmanipulator->moveToHome();
   terrainmanipulator->enable();


   // animation
   State s = State();
   std::vector<State> statelist;
   bool recordingmode = false;
   bool playbackmode = false;
   unsigned int playback_index = 0;


 
   unsigned int timestep = 0;
   while( !viewer.done() )
   {
    
      // wait for all cull and draw threads to complete.
      viewer.sync();


      if( !playbackmode )
      {

         // current time
         double time = viewer.getFrameStamp()->getReferenceTime();


         event_handler->setTime( time );
         timestep = event_handler->getTimestep();
         water->setTimeStep(timestep);
         hud->setTime( sww->getTime(timestep) );


         // events
         if( event_handler->toggleWireframe() )
            water->toggleWireframe();

         if( event_handler->toggleCulling() )
         {
            sww->toggleCulling();
            water->setTimeStep(timestep);  // refresh
         }


         // '1' key starts/stops recording of view/position/setting info
         if( event_handler->toggleRecording() )
         {
            switch( recordingmode )
            {
               case false : 
                  recordingmode = true; 
                  hud->setRecordingMode("recording");
                  break;
               case true : 
                  recordingmode = false; 
                  hud->setRecordingMode("");
                  break;
            }
         }


         // '2' key starts playback of recorded frames
         if( event_handler->togglePlayback() )
         {
            recordingmode = false;
            switch( playbackmode )
            {
               case false : 
                  playbackmode = true; 
                  hud->setRecordingMode("playback");
                  event_handler->setPaused( true );
                  playback_index = 0;
                  // store current state
                  break;
               case true : 
                  playbackmode = false; 
                  hud->setRecordingMode("");
                  event_handler->setPaused( false );
                  // pop saved state
                  break;
            }
         }


         if( recordingmode )
         {
            s.setTimestep( event_handler->getTimestep() );
            s.setTime( sww->getTime(timestep) );
            s.setCulling( sww->getCulling() );
            s.setWireframe( water->getWireframe() );
            s.setPosition( viewer.getPosition() );
            s.setOrientation( viewer.getOrientation() );
            statelist.push_back( s );
            std::cout << "len(statelist): " << statelist.size() << std::endl;
         }
      }

      else

      {
         // in playback mode
         s = statelist.at( playback_index );
         water->setTimeStep( s.getTimestep() );
         hud->setTime( s.getTime() );

         std::cout << "playing back: " << playback_index << std::endl;

         // loop playback
         playback_index ++;
         if( playback_index == statelist.size() )
            playback_index = 0;
      }



      // update the scene by traversing with the update visitor 
      viewer.update();

      // fire off the cull and draw traversals of the scene.
      viewer.frame();
   }
    
   // wait for all cull and draw threads to complete before exit.
   viewer.sync();

   return 0;
}