TraverseInfo.h

Go to the documentation of this file.

//    Copyright 2004, 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 "H3DTypes.h"
#include "HapticForceEffect.h"
#include "HapticShape.h"
#include "AutoRefVector.h"
#include <sstream>
#include <stack>

using namespace std;

namespace H3D {
  // forward declarations
  class HapticShape;
  class H3DSurfaceNode;
  class H3DHapticsDevice;

  typedef AutoRefVector< HapticShape > HapticShapeVector;
  typedef AutoRefVector< HapticForceEffect > HapticEffectVector;

  class H3DAPI_API TraverseInfo {
  public:
 
    H3D_VALUE_EXCEPTION( int, InvalidHapticsDeviceIndex ); 

    TraverseInfo( const vector< H3DHapticsDevice * > &_haptics_devices ) :
      current_surface( NULL ),
      haptics_devices( _haptics_devices ),
      haptic_shapes( _haptics_devices.size() ),
      haptic_effects( _haptics_devices.size() ),
      haptics_enabled( true ) {
      // put two unit matrices on the transform stack.
      transform_stack.push( TransformInfo( Matrix4f(), Matrix4f () ) );
    }

    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, HapticShape *shape );

    inline void addHapticShape( H3DHapticsDevice *hd, HapticShape *shape ) {
      int device_index = getHapticsDeviceIndex( hd );
      addHapticShape( device_index, shape );
    }
    
    void addHapticShapeToAll( HapticShape *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 ];
    }

    inline const HapticShapeVector 
      &getHapticShapes( H3DHapticsDevice * hd ) {
      int device_index = getHapticsDeviceIndex( hd );
      return getHapticShapes( device_index );
    }

    void addForceEffect( int device_index, HapticForceEffect *effect );

    inline void addForceEffect( H3DHapticsDevice *hd, 
                                HapticForceEffect *effect ) {
      int device_index = getHapticsDeviceIndex( hd );
      addForceEffect( device_index, effect );
    }
    
    void addForceEffectToAll( HapticForceEffect *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() {
      haptics_enabled = false;
    }

    inline void enableHaptics() {
      haptics_enabled = true;
    }

    inline bool hapticsEnabled() {
      return haptics_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;
    }

  protected:
    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;
    
    H3DSurfaceNode *current_surface;
    vector< H3DHapticsDevice * > haptics_devices;
    vector< HapticShapeVector > haptic_shapes;
    vector< HapticEffectVector > haptic_effects;
    bool haptics_enabled;
  };

};

#endif

---