TraverseInfo.h

Go to the documentation of this file.

//    Copyright 2004-2019, SenseGraphics AB
//
//    This file is part of H3D API.
//
//    H3D API is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//    H3D API is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with H3D API; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//    A commercial license is also available. Please contact us at 
//    www.sensegraphics.com for more information.
//
//
//
//
#ifndef __TRAVERSEINFO_H__
#define __TRAVERSEINFO_H__
 
#include <H3D/H3DTypes.h>
#include <HAPI/HAPIForceEffect.h>
#include <HAPI/HAPIHapticShape.h>
#include <H3DUtil/AutoRefVector.h>
#include <sstream>
#include <stack>
#include <map>
 
 
namespace H3D {
  // forward declarations
  class H3DSurfaceNode;
  class H3DHapticsDevice;
  class X3DGeometryNode;
  class X3DLightNode;
 
  typedef AutoRefVector< HAPI::HAPIHapticShape > HapticShapeVector;
  typedef AutoRefVector< HAPI::HAPIForceEffect > HapticEffectVector;
 
  class H3DAPI_API TraverseInfo {
  public:
 
    H3D_VALUE_EXCEPTION( int, InvalidHapticsDeviceIndex ); 
 
    TraverseInfo( const vector< H3DHapticsDevice * > &_haptics_devices );
 
    inline unsigned int nrLayers() {
      if( haptic_shapes.size() > 0 ) {
        return (unsigned int) haptic_shapes[0].size();
      } else {
        return 0;
      }
    }
 
    inline void initializeLayers( unsigned int nr_layers ) {
      for( unsigned int i = 0; i < haptic_shapes.size(); ++i ) {
        if( haptic_shapes[i].size() < nr_layers )
          haptic_shapes[i].resize( nr_layers );
      }
    }
 
    inline void setCurrentLayer( unsigned int layer ) {
      current_layer = layer;
    }
 
    inline unsigned int getCurrentLayer() {
      return current_layer;
    }
 
    inline int getHapticsDeviceIndex( H3DHapticsDevice *hd ) {
      int index = 0;
      for( vector< H3DHapticsDevice * >::iterator i = haptics_devices.begin();
           i != haptics_devices.end();
           ++i, ++index ) {
        if( (*i) == hd ) return index;
      }
      return -1;
    } 
 
    void addHapticShape( int device_index, 
                         HAPI::HAPIHapticShape *shape );
 
    inline void addHapticShape( H3DHapticsDevice *hd, 
                                HAPI::HAPIHapticShape *shape ) {
      int device_index = getHapticsDeviceIndex( hd );
      addHapticShape( device_index, shape );
    }
    
    void addHapticShapeToAll( HAPI::HAPIHapticShape *shape );
 
    inline const HapticShapeVector &getHapticShapes(int device_index ){
      if( device_index < 0 || device_index >= (int)haptics_devices.size() ) {
        stringstream s;
        s << "TraverseInfo only has " << (unsigned int) haptics_devices.size() 
          << " haptics device available. ";
        throw InvalidHapticsDeviceIndex( device_index,
                                         s.str(),
                                         H3D_FULL_LOCATION );
      }
      return haptic_shapes[ device_index ][ current_layer ];
    }
 
    inline const HapticShapeVector 
    &getHapticShapes( H3DHapticsDevice * hd ) {
      int device_index = getHapticsDeviceIndex( hd );
      return getHapticShapes( device_index );
    }
 
    void addForceEffect( int device_index, HAPI::HAPIForceEffect *effect );
 
    inline void addForceEffect( H3DHapticsDevice *hd, 
                                HAPI::HAPIForceEffect *effect ) {
      int device_index = getHapticsDeviceIndex( hd );
      addForceEffect( device_index, effect );
    }
    
    void addForceEffectToAll( HAPI::HAPIForceEffect *effect );
                
    inline const HapticEffectVector 
      &getForceEffects( int device_index){
      if( device_index < 0 || device_index >= (int)haptics_devices.size() ) {
        stringstream s;
        s << "TraverseInfo only has " << (unsigned int)haptics_devices.size() 
          << " haptics device available. ";
        throw InvalidHapticsDeviceIndex( device_index,
                                         s.str(),
                                         H3D_FULL_LOCATION );
      }
      return haptic_effects[ device_index ];
    }
    
    inline const HapticEffectVector
      &getForceEffects( H3DHapticsDevice * hd ) {
      int device_index = getHapticsDeviceIndex( hd );
      return getForceEffects( device_index );
    }
    
    inline void setCurrentSurface( H3DSurfaceNode *s ) {
      current_surface = s;
    }
 
    inline H3DSurfaceNode * getCurrentSurface() {
      return current_surface;
    }
    
    inline H3DHapticsDevice *getHapticsDevice( int device_index ) {
      return haptics_devices[ device_index ];
    }
 
    inline const vector< H3DHapticsDevice * > &getHapticsDevices() {
      return haptics_devices;
    }
 
    inline void disableHaptics( int i = -1 ) {
      if( i == -1 ) {
        for( unsigned int j = 0; j < haptics_enabled.size(); ++j ) {
          haptics_enabled[j] = false;
        }
      } else {
        haptics_enabled[i] = false;
      }
    }
 
