Changeset 115

Timestamp:

Jun 26, 2005, 2:52:53 PM (20 years ago)

Author:

darran

Message:

 

Location:

Swollen/swollen

Files:

• Makefile (modified) (1 diff)
• hud.cpp (modified) (3 diffs)
• hud.h (modified) (2 diffs)
• keyboardeventhandler.cpp (modified) (9 diffs)
• keyboardeventhandler.h (modified) (1 diff)
• main.cpp (modified) (2 diffs)
• state.h (modified) (3 diffs)
• version.cpp (modified) (1 diff)
• watersurface.cpp (modified) (6 diffs)
• watersurface.h (modified) (2 diffs)

Swollen/swollen/Makefile

@@ -29 +29 @@
 OBJ              =  customviewer.o hud.o keyboardeventhandler.o watersurface.o main.o version.o \
                     bedslope.o createSky.o customtrackball.o customterrainmanipulator.o spotlight.o \
-                    directionallight.o
+                    directionallight.o state.o
 CPPFLAGS         =  -F/System/Library/Frameworks -Wall -DDARWIN_QUICKTIME \
                     $(OPTIMIZATION)

Swollen/swollen/hud.cpp

@@ -1 +1 @@
 
 /*
-    HeadsUpDisplay class for orthographic foreground display of text
+  HeadsUpDisplay class for orthographic foreground display of text
 
-    An OpenSceneGraph viewer for pyVolution SWW files.
-    copyright (C) 2004 Geoscience Australia
+  An OpenSceneGraph viewer for pyVolution SWW files.
+  copyright (C) 2004 Geoscience Australia
 */
 
@@ -23 +23 @@
 HeadsUpDisplay::HeadsUpDisplay()
 {
-    // a heads-up display requires an orthographic projection
-    _projection = new osg::Projection;
-    _projection->setMatrix( osg::Matrix::ortho2D(0,ORTHO2D_WIDTH,0,ORTHO2D_HEIGHT) );
+   // a heads-up display requires an orthographic projection
+   _projection = new osg::Projection;
+   _projection->setMatrix( osg::Matrix::ortho2D(0,ORTHO2D_WIDTH,0,ORTHO2D_HEIGHT) );
 
-    // font
-    osgText::Font* font = osgText::readFontFile("fonts/arial.ttf");
+   // font
+   osgText::Font* font = osgText::readFontFile("fonts/arial.ttf");
 
-    // title text
-        _title = new osgText::Text;
-    _title->setFont(font);
-    _title->setColor(osg::Vec4(DEF_HUD_COLOUR) );
-    _title->setCharacterSize(20);
-    _title->setPosition(osg::Vec3(20,20,0));
-    _title->setFontResolution(40,40);
+   // title text
+   _titletext = new osgText::Text;
+   _titletext->setFont(font);
+   _titletext->setColor(osg::Vec4(DEF_HUD_COLOUR) );
+   _titletext->setCharacterSize(20);
+   _titletext->setPosition(osg::Vec3(20,20,0));
+   _titletext->setFontResolution(40,40);
+   _dirtytime = false;
 
-    // timer text
-    _time = new osgText::Text;
-    _time->setFont(font);
-    _time->setColor(osg::Vec4(DEF_HUD_COLOUR) );
-    _time->setCharacterSize(30);
-    _time->setPosition(osg::Vec3(1100,20,0));
-    _time->setFontResolution(40,40);
-    _time->setText("t = 0.0");
+   // timer text
+   _timetext = new osgText::Text;
+   _timetext->setFont(font);
+   _timetext->setColor(osg::Vec4(DEF_HUD_COLOUR) );
+   _timetext->setCharacterSize(30);
+   _timetext->setPosition(osg::Vec3(1100,20,0));
+   _timetext->setFontResolution(40,40);
+   _timevalue = 0.0;
+   _dirtytime = true;
 
-    // recording mode text
-    _record = new osgText::Text;
-    _record->setFont(font);
-    _record->setColor(osg::Vec4(DEF_HUD_COLOUR) );
-    _record->setCharacterSize(30);
-    _record->setPosition(osg::Vec3(600,20,0));
-    _record->setFontResolution(40,40);
-    _record->setText("");
+   // recording mode text
+   _modetext = new osgText::Text;
+   _modetext->setFont(font);
+   _modetext->setColor(osg::Vec4(DEF_HUD_COLOUR) );
+   _modetext->setCharacterSize(30);
+   _modetext->setPosition(osg::Vec3(600,20,0));
+   _modetext->setFontResolution(40,40);
+   _modestring = new std::string("");
+   _dirtymode = true;
 
 
-    // state
-    osg::StateSet *state = _projection->getOrCreateStateSet();
-    state->setRenderBinDetails(12, "RenderBin");
-    state->setMode(GL_DEPTH_TEST,osg::StateAttribute::OFF);
-    state->setMode( GL_LIGHTING, osg::StateAttribute::OFF );
+   // state
+   osg::StateSet *state = _projection->getOrCreateStateSet();
+   state->setRenderBinDetails(12, "RenderBin");
+   state->setMode(GL_DEPTH_TEST,osg::StateAttribute::OFF);
+   state->setMode( GL_LIGHTING, osg::StateAttribute::OFF );
 
-    // scenegraph
-    osg::MatrixTransform* xfm = new osg::MatrixTransform;
-    xfm->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
-    xfm->setMatrix(osg::Matrix::identity());
-    osg::Geode* textnode = new osg::Geode;
-    textnode->addDrawable( _title );
-    textnode->addDrawable( _time );
-    textnode->addDrawable( _record );
-    xfm->addChild( textnode );
-    _projection->addChild( xfm );
+   // scenegraph
+   osg::MatrixTransform* xfm = new osg::MatrixTransform;
+   xfm->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
+   xfm->setMatrix(osg::Matrix::identity());
+   osg::Geode* textnode = new osg::Geode;
+   textnode->addDrawable( _titletext );
+   textnode->addDrawable( _timetext );
+   textnode->addDrawable( _modetext );
+   xfm->addChild( textnode );
+   _projection->addChild( xfm );
 }
 
