SpaceWareSensor.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 __SPACEWARESENSOR_H__
#define __SPACEWARESENSOR_H__
 
 
#include <H3D/X3DSensorNode.h>
#include <list>
#include <H3D/SFVec3f.h>
#include <H3D/SFFloat.h>
#include <H3D/SFInt32.h>
#include <H3D/SFRotation.h>
#include <H3DUtil/Threads.h>
 
namespace H3D {
 
  class H3DAPI_API SpaceWareSensor : public X3DSensorNode {
  public:
 
    struct H3DAPI_API ScaleRotation: 
      public TypedField< SFRotation,
                         Types< SFRotation, SFFloat > > {
      virtual void update() {
        Rotation r = 
          static_cast< SFRotation * >( routes_in[0] )->getValue();
        H3DFloat s = 
          static_cast< SFFloat * >( routes_in[1] )->getValue();
 
        value = r * s;
      }
    };
 
    struct H3DAPI_API ScaleTranslation: 
      public TypedField< SFVec3f,
                         Types< SFVec3f, SFFloat > > {
      virtual void update() {
        const Vec3f &r = static_cast< SFVec3f * >( routes_in[0] )->getValue();
        H3DFloat s = static_cast< SFFloat * >( routes_in[1] )->getValue();
        value = r * s;
      }
    };
 
 
    struct H3DAPI_API AccumulateRotation:
      public AutoUpdate< SFRotation > {
        AccumulateRotation() { last_time = TimeStamp(); }
      
      virtual void setValue( const Rotation &r, int _id = 0 ) {
        SFRotation::setValue( r, _id );
        last_time = TimeStamp();
      }
 
      virtual void update() {
        H3DTime current_time = TimeStamp();
        H3DTime time_scale = 1;
        if( static_cast< SpaceWareSensor * >(owner)->accumulateTimeDependent->getValue() )
          time_scale = current_time - last_time;
        last_time = current_time;
        Rotation r = static_cast< SFRotation * >( event.ptr )->getValue();
        value = ( r * time_scale ) * value;
      }
      protected:
      H3DTime last_time;
    };
 
    class H3DAPI_API ResetAccumulatedRotation: 
      public AutoUpdate< SFRotation > {
 
     public:
      virtual void setValue( const Rotation &r, int _id = 0 ) {
        SFRotation::setValue( r, _id );
        SpaceWareSensor * sws = static_cast< SpaceWareSensor * >(owner);
        sws->accumulatedRotation->setValue( r, sws->id );
        Rotation temp_r = r;
        Vec3f euler_angles = temp_r.toEulerAngles();
        sws->accumulatedYaw->setValue(
          Rotation( 1, 0, 0, euler_angles.x ), sws->id );
        sws->accumulatedPitch->setValue(
          Rotation( 0, 1, 0, euler_angles.y ), sws->id );
        sws->accumulatedRoll->setValue(
          Rotation( 0, 0, 1, euler_angles.z ), sws->id );        
      }
      
    protected:
      virtual void update() {
        SFRotation::update();
        SpaceWareSensor * sws = static_cast< SpaceWareSensor * >(owner);
        sws->accumulatedRotation->setValue( value, sws->id );
        Rotation temp_r = value;
        Vec3f euler_angles = temp_r.toEulerAngles();
        sws->accumulatedYaw->setValue(
          Rotation( 1, 0, 0, euler_angles.x ), sws->id );
        sws->accumulatedPitch->setValue(
          Rotation( 0, 1, 0, euler_angles.y ), sws->id );
        sws->accumulatedRoll->setValue(
          Rotation( 0, 0, 1, euler_angles.z ), sws->id );     
      }
    };
#ifdef __BORLANDC__
    friend class ResetAccumulatedRotation;
#endif
 
    struct H3DAPI_API AccumulateTranslation: 
      public AutoUpdate< SFVec3f > {
      AccumulateTranslation() { last_time = TimeStamp(); }
 
      virtual void setValue( const Vec3f &v, int _id = 0 ) {
        SFVec3f::setValue( v, _id );
        last_time = TimeStamp();
      }
      
      virtual void update() {
        H3DTime current_time = TimeStamp();
        H3DTime time_scale = 1;
        if( static_cast< SpaceWareSensor * >(owner)->accumulateTimeDependent->getValue() )
          time_scale = ( current_time - last_time ) * 0.025f;
        last_time = current_time;
        const Vec3f &v = static_cast< SFVec3f * >( event.ptr )->getValue();
        value = value + v * time_scale;
      }
    protected:
      H3DTime last_time;
    };
 
    class H3DAPI_API ResetAccumulatedTranslation: 
      public AutoUpdate< SFVec3f > {
    public:
      virtual void setValue( const Vec3f &v, int _id = 0 ) {
        SFVec3f::setValue( v, _id );
        SpaceWareSensor * sws = static_cast< SpaceWareSensor * >(owner);
        sws->accumulatedTranslation->setValue( v, sws->id );
      }
    protected: 
      virtual void update() {
        SFVec3f::update();
        SpaceWareSensor * sws = static_cast< SpaceWareSensor * >(owner);
        sws->accumulatedTranslation->setValue( value, sws->id );
      }
    };
#ifdef __BORLANDC__
    friend class ResetAccumulatedTranslation;
#endif
  