    inline void enableHaptics( int i = -1 ) {
      if( i == -1 ) {
        for( unsigned int j = 0; j < haptics_enabled.size(); ++j ) {
          haptics_enabled[j] = true;
        }
      } else {
        haptics_enabled[i] = true;
      }
    }
 
    inline void disableGraphics() {
      graphics_enabled = false;
    }
 
    inline void enableGraphics() {
      graphics_enabled = true;
    }
    
    inline void setMultiPassTransparency( bool b ) {
      multi_pass_transparency = b;
    }
 
    inline bool getMultiPassTransparency() {
      return multi_pass_transparency;
    }
 
    inline bool hapticsEnabled( unsigned int i = 0 ) {
      if( i < haptics_enabled.size() ) {
        return haptics_enabled[i];
      } else {
        return false;
      }
    }
 
    inline bool hapticsEnabledForAll() {
      for( unsigned int i = 0; i < haptics_enabled.size(); ++i ) {
        if( !haptics_enabled[i] ) return false;
      }
      return true;
    }
 
    inline bool hapticsDisabledForAll() {
      for( unsigned int i = 0; i < haptics_enabled.size(); ++i ) {
        if( haptics_enabled[i] ) return false;
      }
      return true;
    }
 
    inline const vector< bool >&getHapticsEnabled() {
      return haptics_enabled;
    }
 
    inline int setHapticsEnabled( const vector< bool > &enabled) {
      if( enabled.size() != haptics_enabled.size() ) return -1;
      else {
        haptics_enabled = enabled;
        return 0;
      }
    }
 
    inline bool graphicsEnabled() {
      return graphics_enabled;
    }
 
    inline void pushMatrices( const Matrix4f &forward,
                              const Matrix4f &inverse ) {
      const TransformInfo &top = transform_stack.top();
      transform_stack.push( TransformInfo( top.acc_frw * forward,
                                           inverse * top.acc_inv ) );
    }
 
    inline void popMatrices() {
      transform_stack.pop();
    }
 
    inline const Matrix4f &getAccForwardMatrix() {
      return transform_stack.top().acc_frw;
    }
 
    inline const Matrix4f &getAccInverseMatrix() {
      return transform_stack.top().acc_inv;
    }
    
    inline int getGeometryCount( X3DGeometryNode *geom ) {
      return geometry_count[geom];
    }
 
    inline void setUserData( const string &key, void *data ) {
      user_data[key] = data;
    }
 
    inline bool haveUserData( const string &key ) {
      return user_data.find( key ) != user_data.end();
    }
 
    inline int deleteUserData( const string &key ) {
      std::map<string, void *>::iterator i = user_data.find( key );
      if( i != user_data.end() ) {
        user_data.erase( i );
        return 0;
      } else {
        return -1;
      }
    }
    
    inline int getUserData( const string &key, void ** data ) {
      std::map<string, void *>::iterator i = user_data.find( key );
      if( i != user_data.end() ) {
        *data = (*i).second; 
        return 0;
      } else {
        return -1;
      }
    }
 
    typedef void (*CallbackFunc)(TraverseInfo &ti, void *data); 
 
    inline void addPostTraverseCallback( CallbackFunc func, void *data ) {
      post_traverse_callbacks.push_back( make_pair( func, data ) );
    }
      
    void callPostTraverseCallbacks();
 
    class H3DAPI_API LightInfo {
    public:
      LightInfo( X3DLightNode *, const Matrix4f &transform );
      X3DLightNode *getLight() const;
      inline const Matrix4f &getLightTransform() const { return transform; }
    protected:
      AutoRef< Node > light;
      Matrix4f transform;
    };
 
    typedef vector< LightInfo > LightVector;
 
    void addActiveLightNode( X3DLightNode *light, const Matrix4f &transform );
 
    void removeActiveLightNode( X3DLightNode *light, const Matrix4f &transform );
    
    const LightVector &getActiveLightNodes();
 
  protected:
    LightVector x3dlightnode_vector;
 
    class TransformInfo {
    public:
      TransformInfo( const Matrix4f &_acc_frw,
                     const Matrix4f &_acc_inv ):
        acc_frw( _acc_frw ),
        acc_inv( _acc_inv ) {}
      Matrix4f acc_frw, acc_inv;
    };
    stack< TransformInfo > transform_stack;
    
    typedef std::list< std::pair< CallbackFunc, void * > > CallbackList;
    // A list of the callback functions to run after scene traversal.
    CallbackList post_traverse_callbacks;
 
    unsigned int current_layer;
    H3DSurfaceNode *current_surface;
    vector< H3DHapticsDevice * > haptics_devices;
    vector< vector< HapticShapeVector > > haptic_shapes;
    vector< HapticEffectVector > haptic_effects;
    bool graphics_enabled;
    bool multi_pass_transparency;
    // When the global haptics_enabled is true the following vector contains
    // per devceinformation about which devices have haptics enabled.
    vector< bool > haptics_enabled;
 
    typedef std::map< X3DGeometryNode *, int > GeometryCountMap;
    GeometryCountMap geometry_count;
    std::map< string, void * > user_data;
  };
 
}
 
#endif