@@ -84 +87 @@
 void HeadsUpDisplay::setTime( float t )
 {
-        char timestr[20];
-        sprintf(timestr, "t = %-7.2f", t);
-        _time->setText(timestr);
+   if( t != _timevalue )
+   {
+      _timevalue = t;
+      _dirtytime = true;
+   }
 }
 
 
-void HeadsUpDisplay::setTitle( char *s )
+void HeadsUpDisplay::setTitle( std::string s )
 {
-    _title->setText(s);
+   if( s != *_titlestring )
+   {
+      _titlestring = new std::string(s);
+      _dirtytitle = true;
+   }
 }
 
 
-void HeadsUpDisplay::setRecordingMode( char *s )
+void HeadsUpDisplay::setMode( std::string s )
 {
-    _record->setText(s);
+   if( s != *_modestring )
+   {
+      _modestring = new std::string(s);
+      _dirtymode = true;
+   }
 }
 
+
+
+void HeadsUpDisplay::update()
+{
+   
+   if( _dirtytime )
+   {
+      char timestr[20];
+      sprintf(timestr, "t = %-7.2f", _timevalue);
+      _timetext->setText(timestr);
+
+      // hud time now updated ...
+      _dirtytime = false;
+   }
+
+
+   if( _dirtymode )
+   {
+      _modetext->setText(_modestring->c_str());
+
+      // hud "recording/playback" text now updated ...
+      _dirtymode = false;
+   }
+
+
+   if( _dirtytitle )
+   {
+      _titletext->setText(_titlestring->c_str());
+
+      // hud title text now updated ...
+      _dirtytitle = false;
+   }
+}

Swollen/swollen/hud.h

@@ -24 +24 @@
     HeadsUpDisplay();
     virtual void setTime(float t);
