HumanHand.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 __HUMANHANDH3D_H__
#define __HUMANHANDH3D_H__
 
// H3D includes
#include <H3D/X3DGeometryNode.h>
#include <H3D/CyberGloveSensor.h>
#include <H3D/DependentNodeFields.h>
 
#ifdef HAVE_VIRTUAL_HAND_SDK
// Virtual Hand SDK includes
#include <vhandtk/vhtHumanHand.h>
#include <vhandtk/vhtOglDrawer.h>
#endif
 
namespace H3D {
 
  class H3DAPI_API HumanHand : public X3DGeometryNode {
  public:
 
    class SFCyberGloveSensor: public TypedSFNode< CyberGloveSensor > {
    protected:
      virtual void onAdd( Node *node ) {
        TypedSFNode< CyberGloveSensor >::onAdd( node );
        if( node ) {
          CyberGloveSensor * cgs = static_cast< CyberGloveSensor * >(node);
          HumanHand *hh = static_cast< HumanHand * >(owner);
          cgs->thumb->route( hh->displayList );
          cgs->index->route( hh->displayList );
          cgs->middle->route( hh->displayList );
          cgs->ring->route( hh->displayList );
          cgs->pinky->route( hh->displayList );
        }
      }
 
      virtual void onRemove( Node *node ) {
        if( node ) {
          CyberGloveSensor * cgs = static_cast< CyberGloveSensor * >(node);
          HumanHand *hh = static_cast< HumanHand * >(owner);
          cgs->thumb->unroute( hh->displayList );
          cgs->index->unroute( hh->displayList );
          cgs->middle->unroute( hh->displayList );
          cgs->ring->unroute( hh->displayList );
          cgs->pinky->unroute( hh->displayList );
        }
        TypedSFNode< CyberGloveSensor >::onRemove( node );
      }
    };
 
    class SFBound: public TypedField< X3DGeometryNode::SFBound,
                                      Types< SFCyberGloveSensor,
                                             SFFloat, SFVec3f > > {
    protected:
      virtual void update() {
        Vec3f b;
        if( static_cast< SFCyberGloveSensor * >( routes_in[0] )->getValue() ) {
          Vec3f scene_graph_scale =
            static_cast< SFVec3f * >(routes_in[2])->getValue();
          // The units of the virtual hand is centimeters, so a bounding box of
          // about 30 centimeters in every direction should enclose the hand.
          // The scale will scale down the hand to the correct size, by default
          // the scale is 0.01 in order to translate into meters.
          if( scene_graph_scale.length() > Constants::f_epsilon ) {
            H3DFloat scale_field =
              static_cast< SFFloat * >(routes_in[1])->getValue();
            b = Vec3f( 35, 35, 35 ) * scale_field;
            b.x *= 1/scene_graph_scale.x;
            b.y *= 1/scene_graph_scale.y;
            b.z *= 1/scene_graph_scale.z;
          }
        }
        BoxBound *bb = new BoxBound;
        bb->size->setValue( b );
        value = bb;
      }
    };
 
    HumanHand( Inst< SFNode             > _metadata        = 0,
               Inst< SFBound            > _bound           = 0,
               Inst< DisplayList        > _displayList     = 0,
               Inst< SFCyberGloveSensor > _cyberGlove      = 0,
               Inst< SFString           > _gloveHandedness = 0,
               Inst< SFFloat            > _scale           = 0 );
 
    ~HumanHand() {
      CyberGloveSensor * cyber_glove = cyberGlove->getValue();
      if( cyber_glove )
        cyber_glove->resetGlove();
#ifdef HAVE_VIRTUAL_HAND_SDK
      drawer.reset( 0 );
      if( hand.get() )
        hand->disconnect();
      hand.reset( 0 );
#endif
    }
 
    virtual void initialize();
 
    // render the hand.
    virtual void render();
 
    // updates the hand data.
    virtual void traverseSG( TraverseInfo &ti );
 
    virtual int nrTriangles() {
      return 2000;
    }
 
    virtual bool lineIntersect( const Vec3f &from,
                                const Vec3f &to,
                                LineIntersectResult &result ) { return false; }
 
    virtual void closestPoint( const Vec3f &p,
                               NodeIntersectResult &result ) {}
 
    virtual bool movingSphereIntersect( H3DFloat radius,
                                        const Vec3f &from, 
                                        const Vec3f &to,
                                        NodeIntersectResult &result )
    { return false; }
 
    H3DUniquePtr< SFCyberGloveSensor> cyberGlove;
 
    H3DUniquePtr< SFString> gloveHandedness;
 
    H3DUniquePtr< SFFloat > scale;
 
    static H3DNodeDatabase database;
 
  protected:
#ifdef HAVE_VIRTUAL_HAND_SDK
    // VHSDK classes
    H3DUniquePtr< vhtHumanHand > hand;
    H3DUniquePtr< vhtOglDrawer > drawer;
    vhtTransform3D * cameraXForm;
#endif
 
    H3DUniquePtr< SFVec3f > sceneGraphScaling;
  };
}
 
#endif