    SpaceWareSensor( 
                    Inst< SFBool                > _enabled  = 0,
                    Inst< SFNode                > _metadata = 0,
                    Inst< SFBool                > _isActive = 0,
                    Inst< SFVec3f               > _rawTranslation = 0,
                    Inst< SFRotation            > _rawYaw = 0,
                    Inst< SFRotation            > _rawPitch = 0,
                    Inst< SFRotation            > _rawRoll = 0,
                    Inst< SFRotation            > _rawRotation = 0,
                    Inst< ScaleTranslation      > _instantTranslation = 0,
                    Inst< ScaleRotation         > _instantYaw = 0,
                    Inst< ScaleRotation         > _instantPitch = 0,
                    Inst< ScaleRotation         > _instantRoll = 0,
                    Inst< ScaleRotation         > _instantRotation = 0,
                    Inst< AccumulateTranslation > _accumulatedTranslation = 0,
                    Inst< AccumulateRotation    > _accumulatedYaw = 0,
                    Inst< AccumulateRotation    > _accumulatedPitch = 0,
                    Inst< AccumulateRotation    > _accumulatedRoll = 0,
                    Inst< AccumulateRotation    > _accumulatedRotation = 0,
                    Inst< SFFloat               > _translationScale = 0,
                    Inst< SFFloat               > _rotationScale = 0,
                    Inst< SFInt32               > _buttons = 0,
                    Inst< SFInt32               > _latestButtonPress = 0,
                    Inst< SFInt32               > _latestButtonRelease = 0,
                    Inst< SFBool                > _accumulateTimeDependent = 0,
          Inst< ResetAccumulatedTranslation > _resetAccumulatedTranslation = 0,
          Inst< ResetAccumulatedRotation > _resetAccumulatedRotation = 0
                    );
 
    ~SpaceWareSensor() {
      if( this == sws_instance )
        sws_instance = 0;
    }
 
    H3DUniquePtr< SFVec3f>             rawTranslation;
 
    H3DUniquePtr< SFRotation>          rawYaw;
 
    H3DUniquePtr< SFRotation>          rawPitch;
 
    H3DUniquePtr< SFRotation>          rawRoll;
 
    H3DUniquePtr< SFRotation>        rawRotation;
 
    H3DUniquePtr< ScaleTranslation>  instantTranslation;
 
    H3DUniquePtr< ScaleRotation>     instantYaw;
 
    H3DUniquePtr< ScaleRotation>     instantPitch;
 
    H3DUniquePtr< ScaleRotation>     instantRoll;
 
    H3DUniquePtr< ScaleRotation>     instantRotation;
 
    H3DUniquePtr< AccumulateTranslation>  accumulatedTranslation;
 
    H3DUniquePtr< AccumulateRotation>     accumulatedYaw;
 
    H3DUniquePtr< AccumulateRotation>     accumulatedPitch;
 
    H3DUniquePtr< AccumulateRotation>     accumulatedRoll; 
 
    H3DUniquePtr< AccumulateRotation>     accumulatedRotation;
 
    H3DUniquePtr< SFFloat>          translationScale; 
 
    H3DUniquePtr< SFFloat>          rotationScale;
 
    H3DUniquePtr< SFInt32 > buttons;
 
    H3DUniquePtr< SFInt32 > latestButtonPress;
 
    H3DUniquePtr< SFInt32 > latestButtonRelease;
 
    H3DUniquePtr< SFBool > accumulateTimeDependent;
 
    H3DUniquePtr< ResetAccumulatedTranslation > resetAccumulatedTranslation;
 
    H3DUniquePtr< ResetAccumulatedRotation > resetAccumulatedRotation;
 
    // This data structure is used to transfer button data from the 
    // device communication thread to the scene graph thread.
    struct ButtonData {
      ButtonData( int _pressed, 
                  int _released,
                  int _current_state ) :
        pressed( _pressed ),
        released( _released ),
        current_state( _current_state ) {}
      unsigned int pressed, released, current_state;
    };
  public:
    // has a motion event occured since last scenegraph loop.
    bool thread_motion_event;
    // button data since last scenegraph loop.
    vector< ButtonData > thread_buttons; 
    // rotation values from the last motion event.
    Vec3f thread_rotation;
    // translation values from the last motion event.
    Vec3f thread_translation;
    // is_active in thread. Will be false if thread main loop
    // can not run due to some error.
    bool thread_is_active;
 
    static H3DNodeDatabase database;
 
    // instance of the first SpaceWareSensor created
    // used if the spacewaresensor should be used to navigate the scene
    static SpaceWareSensor *sws_instance;
 
  private:
#ifdef HAVE_3DXWARE
    // the handle of the communication thread.
    H3DUniquePtr< H3DUtil::SimpleThread > thread_handle;
#endif
 
    void updateValues();
    
    struct H3DAPI_API Update
      : AutoUpdate<Field> {
      void update(){
        static_cast<SpaceWareSensor*>
          (owner)->updateValues();
      }
    };
    
    H3DUniquePtr< Update > update;
  };
}
 
#endif