-    virtual void setTitle(char *s);
-    virtual void setRecordingMode(char *s);
+    virtual void setTitle(std::string s);
+    virtual void setMode(std::string s);
+    virtual void update();
     virtual osg::Projection* get(){ return _projection; }
 
@@ -31 +32 @@
 
     osg::Projection* _projection;
-    osgText::Text* _title;
-    osgText::Text* _time;
-    osgText::Text* _record;
+    osgText::Text* _titletext;
+    osgText::Text* _timetext;
+    osgText::Text* _modetext;
+    float _timevalue;
+    std::string* _modestring;
+    std::string* _titlestring;
+    bool _dirtytime, _dirtymode, _dirtytitle;
     virtual ~HeadsUpDisplay();
 

Swollen/swollen/keyboardeventhandler.cpp

@@ -1 +1 @@
 
 #include <keyboardeventhandler.h>
+#include <iostream>
 
 
 KeyboardEventHandler::KeyboardEventHandler( int nTimesteps, float tps)
 {
-    _paused = DEF_PAUSED_START;
-    _direction = 1;
-    _ntimesteps = nTimesteps;
-    _tps = tps;
-    _tpsorig = tps;
-    _timestepchanged = false;
-    _timestep = 0;
-    _prevtime = 0;
-    _togglewireframe = false;
-    _toggleculling = false;
-    _togglerecording = false;
-    _toggleplayback = false;
-    _togglesave = false;
+   _paused = DEF_PAUSED_START;
+   _direction = 1;
+   _ntimesteps = nTimesteps;
+   _tps = tps;
+   _tpsorig = tps;
+   _timestepchanged = false;
+   _timestep = 0;
+   _prevtime = 0;
+   _togglewireframe = false;
+   _toggleculling = false;
+   _togglerecording = false;
+   _toggleplayback = false;
+   _togglesave = false;
 }
 
@@ -23 +24 @@
 bool KeyboardEventHandler::handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter&)
 {
-    bool handled = false;
+   bool handled = false;
 
-    if( ea.getEventType() == osgGA::GUIEventAdapter::KEYDOWN )
-    {
-        switch( ea.getKey() )
-            {
+   if( ea.getEventType() == osgGA::GUIEventAdapter::KEYDOWN )
+   {
+      switch( ea.getKey() )
+      {
             case osgGA::GUIEventAdapter::KEY_Space:
-                _paused = _paused ? false : true;
-                handled = true;
-                break;
+            _paused = _paused ? false : true;
+            handled = true;
+            break;
 
             case osgGA::GUIEventAdapter::KEY_Up:
-                if( !_paused ) _tps *= 1.5;
-                handled = true;
-                break;
+            if( !_paused ) _tps *= 1.5;
+            handled = true;
+            break;
 
             case osgGA::GUIEventAdapter::KEY_Down:
-                if( !_paused ) _tps /= 1.5;
-                handled = true;
-                break;
+            if( !_paused ) _tps /= 1.5;
+            handled = true;
+            break;
 
             case 'r':
-                _paused = DEF_PAUSED_START;
-                _tps = _tpsorig;
-                _timestep = 0;
-                _timestepchanged = true;
-                handled = true;
-                break;
+            _paused = DEF_PAUSED_START;
+            _tps = _tpsorig;
+            _timestep = 0;
+            _timestepchanged = true;
+            handled = true;
+            break;
 
             case osgGA::GUIEventAdapter::KEY_Right:
-                if( _paused )
-                {
-                    _timestep = (_timestep+1) % _ntimesteps;
-                    _timestepchanged = true;
-                }
-                else
-                    _direction = +1;
-                handled = true;
-                break;
+            if( _paused )
+            {
+               _timestep = (_timestep+1) % _ntimesteps;
+               _timestepchanged = true;
+            }
+            else
+               _direction = +1;
+            handled = true;
+            break;
 
             case osgGA::GUIEventAdapter::KEY_Left:
-                if( _paused ) 
-                {
-                    _timestep = _timestep-1;
-                    if( _timestep < 0 ) _timestep = _ntimesteps-1;
-                    _timestepchanged = true;
-                }
-                else
-                    _direction = -1;
-                handled = true;
-                break;
+            if( _paused ) 
+            {
+               _timestep = _timestep-1;
+               if( _timestep < 0 ) _timestep = _ntimesteps-1;
+               _timestepchanged = true;
+            }
+            else
+               _direction = -1;
+            handled = true;
+            break;
 
             case 'w':
-                _togglewireframe = true;
-                handled = true;
-                break;
+            _togglewireframe = true;
+            handled = true;
+            break;
 
             case 'c':
-                _toggleculling = true;
-                handled = true;
-                break;
+            _toggleculling = true;
+            handled = true;
+            break;
 
 
             case '1':
-                _togglerecording = true;
-                handled = true;
-                break;
+            _togglerecording = true;
+            handled = true;
+            break;
 
             case '2':
-                _toggleplayback = true;
-                handled = true;
-                break;
+            _toggleplayback = true;
+            handled = true;
+            break;
 
             case '3':
-                _togglesave = true;
-                handled = true;
-                break;
+            _togglesave = true;
+            handled = true;
+            break;
 
-            }
+      }
 
-    }
-    return handled;
+   }
+   return handled;
 }
 
