HapticsRenderers.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 __HAPTICSRENDERERS_H__
#define __HAPTICSRENDERERS_H__
 
// H3DApi includes
#include <H3D/H3DHapticsRendererNode.h>
#include <H3D/SFDouble.h>
#include <H3D/SFFloat.h>
#include <H3D/SFString.h>
#include <H3D/SFBool.h>
#include <H3D/FieldTemplates.h>
#include <H3D/MFNode.h>
 
// HAPI includes
#include <HAPI/RuspiniRenderer.h>
#include <HAPI/GodObjectRenderer.h>
 
namespace H3D {
 
  class H3DAPI_API OpenHapticsRenderer: public H3DHapticsRendererNode {
  public:
    class H3DAPI_API ShapeType: public OnValueChangeSField< SFString > {
    protected:
      virtual void onValueChange( const string &v );
    };
 
    class H3DAPI_API AdaptiveViewport: public OnValueChangeSField< SFBool > {
    protected:
      virtual void onValueChange( const bool &v );
    };
 
    
    class H3DAPI_API CameraView: public OnValueChangeSField< SFBool > {
    protected:
      virtual void onValueChange( const bool &v );
    };
 
    OpenHapticsRenderer( Inst< ShapeType     > _defaultShapeType = 0,
                         Inst< AdaptiveViewport >  _defaultAdaptiveViewport = 0,
                         Inst< CameraView  >  _defaultHapticCameraView = 0 ) :
      defaultShapeType( _defaultShapeType ),
      defaultAdaptiveViewport( _defaultAdaptiveViewport ),
      defaultHapticCameraView( _defaultHapticCameraView ) {
      type_name = "OpenHapticsRenderer";
      database.initFields( this );
 
#ifndef HAVE_OPENHAPTICS
      Console(LogLevel::Error) << "Cannot use OpenHapticsRenderer. HAPI compiled without"
     << " OpenHaptics support. Recompile HAPI with "
     << "HAVE_OPENHAPTICS defined"
     << " in order to use it." << endl;
#endif
 
      defaultShapeType->addValidValue( "FEEDBACK_BUFFER" );
      defaultShapeType->addValidValue( "DEPTH_BUFFER" );
      defaultShapeType->setValue( "FEEDBACK_BUFFER" );
      defaultAdaptiveViewport->setValue( true );
      defaultHapticCameraView->setValue( true );
    }
 
    H3DUniquePtr< SFString > defaultShapeType;
 
    H3DUniquePtr< SFBool > defaultAdaptiveViewport;
 
    H3DUniquePtr< SFBool > defaultHapticCameraView;
 
    static H3DNodeDatabase database;
  protected:
    virtual HAPI::HAPIHapticsRenderer *getNewHapticsRenderer();
  };
 
  class H3DAPI_API GodObjectRenderer: public H3DHapticsRendererNode {
  public:
 
    class H3DAPI_API MinDistance : public OnValueChangeSField< SFDouble > {
      virtual void onValueChange(const H3DDouble &v);
    };
 
    class H3DAPI_API EnableSecondaryCollisions : public OnValueChangeSField< SFBool > {
      virtual void onValueChange(const bool &v);
    };
 
    GodObjectRenderer( Inst< MinDistance > _minDistance = 0, 
                       Inst< EnableSecondaryCollisions > _enableSecondaryCollisions = 0);
 
    H3DUniquePtr< SFDouble > minDistance;
 
    H3DUniquePtr< SFBool > enableSecondaryCollisions;
 
    static H3DNodeDatabase database;
  protected:
    virtual HAPI::HAPIHapticsRenderer *getNewHapticsRenderer() {
      return new HAPI::GodObjectRenderer( minDistance->getValue(), enableSecondaryCollisions->getValue());
    }
  };
 
  class H3DAPI_API RuspiniRenderer: public H3DHapticsRendererNode {
  public:
    class H3DAPI_API ProxyRadius: public OnValueChangeSField< SFFloat > {
      virtual void onValueChange( const H3DFloat &v );
    };
 
    class H3DAPI_API AlwaysFollowSurface: public OnValueChangeSField< SFBool > {
      virtual void onValueChange( const bool &b );
    };
 
    RuspiniRenderer( Inst< ProxyRadius > _proxyRadius                 = 0,
                     Inst< AlwaysFollowSurface > _alwaysFollowSurface = 0 );
 
    H3DUniquePtr< SFFloat > proxyRadius;
 
    H3DUniquePtr< SFBool > alwaysFollowSurface;
 
    static H3DNodeDatabase database;
  protected:
    virtual HAPI::HAPIHapticsRenderer *getNewHapticsRenderer() {
      return new HAPI::RuspiniRenderer( proxyRadius->getValue(), alwaysFollowSurface->getValue() );
    }
  };
 
#ifdef HAVE_CHAI3D
  class H3DAPI_API Chai3DRenderer: public H3DHapticsRendererNode {
  public:
 
    Chai3DRenderer() {
      type_name = "Chai3DRenderer";
      database.initFields( this );
    }
 
    static H3DNodeDatabase database;
 
  protected:
    virtual HAPI::HAPIHapticsRenderer *getNewHapticsRenderer();
  };
#endif
 
  class H3DAPI_API LayeredRenderer: public H3DHapticsRendererNode {
  public:
 
    class H3DAPI_API MFHapticsRendererNode: 
      public TypedMFNode< H3DHapticsRendererNode > {
    protected:
      
      virtual void onAdd( Node *n );
 
      virtual void onRemove( Node *n );
    };
 
    LayeredRenderer( Inst< MFHapticsRendererNode > _hapticsRenderer = 0 );
 
    virtual HAPI::HAPIHapticsRenderer *
    getHapticsRenderer( unsigned int layer );
 
    virtual void hapticsRendererRemoved( unsigned int layer ) {
      hapticsRendererRemovedInternal( layer );
      if( layer < hapticsRenderer->size() )
        hapticsRenderer->getValueByIndex( layer )->
          hapticsRendererRemoved( 0 );
    }
 
    H3DUniquePtr< MFHapticsRendererNode > hapticsRenderer;
 
    static H3DNodeDatabase database;
  protected:
    virtual HAPI::HAPIHapticsRenderer *getNewHapticsRenderer() {
      return new HAPI::GodObjectRenderer;
    }
 
    void hapticsRendererRemovedInternal( unsigned int layer, bool erase = false ) {
      if( erase ) {
        if( layer < renderers.size() ) {
          vector< HAPI::HAPIHapticsRenderer * >::iterator i = renderers.begin();
          i += layer;
          renderers.erase( i );
        }
      } else
        H3DHapticsRendererNode::hapticsRendererRemoved( layer );
    }
  };
}
 
#endif