H3DFakeHapticsDevice.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 __H3DFAKEHAPTICSDEVICE_H__
#define __H3DFAKEHAPTICSDEVICE_H__
 
#include "H3D/H3DHapticsDevice.h"
#include "H3D/SFFloat.h"
#include "H3D/PeriodicUpdate.h"
#include <H3DUtil/Threads.h>
 
#include <HAPI/HAPIHapticsDevice.h>
 
namespace H3D {
  class H3DAPI_API H3DFakeHapticsDevice: public H3DHapticsDevice {
  public:
    class H3DAPI_API FakeHapticsDevice: public HAPI::HAPIHapticsDevice {
    public:
      FakeHapticsDevice() : owner( NULL ) {}
 
      virtual void updateDeviceValues( DeviceValues &dv, HAPI::HAPITime dt );
 
      virtual void sendOutput( DeviceOutput &/*dv*/,
             HAPI::HAPITime /*dt*/ ) {}
 
      virtual bool initHapticsDevice( int /*_thread_frequency*/ = 1000 ) {
        return true;
      }
 
      virtual bool releaseHapticsDevice() { return true; }
    protected:
      H3DFakeHapticsDevice *owner;
    
  friend class H3DFakeHapticsDevice;
    };
    template< class BaseField >
    class GetValueSafeField: public PeriodicUpdate< BaseField > {
    public:
      GetValueSafeField() {
        rt_value = PeriodicUpdate< BaseField >::value;
        value_for_haptic = PeriodicUpdate< BaseField >::value;
      }
 
      inline virtual const typename BaseField::value_type &getValue( int _id = 0 ) {
        if( H3DUtil::HapticThread::inHapticThread() ) {
          // if in haptic thread only get the rt_value and return
          value_lock.readLock();
          value_for_haptic = rt_value;
          value_lock.unlock();
          return value_for_haptic;
        } else {
          assert( H3DUtil::ThreadBase::inMainThread() );
          return PeriodicUpdate< BaseField >::getValue( _id );
        }
      }
      inline virtual void update() {
        assert( H3DUtil::ThreadBase::inMainThread() ); // terminate if update in non-main thread
        PeriodicUpdate< BaseField >::update();
        value_lock.writeLock();
        rt_value = this->value;
        value_lock.unlock();
      }
      virtual void upToDate() {
        assert( H3DUtil::ThreadBase::inMainThread() );
        PeriodicUpdate< BaseField >::upToDate();
      }
      inline virtual void setValue( const typename BaseField::value_type &v,
                                    int _id = 0 ) {
          assert( H3DUtil::ThreadBase::inMainThread() );
          PeriodicUpdate< BaseField >::setValue( v, _id );
          value_lock.writeLock();
          rt_value = this->value;
          value_lock.unlock();
      }
    protected:
      // value used to exchange value between haptic and main thread 
      typename BaseField::value_type rt_value;
      typename BaseField::value_type value_for_haptic;
      H3DUtil::ReadWriteLock value_lock;
    };
 
    H3DFakeHapticsDevice( Inst< SFVec3f         > _devicePosition = 0,
        Inst< SFRotation      > _deviceOrientation      = 0,
        Inst< TrackerPosition > _trackerPosition        = 0,
        Inst< TrackerOrientation > _trackerOrientation  = 0,
        Inst< SFMatrix4f      > _positionCalibration    = 0,
        Inst< SFRotation      > _orientationCalibration = 0,
        Inst< SFVec3f         > _proxyPosition          = 0,
        Inst< WeightedProxy   > _weightedProxyPosition  = 0,
        Inst< SFFloat         > _proxyWeighting         = 0,
        Inst< SFBool          > _mainButton             = 0,
        Inst< SFBool          > _secondaryButton        = 0,
        Inst< SFInt32         > _buttons                = 0,
        Inst< SFVec3f         > _force                  = 0,
        Inst< SFVec3f         > _torque                 = 0,
        Inst< SFInt32         > _inputDOF               = 0,
        Inst< SFInt32         > _outputDOF              = 0,
        Inst< SFInt32         > _hapticsRate            = 0,
        Inst< SFInt32         > _desiredHapticsRate     = 0,
        Inst< SFNode          > _stylus                 = 0,
        Inst< SFHapticsRendererNode > _hapticsRenderer  = 0,
        Inst< MFVec3f         > _proxyPositions         = 0,
        Inst< SFBool          > _followViewpoint        = 0,
        Inst< GetValueSafeField< SFVec3f > > _set_devicePosition     = 0,
        Inst< GetValueSafeField< SFRotation > > _set_deviceOrientation  = 0,
        Inst< GetValueSafeField< SFBool > > _set_mainButton       = 0,
        Inst< GetValueSafeField< SFBool > > _set_secondaryButton  = 0,
        Inst< GetValueSafeField< SFBool > > _set_pauseDeviceTransform = 0,
        Inst< SFFloat > _gripperAngle                             = 0,
        Inst< GetValueSafeField< SFFloat > > _set_gripperAngle    = 0,
        Inst< SFFloat > _gripperForce                             = 0 );
 
    ~H3DFakeHapticsDevice() {
      releaseDevice();
      hapi_device.reset( NULL );
    }
 
    static H3DNodeDatabase database;
 
    H3DUniquePtr< GetValueSafeField<SFVec3f> > set_devicePosition;
 
    H3DUniquePtr< GetValueSafeField<SFRotation> > set_deviceOrientation;
 
    H3DUniquePtr< GetValueSafeField<SFBool> > set_mainButton;
 
    H3DUniquePtr< GetValueSafeField<SFBool> > set_secondaryButton;
 
    H3DUniquePtr< GetValueSafeField<SFBool> > set_pauseDeviceTransform;
 
    bool pauseDeviceTransform;
 
    HAPI::HAPIHapticsDevice::DeviceValues pauseDeviceTransformDV;
  public:
    virtual void initialize() {
      // This makes it easier to subclass FakeHapticsDevice, or H3DFakeHapticsDevice and use a subclass
      // H3DFakeHapticsDevice::FakeHapticsDevice internally.
      dynamic_cast< H3DFakeHapticsDevice::FakeHapticsDevice * >(hapi_device.get())->owner = this;
    }
 
    H3DUniquePtr< SFFloat > gripperAngle;
 
    H3DUniquePtr< GetValueSafeField<SFFloat> > set_gripperAngle;
 
    H3DUniquePtr< SFFloat > gripperForce;
 
    virtual void updateDeviceValues();
  };
}
 
#endif