@@ -110 +111 @@
 void KeyboardEventHandler::setTime( float time)
 {
-    if( !isPaused()  &&  time - _prevtime > 1.0/_tps )
-    {
-        _prevtime = time;
-        _timestep = _timestep + _direction;
-        if( _timestep == _ntimesteps ) 
+   //std::cout << "setTime: " << time << std::endl;
+   //std::cout << "setTime: " << _tps << std::endl;
+   if( !isPaused()  &&  time - _prevtime > 1.0/_tps )
+   {
+      _prevtime = time;
+      _timestep = _timestep + _direction;
+      if( _timestep == _ntimesteps ) 
             _timestep = 0;
-        else if( _timestep < 0 ) 
+      else if( _timestep < 0 ) 
             _timestep = _ntimesteps-1;
-        _timestepchanged = true;
-    }
+      _timestepchanged = true;
+   }
 }
 
@@ -125 +128 @@
 bool KeyboardEventHandler::timestepChanged()
 {
-    if( _timestepchanged )
-    {
-        _timestepchanged = false;
-        return true;
-    }
-    return false;
+   if( _timestepchanged )
+   {
+      _timestepchanged = false;
+      return true;
+   }
+   return false;
 }
 
@@ -136 +139 @@
 bool KeyboardEventHandler::toggleWireframe()
 {
-    if( _togglewireframe )
-    {
-        _togglewireframe = false;
-        return true;
-    }
-    return false;
+   if( _togglewireframe )
+   {
+      _togglewireframe = false;
+      return true;
+   }
+   return false;
 }
 
@@ -147 +150 @@
 bool KeyboardEventHandler::toggleCulling()
 {
-    if( _toggleculling )
-    {
-        _toggleculling = false;
-        return true;
-    }
-    return false;
+   if( _toggleculling )
+   {
+      _toggleculling = false;
+      return true;
+   }
+   return false;
 }
 
@@ -158 +161 @@
 bool KeyboardEventHandler::toggleRecording()
 {
-    if( _togglerecording )
-    {
-        _togglerecording = false;
-        return true;
-    }
-    return false;
+   if( _togglerecording )
+   {
+      _togglerecording = false;
+      return true;
+   }
+   return false;
 }
 
@@ -169 +172 @@
 bool KeyboardEventHandler::togglePlayback()
 {
-    if( _toggleplayback )
-    {
-        _toggleplayback = false;
-        return true;
-    }
-    return false;
+   if( _toggleplayback )
+   {
+      _toggleplayback = false;
+      return true;
+   }
+   return false;
 }
 
