SpaceWareSensor.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 __SPACEWARESENSOR_H__
#define __SPACEWARESENSOR_H__


#include "X3DSensorNode.h"
#include <list>
#include "SFVec3f.h"
#include "SFFloat.h"
#include "SFInt32.h"
#include "SFRotation.h"
#include "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();
  
        //TODO: fix so that operator can be used
        r.angle = r.angle * s;
        value = r;
      }
    };

    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 > {
      virtual void update() {
        Rotation r = static_cast< SFRotation * >( event.ptr )->getValue();
        value = r * value;
      }
    };

    struct H3DAPI_API AccumulateTranslation: 
      public AutoUpdate< SFVec3f > {
      virtual void update() {
        const Vec3f &v = static_cast< SFVec3f * >( event.ptr )->getValue();
        value = value + v;
      }
    };
  
    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
                    );

    auto_ptr< SFVec3f>             rawTranslation;

    auto_ptr< SFRotation>          rawYaw;

    auto_ptr< SFRotation>          rawPitch;

    auto_ptr< SFRotation>          rawRoll;

    auto_ptr< SFRotation>        rawRotation;

    auto_ptr< ScaleTranslation>  instantTranslation;

    auto_ptr< ScaleRotation>     instantYaw;

    auto_ptr< ScaleRotation>     instantPitch;

    auto_ptr< ScaleRotation>     instantRoll;

    auto_ptr< ScaleRotation>      instantRotation;

    auto_ptr< AccumulateTranslation>  accumulatedTranslation;

    auto_ptr< AccumulateRotation>     accumulatedYaw;

    auto_ptr< AccumulateRotation>     accumulatedPitch;

    auto_ptr< AccumulateRotation>     accumulatedRoll; 

    auto_ptr< AccumulateRotation>     accumulatedRotation;

    auto_ptr< SFFloat>          translationScale; 

    auto_ptr< SFFloat>          rotationScale;

    auto_ptr< SFInt32 > buttons;

    auto_ptr< SFInt32 > latestButtonPress;

    auto_ptr< SFInt32 > latestButtonRelease;

#ifdef USE_HAPTICS
    virtual void traverseSG( TraverseInfo &ti );
#endif

    // 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;
    static H3DNodeDatabase database;

  private:
#ifdef HAVE_3DXWARE
    // the handle of the communication thread.
    auto_ptr< SimpleThread > thread_handle;
#endif
  };
}

#endif

---