Changeset 115


Ignore:
Timestamp:
Jun 26, 2005, 2:52:53 PM (19 years ago)
Author:
darran
Message:
 
Location:
Swollen/swollen
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • Swollen/swollen/Makefile

    r88 r115  
    2929OBJ              =  customviewer.o hud.o keyboardeventhandler.o watersurface.o main.o version.o \
    3030                    bedslope.o createSky.o customtrackball.o customterrainmanipulator.o spotlight.o \
    31                     directionallight.o
     31                    directionallight.o state.o
    3232CPPFLAGS         =  -F/System/Library/Frameworks -Wall -DDARWIN_QUICKTIME \
    3333                    $(OPTIMIZATION)
  • Swollen/swollen/hud.cpp

    r111 r115  
    11
    22/*
    3     HeadsUpDisplay class for orthographic foreground display of text
     3  HeadsUpDisplay class for orthographic foreground display of text
    44
    5     An OpenSceneGraph viewer for pyVolution SWW files.
    6     copyright (C) 2004 Geoscience Australia
     5  An OpenSceneGraph viewer for pyVolution SWW files.
     6  copyright (C) 2004 Geoscience Australia
    77*/
    88
     
    2323HeadsUpDisplay::HeadsUpDisplay()
    2424{
    25     // a heads-up display requires an orthographic projection
    26     _projection = new osg::Projection;
    27     _projection->setMatrix( osg::Matrix::ortho2D(0,ORTHO2D_WIDTH,0,ORTHO2D_HEIGHT) );
     25   // a heads-up display requires an orthographic projection
     26   _projection = new osg::Projection;
     27   _projection->setMatrix( osg::Matrix::ortho2D(0,ORTHO2D_WIDTH,0,ORTHO2D_HEIGHT) );
    2828
    29     // font
    30     osgText::Font* font = osgText::readFontFile("fonts/arial.ttf");
     29   // font
     30   osgText::Font* font = osgText::readFontFile("fonts/arial.ttf");
    3131
    32     // title text
    33         _title = new osgText::Text;
    34     _title->setFont(font);
    35     _title->setColor(osg::Vec4(DEF_HUD_COLOUR) );
    36     _title->setCharacterSize(20);
    37     _title->setPosition(osg::Vec3(20,20,0));
    38     _title->setFontResolution(40,40);
     32   // title text
     33   _titletext = new osgText::Text;
     34   _titletext->setFont(font);
     35   _titletext->setColor(osg::Vec4(DEF_HUD_COLOUR) );
     36   _titletext->setCharacterSize(20);
     37   _titletext->setPosition(osg::Vec3(20,20,0));
     38   _titletext->setFontResolution(40,40);
     39   _dirtytime = false;
    3940
    40     // timer text
    41     _time = new osgText::Text;
    42     _time->setFont(font);
    43     _time->setColor(osg::Vec4(DEF_HUD_COLOUR) );
    44     _time->setCharacterSize(30);
    45     _time->setPosition(osg::Vec3(1100,20,0));
    46     _time->setFontResolution(40,40);
    47     _time->setText("t = 0.0");
     41   // timer text
     42   _timetext = new osgText::Text;
     43   _timetext->setFont(font);
     44   _timetext->setColor(osg::Vec4(DEF_HUD_COLOUR) );
     45   _timetext->setCharacterSize(30);
     46   _timetext->setPosition(osg::Vec3(1100,20,0));
     47   _timetext->setFontResolution(40,40);
     48   _timevalue = 0.0;
     49   _dirtytime = true;
    4850
    49     // recording mode text
    50     _record = new osgText::Text;
    51     _record->setFont(font);
    52     _record->setColor(osg::Vec4(DEF_HUD_COLOUR) );
    53     _record->setCharacterSize(30);
    54     _record->setPosition(osg::Vec3(600,20,0));
    55     _record->setFontResolution(40,40);
    56     _record->setText("");
     51   // recording mode text
     52   _modetext = new osgText::Text;
     53   _modetext->setFont(font);
     54   _modetext->setColor(osg::Vec4(DEF_HUD_COLOUR) );
     55   _modetext->setCharacterSize(30);
     56   _modetext->setPosition(osg::Vec3(600,20,0));
     57   _modetext->setFontResolution(40,40);
     58   _modestring = new std::string("");
     59   _dirtymode = true;
    5760
    5861
    59     // state
    60     osg::StateSet *state = _projection->getOrCreateStateSet();
    61     state->setRenderBinDetails(12, "RenderBin");
    62     state->setMode(GL_DEPTH_TEST,osg::StateAttribute::OFF);
    63     state->setMode( GL_LIGHTING, osg::StateAttribute::OFF );
     62   // state
     63   osg::StateSet *state = _projection->getOrCreateStateSet();
     64   state->setRenderBinDetails(12, "RenderBin");
     65   state->setMode(GL_DEPTH_TEST,osg::StateAttribute::OFF);
     66   state->setMode( GL_LIGHTING, osg::StateAttribute::OFF );
    6467
    65     // scenegraph
    66     osg::MatrixTransform* xfm = new osg::MatrixTransform;
    67     xfm->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
    68     xfm->setMatrix(osg::Matrix::identity());
    69     osg::Geode* textnode = new osg::Geode;
    70     textnode->addDrawable( _title );
    71     textnode->addDrawable( _time );
    72     textnode->addDrawable( _record );
    73     xfm->addChild( textnode );
    74     _projection->addChild( xfm );
     68   // scenegraph
     69   osg::MatrixTransform* xfm = new osg::MatrixTransform;
     70   xfm->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
     71   xfm->setMatrix(osg::Matrix::identity());
     72   osg::Geode* textnode = new osg::Geode;
     73   textnode->addDrawable( _titletext );
     74   textnode->addDrawable( _timetext );
     75   textnode->addDrawable( _modetext );
     76   xfm->addChild( textnode );
     77   _projection->addChild( xfm );
    7578}
    7679
     
    8487void HeadsUpDisplay::setTime( float t )
    8588{
    86         char timestr[20];
    87         sprintf(timestr, "t = %-7.2f", t);
    88         _time->setText(timestr);
     89   if( t != _timevalue )
     90   {
     91      _timevalue = t;
     92      _dirtytime = true;
     93   }
    8994}
    9095
    9196
    92 void HeadsUpDisplay::setTitle( char *s )
     97void HeadsUpDisplay::setTitle( std::string s )
    9398{
    94     _title->setText(s);
     99   if( s != *_titlestring )
     100   {
     101      _titlestring = new std::string(s);
     102      _dirtytitle = true;
     103   }
    95104}
    96105
    97106
    98 void HeadsUpDisplay::setRecordingMode( char *s )
     107void HeadsUpDisplay::setMode( std::string s )
    99108{
    100     _record->setText(s);
     109   if( s != *_modestring )
     110   {
     111      _modestring = new std::string(s);
     112      _dirtymode = true;
     113   }
    101114}
    102115
     116
     117
     118void HeadsUpDisplay::update()
     119{
     120   
     121   if( _dirtytime )
     122   {
     123      char timestr[20];
     124      sprintf(timestr, "t = %-7.2f", _timevalue);
     125      _timetext->setText(timestr);
     126
     127      // hud time now updated ...
     128      _dirtytime = false;
     129   }
     130
     131
     132   if( _dirtymode )
     133   {
     134      _modetext->setText(_modestring->c_str());
     135
     136      // hud "recording/playback" text now updated ...
     137      _dirtymode = false;
     138   }
     139
     140
     141   if( _dirtytitle )
     142   {
     143      _titletext->setText(_titlestring->c_str());
     144
     145      // hud title text now updated ...
     146      _dirtytitle = false;
     147   }
     148}
  • Swollen/swollen/hud.h

    r111 r115  
    2424    HeadsUpDisplay();
    2525    virtual void setTime(float t);
    26     virtual void setTitle(char *s);
    27     virtual void setRecordingMode(char *s);
     26    virtual void setTitle(std::string s);
     27    virtual void setMode(std::string s);
     28    virtual void update();
    2829    virtual osg::Projection* get(){ return _projection; }
    2930
     
    3132
    3233    osg::Projection* _projection;
    33     osgText::Text* _title;
    34     osgText::Text* _time;
    35     osgText::Text* _record;
     34    osgText::Text* _titletext;
     35    osgText::Text* _timetext;
     36    osgText::Text* _modetext;
     37    float _timevalue;
     38    std::string* _modestring;
     39    std::string* _titlestring;
     40    bool _dirtytime, _dirtymode, _dirtytitle;
    3641    virtual ~HeadsUpDisplay();
    3742
  • Swollen/swollen/keyboardeventhandler.cpp

    r114 r115  
    11
    22#include <keyboardeventhandler.h>
     3#include <iostream>
    34
    45
    56KeyboardEventHandler::KeyboardEventHandler( int nTimesteps, float tps)
    67{
    7     _paused = DEF_PAUSED_START;
    8     _direction = 1;
    9     _ntimesteps = nTimesteps;
    10     _tps = tps;
    11     _tpsorig = tps;
    12     _timestepchanged = false;
    13     _timestep = 0;
    14     _prevtime = 0;
    15     _togglewireframe = false;
    16     _toggleculling = false;
    17     _togglerecording = false;
    18     _toggleplayback = false;
    19     _togglesave = false;
     8   _paused = DEF_PAUSED_START;
     9   _direction = 1;
     10   _ntimesteps = nTimesteps;
     11   _tps = tps;
     12   _tpsorig = tps;
     13   _timestepchanged = false;
     14   _timestep = 0;
     15   _prevtime = 0;
     16   _togglewireframe = false;
     17   _toggleculling = false;
     18   _togglerecording = false;
     19   _toggleplayback = false;
     20   _togglesave = false;
    2021}
    2122
     
    2324bool KeyboardEventHandler::handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter&)
    2425{
    25     bool handled = false;
     26   bool handled = false;
    2627
    27     if( ea.getEventType() == osgGA::GUIEventAdapter::KEYDOWN )
    28     {
    29         switch( ea.getKey() )
    30             {
     28   if( ea.getEventType() == osgGA::GUIEventAdapter::KEYDOWN )
     29   {
     30      switch( ea.getKey() )
     31      {
    3132            case osgGA::GUIEventAdapter::KEY_Space:
    32                 _paused = _paused ? false : true;
    33                 handled = true;
    34                 break;
     33            _paused = _paused ? false : true;
     34            handled = true;
     35            break;
    3536
    3637            case osgGA::GUIEventAdapter::KEY_Up:
    37                 if( !_paused ) _tps *= 1.5;
    38                 handled = true;
    39                 break;
     38            if( !_paused ) _tps *= 1.5;
     39            handled = true;
     40            break;
    4041
    4142            case osgGA::GUIEventAdapter::KEY_Down:
    42                 if( !_paused ) _tps /= 1.5;
    43                 handled = true;
    44                 break;
     43            if( !_paused ) _tps /= 1.5;
     44            handled = true;
     45            break;
    4546
    4647            case 'r':
    47                 _paused = DEF_PAUSED_START;
    48                 _tps = _tpsorig;
    49                 _timestep = 0;
    50                 _timestepchanged = true;
    51                 handled = true;
    52                 break;
     48            _paused = DEF_PAUSED_START;
     49            _tps = _tpsorig;
     50            _timestep = 0;
     51            _timestepchanged = true;
     52            handled = true;
     53            break;
    5354
    5455            case osgGA::GUIEventAdapter::KEY_Right:
    55                 if( _paused )
    56                 {
    57                     _timestep = (_timestep+1) % _ntimesteps;
    58                     _timestepchanged = true;
    59                 }
    60                 else
    61                     _direction = +1;
    62                 handled = true;
    63                 break;
     56            if( _paused )
     57            {
     58               _timestep = (_timestep+1) % _ntimesteps;
     59               _timestepchanged = true;
     60            }
     61            else
     62               _direction = +1;
     63            handled = true;
     64            break;
    6465
    6566            case osgGA::GUIEventAdapter::KEY_Left:
    66                 if( _paused )
    67                 {
    68                     _timestep = _timestep-1;
    69                     if( _timestep < 0 ) _timestep = _ntimesteps-1;
    70                     _timestepchanged = true;
    71                 }
    72                 else
    73                     _direction = -1;
    74                 handled = true;
    75                 break;
     67            if( _paused )
     68            {
     69               _timestep = _timestep-1;
     70               if( _timestep < 0 ) _timestep = _ntimesteps-1;
     71               _timestepchanged = true;
     72            }
     73            else
     74               _direction = -1;
     75            handled = true;
     76            break;
    7677
    7778            case 'w':
    78                 _togglewireframe = true;
    79                 handled = true;
    80                 break;
     79            _togglewireframe = true;
     80            handled = true;
     81            break;
    8182
    8283            case 'c':
    83                 _toggleculling = true;
    84                 handled = true;
    85                 break;
     84            _toggleculling = true;
     85            handled = true;
     86            break;
    8687
    8788
    8889            case '1':
    89                 _togglerecording = true;
    90                 handled = true;
    91                 break;
     90            _togglerecording = true;
     91            handled = true;
     92            break;
    9293
    9394            case '2':
    94                 _toggleplayback = true;
    95                 handled = true;
    96                 break;
     95            _toggleplayback = true;
     96            handled = true;
     97            break;
    9798
    9899            case '3':
    99                 _togglesave = true;
    100                 handled = true;
    101                 break;
     100            _togglesave = true;
     101            handled = true;
     102            break;
    102103
    103             }
     104      }
    104105
    105     }
    106     return handled;
     106   }
     107   return handled;
    107108}
    108109
     
    110111void KeyboardEventHandler::setTime( float time)
    111112{
    112     if( !isPaused()  &&  time - _prevtime > 1.0/_tps )
    113     {
    114         _prevtime = time;
    115         _timestep = _timestep + _direction;
    116         if( _timestep == _ntimesteps )
     113   //std::cout << "setTime: " << time << std::endl;
     114   //std::cout << "setTime: " << _tps << std::endl;
     115   if( !isPaused()  &&  time - _prevtime > 1.0/_tps )
     116   {
     117      _prevtime = time;
     118      _timestep = _timestep + _direction;
     119      if( _timestep == _ntimesteps )
    117120            _timestep = 0;
    118         else if( _timestep < 0 )
     121      else if( _timestep < 0 )
    119122            _timestep = _ntimesteps-1;
    120         _timestepchanged = true;
    121     }
     123      _timestepchanged = true;
     124   }
    122125}
    123126
     
    125128bool KeyboardEventHandler::timestepChanged()
    126129{
    127     if( _timestepchanged )
    128     {
    129         _timestepchanged = false;
    130         return true;
    131     }
    132     return false;
     130   if( _timestepchanged )
     131   {
     132      _timestepchanged = false;
     133      return true;
     134   }
     135   return false;
    133136}
    134137
     
    136139bool KeyboardEventHandler::toggleWireframe()
    137140{
    138     if( _togglewireframe )
    139     {
    140         _togglewireframe = false;
    141         return true;
    142     }
    143     return false;
     141   if( _togglewireframe )
     142   {
     143      _togglewireframe = false;
     144      return true;
     145   }
     146   return false;
    144147}
    145148
     
    147150bool KeyboardEventHandler::toggleCulling()
    148151{
    149     if( _toggleculling )
    150     {
    151         _toggleculling = false;
    152         return true;
    153     }
    154     return false;
     152   if( _toggleculling )
     153   {
     154      _toggleculling = false;
     155      return true;
     156   }
     157   return false;
    155158}
    156159
     
    158161bool KeyboardEventHandler::toggleRecording()
    159162{
    160     if( _togglerecording )
    161     {
    162         _togglerecording = false;
    163         return true;
    164     }
    165     return false;
     163   if( _togglerecording )
     164   {
     165      _togglerecording = false;
     166      return true;
     167   }
     168   return false;
    166169}
    167170
     
    169172bool KeyboardEventHandler::togglePlayback()
    170173{
    171     if( _toggleplayback )
    172     {
    173         _toggleplayback = false;
    174         return true;
    175     }
    176     return false;
     174   if( _toggleplayback )
     175   {
     176      _toggleplayback = false;
     177      return true;
     178   }
     179   return false;
    177180}
    178181
     
    180183bool KeyboardEventHandler::toggleSave()
    181184{
    182     if( _togglesave )
    183     {
    184         _togglesave = false;
    185         return true;
    186     }
    187     return false;
     185   if( _togglesave )
     186   {
     187      _togglesave = false;
     188      return true;
     189   }
     190   return false;
    188191}
  • Swollen/swollen/keyboardeventhandler.h

    r114 r115  
    2121    virtual void accept(osgGA::GUIEventHandlerVisitor&) {}
    2222    virtual bool isPaused(){return _paused;}
     23    virtual void setPaused(bool value){_paused = value;}
    2324    virtual bool timestepChanged();
    2425    virtual bool toggleWireframe();
  • Swollen/swollen/main.cpp

    r114 r115  
    207207
    208208
    209    // animation mode is off to start
     209   // animation
     210   State s = State();
     211   std::vector<State> statelist;
    210212   bool recordingmode = false;
    211 
    212 
    213    // test state
    214    State* s = new State;
    215    std::vector<State>* statelist = new std::vector<State>;
     213   bool playbackmode = false;
     214   unsigned int playback_index = 0;
     215
     216
    216217 
    217218   unsigned int timestep = 0;
     
    223224
    224225
    225       // current time
    226       double time = viewer.getFrameStamp()->getReferenceTime();
    227 
    228       // advance sww frame?
    229       event_handler->setTime( time );
    230       if( event_handler->timestepChanged() )
     226      if( !playbackmode )
    231227      {
     228
     229         // current time
     230         double time = viewer.getFrameStamp()->getReferenceTime();
     231
     232
     233         event_handler->setTime( time );
    232234         timestep = event_handler->getTimestep();
    233235         water->setTimeStep(timestep);
    234236         hud->setTime( sww->getTime(timestep) );
     237
     238
     239         // events
     240         if( event_handler->toggleWireframe() )
     241            water->toggleWireframe();
     242
     243         if( event_handler->toggleCulling() )
     244         {
     245            sww->toggleCulling();
     246            water->setTimeStep(timestep);  // refresh
     247         }
     248
     249
     250         // '1' key starts/stops recording of view/position/setting info
     251         if( event_handler->toggleRecording() )
     252         {
     253            switch( recordingmode )
     254            {
     255               case false :
     256                  recordingmode = true;
     257                  hud->setRecordingMode("recording");
     258                  break;
     259               case true :
     260                  recordingmode = false;
     261                  hud->setRecordingMode("");
     262                  break;
     263            }
     264         }
     265
     266
     267         // '2' key starts playback of recorded frames
     268         if( event_handler->togglePlayback() )
     269         {
     270            recordingmode = false;
     271            switch( playbackmode )
     272            {
     273               case false :
     274                  playbackmode = true;
     275                  hud->setRecordingMode("playback");
     276                  event_handler->setPaused( true );
     277                  playback_index = 0;
     278                  // store current state
     279                  break;
     280               case true :
     281                  playbackmode = false;
     282                  hud->setRecordingMode("");
     283                  event_handler->setPaused( false );
     284                  // pop saved state
     285                  break;
     286            }
     287         }
     288
     289
     290         if( recordingmode )
     291         {
     292            s.setTimestep( event_handler->getTimestep() );
     293            s.setTime( sww->getTime(timestep) );
     294            s.setCulling( sww->getCulling() );
     295            s.setWireframe( water->getWireframe() );
     296            s.setPosition( viewer.getPosition() );
     297            s.setOrientation( viewer.getOrientation() );
     298            statelist.push_back( s );
     299            std::cout << "len(statelist): " << statelist.size() << std::endl;
     300         }
    235301      }
    236302
    237       // events
    238       if( event_handler->toggleWireframe() )
    239          water->toggleWireframe();
    240 
    241       if( event_handler->toggleCulling() )
     303      else
     304
    242305      {
    243          sww->toggleCulling();
    244          water->setTimeStep(timestep);  // refresh
     306         // in playback mode
     307         s = statelist.at( playback_index );
     308         water->setTimeStep( s.getTimestep() );
     309         hud->setTime( s.getTime() );
     310
     311         std::cout << "playing back: " << playback_index << std::endl;
     312
     313         // loop playback
     314         playback_index ++;
     315         if( playback_index == statelist.size() )
     316            playback_index = 0;
    245317      }
    246318
    247       /*
    248         Finite State Machine for animation
    249      
    250         0 1 1 begin storing view/orientation/cull settings
    251         0 2 2 if exists, store current settings, commence playback of saved animation path
    252         0 3 0 save animation to disk
    253 
    254         1 1 0 stop storing settings
    255         1 2 2 stop storing settings and commence playback
    256         1 3 1 save animation, keep recording
    257 
    258         2 2 0 stop playback, return to saved settings
    259         2 1 2 no effect
    260         2 3 2 save animation, continue playing back
    261 
    262         header comprised of original command line arguments
    263 
    264         state comprised of:
    265            frame
    266            elapsedtime
    267            position
    268            orientation
    269            timestep
    270            cullsteep
    271            wireframe
    272  
    273       */
    274 
    275 
    276       if( event_handler->toggleRecording() )
    277       {
    278          switch( recordingmode )
    279          {
    280             case false :
    281                recordingmode = true;
    282                hud->setRecordingMode("recording");
    283                break;
    284             case true :
    285                recordingmode = false;
    286                hud->setRecordingMode("");
    287                break;
    288          }
    289 
    290       }
    291 
    292       if( recordingmode )
    293       {
    294          s->setTimestep( event_handler->getTimestep() );
    295          s->setTime( sww->getTime(timestep) );
    296          s->setCulling( sww->getCulling() );
    297          s->setWireframe( water->getWireframe() );
    298          s->setPosition( viewer.getPosition() );
    299          s->setOrientation( viewer.getOrientation() );
    300          statelist->push_back( *s );
    301       }
    302 
    303       //s.write( std::cout );
    304319
    305320
    306321      // update the scene by traversing with the update visitor
    307322      viewer.update();
    308          
     323
    309324      // fire off the cull and draw traversals of the scene.
    310325      viewer.frame();
  • Swollen/swollen/state.h

    r113 r115  
    11
    22/*
    3     state.h, encapsulate current position, orientation and view settings
     3  state.h, encapsulate current position, orientation and view settings
    44
    5     An OpenSceneGraph viewer for pyVolution SWW files.
    6     copyright (C) 2004 Geoscience Australia
     5  An OpenSceneGraph viewer for pyVolution SWW files.
     6  copyright (C) 2004 Geoscience Australia
     7
     8
     9  Finite State Machine for animation
     10     
     11  0 1 1 begin storing view/orientation/cull settings
     12  0 2 2 if exists, store current settings, commence playback of saved animation path
     13  0 3 0 save animation to disk
     14
     15  1 1 0 stop storing settings
     16  1 2 2 stop storing settings and commence playback
     17  1 3 1 save animation, keep recording
     18
     19  2 2 0 stop playback, return to saved settings
     20  2 1 2 no effect
     21  2 3 2 save animation, continue playing back
     22
     23  header comprised of original command line arguments
     24
     25  state comprised of:
     26  frame
     27  elapsedtime
     28  position
     29  orientation
     30  timestep
     31  cullsteep
     32  wireframe
     33 
    734*/
     35
    836
    937
     
    3967    virtual void read(std::istream s);
    4068
     69    virtual ~State();
     70
    4171
    4272protected:
     
    4878    bool _culling;
    4979    bool _wireframe;
    50    
    51     virtual ~State();
    52 
     80 
    5381};
    5482
  • Swollen/swollen/version.cpp

    r111 r115  
    1 const char* version() { const char* s = "Revision: 110M"; return s; }
     1const char* version() { const char* s = "Revision: 114M"; return s; }
  • Swollen/swollen/watersurface.cpp

    r111 r115  
    11/*
    2     WaterSurface class
     2  WaterSurface class
    33
    4     An OpenSceneGraph viewer for pyVolution .sww files.
    5     copyright (C) 2004 Geoscience Australia
     4  An OpenSceneGraph viewer for pyVolution .sww files.
     5  copyright (C) 2004 Geoscience Australia
    66*/
    77
     
    1717
    1818#include <osgDB/ReadFile>
    19 #include <osgUtil/TriStripVisitor>
     19//#include <osgUtil/TriStripVisitor>
    2020
    2121#define DEF_ALPHA_THRESHOLD 0.05
     
    2525WaterSurface::WaterSurface(SWWReader* sww)
    2626{
    27     // persistent
    28     _sww = sww;
    29     _node = new osg::Geode;
    30     _geom = new osg::Geometry;
    31     _stateset = new osg::StateSet;
     27   // persistent
     28   _sww = sww;
     29   _node = new osg::Geode;
     30   _geom = new osg::Geometry;
     31   _stateset = new osg::StateSet;
    3232
    33     // construct local scenegraph hierarchy
    34     _node->setName("watersurface");
    35     _node->addDrawable(_geom);
    36     _node->setStateSet(_stateset);
     33   // construct local scenegraph hierarchy
     34   _node->setName("watersurface");
     35   _node->addDrawable(_geom);
     36   _node->setStateSet(_stateset);
    3737
    38     _geom->setUseDisplayList( false );
     38   _geom->setUseDisplayList( false );
    3939
    40     // initial geometry
    41     setTimeStep(0);
    4240
    43     // environment map
    44     osg::Texture2D* texture = new osg::Texture2D;
    45     texture->setDataVariance(osg::Object::DYNAMIC);
    46     texture->setBorderColor(osg::Vec4(1.0f,1.0f,1.0f,0.5f));
    47     texture->setWrap(osg::Texture::WRAP_S, osg::Texture::REPEAT);
    48     std::string* envmap = new std::string( _sww->getSwollenDir() + std::string("/") + std::string("envmap.jpg") );
    49     texture->setImage(osgDB::readImageFile( envmap->c_str() ));
    50     _stateset->setTextureAttributeAndModes( 1, texture, osg::StateAttribute::ON );
    51     _stateset->setMode( GL_LIGHTING, osg::StateAttribute::ON );
     41   // surface starts on first timestep
     42   _timestep = 0;
     43   _dirtytimestep = true;  // will force load of watersurface
    5244
    53     // surface transparency
    54     osg::BlendFunc* osgBlendFunc = new osg::BlendFunc();
    55     osgBlendFunc->setFunction(osg::BlendFunc::SRC_ALPHA, osg::BlendFunc::ONE_MINUS_SRC_ALPHA);
    56     _stateset->setAttribute(osgBlendFunc);
    57     _stateset->setMode(GL_BLEND, osg::StateAttribute::ON);
    58     _stateset->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);
     45   // default is filled watersurface
     46   _wireframe = false;
     47   _dirtywireframe = true;  // will force wireframe refresh
    5948
    60     // discard pixels with an alpha value below threshold
    61     osg::AlphaFunc* alphaFunc = new osg::AlphaFunc;
    62     alphaFunc->setFunction( osg::AlphaFunc::GREATER, DEF_ALPHA_THRESHOLD );
    63     _stateset->setAttributeAndModes( alphaFunc, osg::StateAttribute::ON );
    6449
    65     // automatically generate texture coords
    66     osg::TexGen* texgen = new osg::TexGen;
    67     texgen->setMode( osg::TexGen::SPHERE_MAP );
    6850
    69     osg::TexEnv* texenv = new osg::TexEnv;
    70     texenv->setMode( osg::TexEnv::DECAL );
    71     //texenv->setMode( osg::TexEnv::BLEND );
    72     texenv->setColor( osg::Vec4(0.6f,0.6f,0.6f,0.2f) );
    73     _stateset->setTextureAttributeAndModes( 1, texgen, osg::StateAttribute::ON );
    74     _stateset->setTextureAttribute( 1, texenv );
     51   // environment map
     52   osg::Texture2D* texture = new osg::Texture2D;
     53   texture->setDataVariance(osg::Object::DYNAMIC);
     54   texture->setBorderColor(osg::Vec4(1.0f,1.0f,1.0f,0.5f));
     55   texture->setWrap(osg::Texture::WRAP_S, osg::Texture::REPEAT);
     56   std::string* envmap = new std::string( _sww->getSwollenDir() + std::string("/") + std::string("envmap.jpg") );
     57   texture->setImage(osgDB::readImageFile( envmap->c_str() ));
     58   _stateset->setTextureAttributeAndModes( 1, texture, osg::StateAttribute::ON );
     59   _stateset->setMode( GL_LIGHTING, osg::StateAttribute::ON );
    7560
    76     // default is filled watersurface
    77     _wireframe = false;
     61   // surface transparency
     62   osg::BlendFunc* osgBlendFunc = new osg::BlendFunc();
     63   osgBlendFunc->setFunction(osg::BlendFunc::SRC_ALPHA, osg::BlendFunc::ONE_MINUS_SRC_ALPHA);
     64   _stateset->setAttribute(osgBlendFunc);
     65   _stateset->setMode(GL_BLEND, osg::StateAttribute::ON);
     66   _stateset->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);
     67
     68   // discard pixels with an alpha value below threshold
     69   osg::AlphaFunc* alphaFunc = new osg::AlphaFunc;
     70   alphaFunc->setFunction( osg::AlphaFunc::GREATER, DEF_ALPHA_THRESHOLD );
     71   _stateset->setAttributeAndModes( alphaFunc, osg::StateAttribute::ON );
     72
     73   // automatically generate texture coords
     74   osg::TexGen* texgen = new osg::TexGen;
     75   texgen->setMode( osg::TexGen::SPHERE_MAP );
     76
     77   osg::TexEnv* texenv = new osg::TexEnv;
     78   texenv->setMode( osg::TexEnv::DECAL );
     79   //texenv->setMode( osg::TexEnv::BLEND );
     80   texenv->setColor( osg::Vec4(0.6f,0.6f,0.6f,0.2f) );
     81   _stateset->setTextureAttributeAndModes( 1, texgen, osg::StateAttribute::ON );
     82   _stateset->setTextureAttribute( 1, texenv );
    7883
    7984}
     
    8994void WaterSurface::setTimeStep(unsigned int ts)
    9095{
    91     // delete if exists
    92     if( _geom->getNumPrimitiveSets() )
    93       _geom->removePrimitiveSet(0);  // reference counting does actual delete
    94 
    95     // local reference to raw height field data
    96     osg::ref_ptr<osg::Vec3Array> vertices = _sww->getStageVertexArray(ts);
    97     osg::ref_ptr<osg::Vec3Array> vertexnormals = _sww->getStageVertexNormalArray();
    98     osg::ref_ptr<osg::Vec4Array> colors = _sww->getStageColorArray();
    99 
    100     // geometry
    101     _geom->setVertexArray( vertices.get() );
    102     _geom->addPrimitiveSet( _sww->getBedslopeIndexArray().get() );
    103 
    104     // per vertex colors (we only modulate the alpha for transparency)
    105     _geom->setColorArray( colors.get() );
    106     _geom->setColorBinding(osg::Geometry::BIND_PER_VERTEX);
    107 
    108     // normals
    109     _geom->setNormalArray( vertexnormals.get() );
    110     _geom->setNormalBinding(osg::Geometry::BIND_PER_VERTEX);
    111 
    112     // osgUtil::TriStripVisitor* optimize = new osgUtil::TriStripVisitor();
    113     // optimize->stripify( *_geom );
    114 
     96   if( ts != _timestep )
     97   {
     98      _timestep = ts;
     99      _dirtytimestep = true;
     100   }
    115101}
    116102
     
    118104void WaterSurface::toggleWireframe()
    119105{
    120    if( _wireframe )
    121       _wireframe = false;
    122    else
    123       _wireframe = true;
    124 
    125    setWireframe(_wireframe);
     106   setWireframe( _wireframe ? false : true );
    126107}
    127108
     
    129110void WaterSurface::setWireframe(bool value)
    130111{
    131     osg::PolygonMode* polyModeObj =
    132         dynamic_cast<osg::PolygonMode*>(_stateset->getAttribute(osg::StateAttribute::POLYGONMODE));
     112   if( value != _wireframe )
     113   {
     114      _wireframe = value;
     115      _dirtywireframe = true;
     116   }
     117}
    133118
    134     if (!polyModeObj)
    135     {
    136             polyModeObj = new osg::PolygonMode;
    137             _stateset->setAttribute(polyModeObj);
    138     }
    139119
    140     switch( value )
    141     {
    142        case true :
    143           polyModeObj->setMode(osg::PolygonMode::FRONT_AND_BACK, osg::PolygonMode::LINE);
    144           break;
     120void WaterSurface::update()
     121{
    145122
    146        case false :
    147          polyModeObj->setMode(osg::PolygonMode::FRONT_AND_BACK, osg::PolygonMode::FILL);
    148          break;
    149     }
     123   if( _dirtytimestep )
     124   {
     125      // delete if exists
     126      if( _geom->getNumPrimitiveSets() )
     127         _geom->removePrimitiveSet(0);  // reference counting does actual delete
     128
     129      // local reference to raw height field data
     130      osg::ref_ptr<osg::Vec3Array> vertices = _sww->getStageVertexArray(_timestep);
     131      osg::ref_ptr<osg::Vec3Array> vertexnormals = _sww->getStageVertexNormalArray();
     132      osg::ref_ptr<osg::Vec4Array> colors = _sww->getStageColorArray();
     133
     134      // geometry
     135      _geom->setVertexArray( vertices.get() );
     136      _geom->addPrimitiveSet( _sww->getBedslopeIndexArray().get() );
     137
     138      // per vertex colors (we only modulate the alpha for transparency)
     139      _geom->setColorArray( colors.get() );
     140      _geom->setColorBinding(osg::Geometry::BIND_PER_VERTEX);
     141
     142      // normals
     143      _geom->setNormalArray( vertexnormals.get() );
     144      _geom->setNormalBinding(osg::Geometry::BIND_PER_VERTEX);
     145
     146      // osgUtil::TriStripVisitor* optimize = new osgUtil::TriStripVisitor();
     147      // optimize->stripify( *_geom );
     148
     149      // water surface corresponding to _timestep is now loaded ...
     150      _dirtytimestep = false;
     151   }
     152
     153
     154   if( _dirtywireframe )
     155   {
     156      osg::PolygonMode* polyModeObj =
     157         dynamic_cast<osg::PolygonMode*>(_stateset->getAttribute(osg::StateAttribute::POLYGONMODE));
     158
     159      if (!polyModeObj)
     160      {
     161         polyModeObj = new osg::PolygonMode;
     162         _stateset->setAttribute(polyModeObj);
     163      }
     164
     165      switch( _wireframe )
     166      {
     167         case true :
     168            polyModeObj->setMode(osg::PolygonMode::FRONT_AND_BACK, osg::PolygonMode::LINE);
     169            break;
     170
     171         case false :
     172            polyModeObj->setMode(osg::PolygonMode::FRONT_AND_BACK, osg::PolygonMode::FILL);
     173            break;
     174      }
     175
     176      // desired wireframe mode now loaded ...
     177      _dirtywireframe = false;
     178
     179   }
     180
     181
    150182}
  • Swollen/swollen/watersurface.h

    r111 r115  
    2929    virtual bool getWireframe(){ return _wireframe; };
    3030    virtual void setWireframe(bool wireframe);
     31    virtual void update();
    3132
    3233protected:
     
    3637    osg::Geometry* _geom;
    3738    osg::StateSet* _stateset;
     39    unsigned int _timestep;
    3840    virtual ~WaterSurface();
    39     bool _wireframe;
     41    bool _wireframe, _dirtywireframe;
     42    bool _dirtytimestep;
    4043};
    4144
Note: See TracChangeset for help on using the changeset viewer.