@@ -180 +183 @@
 bool KeyboardEventHandler::toggleSave()
 {
-    if( _togglesave )
-    {
-        _togglesave = false;
-        return true;
-    }
-    return false;
+   if( _togglesave )
+   {
+      _togglesave = false;
+      return true;
+   }
+   return false;
 }

Swollen/swollen/keyboardeventhandler.h

@@ -21 +21 @@
     virtual void accept(osgGA::GUIEventHandlerVisitor&) {}
     virtual bool isPaused(){return _paused;}
+    virtual void setPaused(bool value){_paused = value;}
     virtual bool timestepChanged();
     virtual bool toggleWireframe();

Swollen/swollen/main.cpp

@@ -207 +207 @@
 
 
-   // animation mode is off to start
+   // animation
+   State s = State();
+   std::vector<State> statelist;
    bool recordingmode = false;
-
-
-   // test state
-   State* s = new State;
-   std::vector<State>* statelist = new std::vector<State>;
+   bool playbackmode = false;
+   unsigned int playback_index = 0;
+
+
  
    unsigned int timestep = 0;
@@ -223 +224 @@
 
 
-      // current time
-      double time = viewer.getFrameStamp()->getReferenceTime();
-
-      // advance sww frame?
-      event_handler->setTime( time );
-      if( event_handler->timestepChanged() )
+      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;
+         }
       }
 
-      // events
-      if( event_handler->toggleWireframe() )
-         water->toggleWireframe();
-
-      if( event_handler->toggleCulling() )
+      else
+
       {
-         sww->toggleCulling();
-         water->setTimeStep(timestep);  // refresh
+         // 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;
       }
 
-      /*
-        Finite State Machine for animation
-      
-        0 1 1 begin storing view/orientation/cull settings
-        0 2 2 if exists, store current settings, commence playback of saved animation path
-        0 3 0 save animation to disk
-
-        1 1 0 stop storing settings
-        1 2 2 stop storing settings and commence playback
-        1 3 1 save animation, keep recording
-
-        2 2 0 stop playback, return to saved settings
-        2 1 2 no effect
-        2 3 2 save animation, continue playing back
-
-        header comprised of original command line arguments
-
-        state comprised of:
-           frame
-           elapsedtime
-           position
-           orientation
-           timestep
-           cullsteep
-           wireframe
-  
-      */
-
-
-      if( event_handler->toggleRecording() )
-      {
-         switch( recordingmode )
-         {
-            case false : 
-               recordingmode = true; 
-               hud->setRecordingMode("recording");
-               break;
-            case true : 
-               recordingmode = false; 
-               hud->setRecordingMode("");
-               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 );
-      }
-
-      //s.write( std::cout );
 
 
       // update the scene by traversing with the update visitor 
       viewer.update();
-         
+
       // fire off the cull and draw traversals of the scene.
       viewer.frame();

Swollen/swollen/state.h

@@ -1 +1 @@
 
 /*
-    state.h, encapsulate current position, orientation and view settings
+  state.h, encapsulate current position, orientation and view settings
 
-    An OpenSceneGraph viewer for pyVolution SWW files.
-    copyright (C) 2004 Geoscience Australia
+  An OpenSceneGraph viewer for pyVolution SWW files.
+  copyright (C) 2004 Geoscience Australia
+
+
+  Finite State Machine for animation
+      
+  0 1 1 begin storing view/orientation/cull settings
+  0 2 2 if exists, store current settings, commence playback of saved animation path
+  0 3 0 save animation to disk
+
+  1 1 0 stop storing settings
+  1 2 2 stop storing settings and commence playback
+  1 3 1 save animation, keep recording
+
+  2 2 0 stop playback, return to saved settings
+  2 1 2 no effect
+  2 3 2 save animation, continue playing back
+
+  header comprised of original command line arguments
+
+  state comprised of:
+  frame
+  elapsedtime
+  position
+  orientation
+  timestep
+  cullsteep
+  wireframe
+  
 */
+
 
 
@@ -39 +67 @@
     virtual void read(std::istream s);
 
+    virtual ~State();
+
 
 protected:
@@ -48 +78 @@
     bool _culling;
     bool _wireframe;
-   
-    virtual ~State();
-
+ 
 };
 

Swollen/swollen/version.cpp

@@ -1 @@
-const char* version() { const char* s = "Revision: 110M"; return s; }
+const char* version() { const char* s = "Revision: 114M"; return s; }

Swollen/swollen/watersurface.cpp

@@ -1 +1 @@
 /*
-    WaterSurface class
+  WaterSurface class
 
-    An OpenSceneGraph viewer for pyVolution .sww files.
-    copyright (C) 2004 Geoscience Australia
+  An OpenSceneGraph viewer for pyVolution .sww files.
+  copyright (C) 2004 Geoscience Australia
 */
 
@@ -17 +17 @@
 
 #include <osgDB/ReadFile>
-#include <osgUtil/TriStripVisitor>
+//#include <osgUtil/TriStripVisitor>
 
 #define DEF_ALPHA_THRESHOLD 0.05
@@ -25 +25 @@
 WaterSurface::WaterSurface(SWWReader* sww)
 {
-    // persistent
-    _sww = sww;
-    _node = new osg::Geode;
-    _geom = new osg::Geometry;
-    _stateset = new osg::StateSet;
+   // persistent
+   _sww = sww;
+   _node = new osg::Geode;
+   _geom = new osg::Geometry;
+   _stateset = new osg::StateSet;
 
-    // construct local scenegraph hierarchy
-    _node->setName("watersurface");
-    _node->addDrawable(_geom);
-    _node->setStateSet(_stateset);
+   // construct local scenegraph hierarchy
+   _node->setName("watersurface");
+   _node->addDrawable(_geom);
+   _node->setStateSet(_stateset);
 
-    _geom->setUseDisplayList( false );
+   _geom->setUseDisplayList( false );
 
-    // initial geometry
-    setTimeStep(0);
 
-    // environment map
-    osg::Texture2D* texture = new osg::Texture2D;
-    texture->setDataVariance(osg::Object::DYNAMIC);
-    texture->setBorderColor(osg::Vec4(1.0f,1.0f,1.0f,0.5f));
-    texture->setWrap(osg::Texture::WRAP_S, osg::Texture::REPEAT);
-    std::string* envmap = new std::string( _sww->getSwollenDir() + std::string("/") + std::string("envmap.jpg") );
-    texture->setImage(osgDB::readImageFile( envmap->c_str() ));
-    _stateset->setTextureAttributeAndModes( 1, texture, osg::StateAttribute::ON );
-    _stateset->setMode( GL_LIGHTING, osg::StateAttribute::ON );
+   // surface starts on first timestep
+   _timestep = 0;
+   _dirtytimestep = true;  // will force load of watersurface
 
-    // surface transparency
-    osg::BlendFunc* osgBlendFunc = new osg::BlendFunc();
-    osgBlendFunc->setFunction(osg::BlendFunc::SRC_ALPHA, osg::BlendFunc::ONE_MINUS_SRC_ALPHA);
-    _stateset->setAttribute(osgBlendFunc);
-    _stateset->setMode(GL_BLEND, osg::StateAttribute::ON);
-    _stateset->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);
+   // default is filled watersurface
+   _wireframe = false;
+   _dirtywireframe = true;  // will force wireframe refresh
 
-    // discard pixels with an alpha value below threshold
-    osg::AlphaFunc* alphaFunc = new osg::AlphaFunc;
-    alphaFunc->setFunction( osg::AlphaFunc::GREATER, DEF_ALPHA_THRESHOLD );
-    _stateset->setAttributeAndModes( alphaFunc, osg::StateAttribute::ON );
 
-    // automatically generate texture coords
-    osg::TexGen* texgen = new osg::TexGen;
-    texgen->setMode( osg::TexGen::SPHERE_MAP );
 
-    osg::TexEnv* texenv = new osg::TexEnv;
-    texenv->setMode( osg::TexEnv::DECAL );
-    //texenv->setMode( osg::TexEnv::BLEND );
-    texenv->setColor( osg::Vec4(0.6f,0.6f,0.6f,0.2f) );
-    _stateset->setTextureAttributeAndModes( 1, texgen, osg::StateAttribute::ON );
-    _stateset->setTextureAttribute( 1, texenv );
+   // environment map
+   osg::Texture2D* texture = new osg::Texture2D;
+   texture->setDataVariance(osg::Object::DYNAMIC);
+   texture->setBorderColor(osg::Vec4(1.0f,1.0f,1.0f,0.5f));
+   texture->setWrap(osg::Texture::WRAP_S, osg::Texture::REPEAT);
+   std::string* envmap = new std::string( _sww->getSwollenDir() + std::string("/") + std::string("envmap.jpg") );
+   texture->setImage(osgDB::readImageFile( envmap->c_str() ));
+   _stateset->setTextureAttributeAndModes( 1, texture, osg::StateAttribute::ON );
+   _stateset->setMode( GL_LIGHTING, osg::StateAttribute::ON );
 
-    // default is filled watersurface
-    _wireframe = false;
+   // surface transparency
+   osg::BlendFunc* osgBlendFunc = new osg::BlendFunc();
+   osgBlendFunc->setFunction(osg::BlendFunc::SRC_ALPHA, osg::BlendFunc::ONE_MINUS_SRC_ALPHA);
+   _stateset->setAttribute(osgBlendFunc);
+   _stateset->setMode(GL_BLEND, osg::StateAttribute::ON);
+   _stateset->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);
+
+   // discard pixels with an alpha value below threshold
+   osg::AlphaFunc* alphaFunc = new osg::AlphaFunc;
+   alphaFunc->setFunction( osg::AlphaFunc::GREATER, DEF_ALPHA_THRESHOLD );
+   _stateset->setAttributeAndModes( alphaFunc, osg::StateAttribute::ON );
+
+   // automatically generate texture coords
+   osg::TexGen* texgen = new osg::TexGen;
+   texgen->setMode( osg::TexGen::SPHERE_MAP );
+
+   osg::TexEnv* texenv = new osg::TexEnv;
+   texenv->setMode( osg::TexEnv::DECAL );
+   //texenv->setMode( osg::TexEnv::BLEND );
+   texenv->setColor( osg::Vec4(0.6f,0.6f,0.6f,0.2f) );
+   _stateset->setTextureAttributeAndModes( 1, texgen, osg::StateAttribute::ON );
+   _stateset->setTextureAttribute( 1, texenv );
 
 }
@@ -89 +94 @@
 void WaterSurface::setTimeStep(unsigned int ts)
 {
-    // delete if exists
-    if( _geom->getNumPrimitiveSets() )
-      _geom->removePrimitiveSet(0);  // reference counting does actual delete
-
-    // local reference to raw height field data
-    osg::ref_ptr<osg::Vec3Array> vertices = _sww->getStageVertexArray(ts);
-    osg::ref_ptr<osg::Vec3Array> vertexnormals = _sww->getStageVertexNormalArray();
-    osg::ref_ptr<osg::Vec4Array> colors = _sww->getStageColorArray();
-
-    // geometry
-    _geom->setVertexArray( vertices.get() );
-    _geom->addPrimitiveSet( _sww->getBedslopeIndexArray().get() );
-
-    // per vertex colors (we only modulate the alpha for transparency)
-    _geom->setColorArray( colors.get() );
-    _geom->setColorBinding(osg::Geometry::BIND_PER_VERTEX);
-
-    // normals
-    _geom->setNormalArray( vertexnormals.get() );
-    _geom->setNormalBinding(osg::Geometry::BIND_PER_VERTEX);
-
-    // osgUtil::TriStripVisitor* optimize = new osgUtil::TriStripVisitor();
-    // optimize->stripify( *_geom );
-
+   if( ts != _timestep )
+   {
+      _timestep = ts;
+      _dirtytimestep = true;
+   }
 }
 
@@ -118 +104 @@
 void WaterSurface::toggleWireframe()
 {
-   if( _wireframe )
-      _wireframe = false;
-   else
-      _wireframe = true;
-
-   setWireframe(_wireframe);
+   setWireframe( _wireframe ? false : true );
 }
 
@@ -129 +110 @@
 void WaterSurface::setWireframe(bool value)
 {
-    osg::PolygonMode* polyModeObj = 
-        dynamic_cast<osg::PolygonMode*>(_stateset->getAttribute(osg::StateAttribute::POLYGONMODE));
+   if( value != _wireframe )
+   {
+      _wireframe = value;
+      _dirtywireframe = true;
+   }
+}
 
-    if (!polyModeObj) 
-    {
-            polyModeObj = new osg::PolygonMode;
-            _stateset->setAttribute(polyModeObj);
-    }
 
-    switch( value )
-    {
-       case true :
-          polyModeObj->setMode(osg::PolygonMode::FRONT_AND_BACK, osg::PolygonMode::LINE);
-          break;
+void WaterSurface::update()
+{
 
-       case false :
-         polyModeObj->setMode(osg::PolygonMode::FRONT_AND_BACK, osg::PolygonMode::FILL);
-         break;
-    }
+   if( _dirtytimestep )
+   {
+      // delete if exists
+      if( _geom->getNumPrimitiveSets() )
+         _geom->removePrimitiveSet(0);  // reference counting does actual delete
+
+      // local reference to raw height field data
+      osg::ref_ptr<osg::Vec3Array> vertices = _sww->getStageVertexArray(_timestep);
+      osg::ref_ptr<osg::Vec3Array> vertexnormals = _sww->getStageVertexNormalArray();
+      osg::ref_ptr<osg::Vec4Array> colors = _sww->getStageColorArray();
+
+      // geometry
+      _geom->setVertexArray( vertices.get() );
+      _geom->addPrimitiveSet( _sww->getBedslopeIndexArray().get() );
+
+      // per vertex colors (we only modulate the alpha for transparency)
+      _geom->setColorArray( colors.get() );
+      _geom->setColorBinding(osg::Geometry::BIND_PER_VERTEX);
+
+      // normals
+      _geom->setNormalArray( vertexnormals.get() );
+      _geom->setNormalBinding(osg::Geometry::BIND_PER_VERTEX);
+
+      // osgUtil::TriStripVisitor* optimize = new osgUtil::TriStripVisitor();
+      // optimize->stripify( *_geom );
+
+      // water surface corresponding to _timestep is now loaded ...
+      _dirtytimestep = false;
+   }
+
+
+   if( _dirtywireframe )
+   {
+      osg::PolygonMode* polyModeObj = 
+         dynamic_cast<osg::PolygonMode*>(_stateset->getAttribute(osg::StateAttribute::POLYGONMODE));
+
+      if (!polyModeObj) 
+      {
+         polyModeObj = new osg::PolygonMode;
+         _stateset->setAttribute(polyModeObj);
+      }
+
+      switch( _wireframe )
+      {
+         case true :
+            polyModeObj->setMode(osg::PolygonMode::FRONT_AND_BACK, osg::PolygonMode::LINE);
+            break;
+
+         case false :
+            polyModeObj->setMode(osg::PolygonMode::FRONT_AND_BACK, osg::PolygonMode::FILL);
+            break;
+      }
+
+      // desired wireframe mode now loaded ...
+      _dirtywireframe = false;
+
+   }
+
+
 }

Swollen/swollen/watersurface.h

@@ -29 +29 @@
     virtual bool getWireframe(){ return _wireframe; };
     virtual void setWireframe(bool wireframe);
+    virtual void update();
 
 protected:
@@ -36 +37 @@
     osg::Geometry* _geom;
     osg::StateSet* _stateset;
+    unsigned int _timestep;
     virtual ~WaterSurface();
-    bool _wireframe;
+    bool _wireframe, _dirtywireframe;
+    bool _dirtytimestep;
 };