X3DGeometryNode.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 __X3DGEOMETRYNODE_H__
#define __X3DGEOMETRYNODE_H__

#include "X3DChildNode.h"
#include "H3DBoundedObject.h"
#include "H3DDisplayListObject.h"
#include "MFBool.h"
#include "MFVec3f.h"
#include "AutoPtrVector.h"
#include "H3DOptionNode.h"
#include "MFNode.h"
#ifdef HAVE_OPENHAPTICS
#include <HL/hl.h>
#endif

namespace H3D {

  class HLHapticsDevice;

  class H3DAPI_API X3DGeometryNode : 
    public X3DChildNode,
    public H3DBoundedObject,
    public H3DDisplayListObject {
  public:
    typedef TypedMFNode< H3DOptionNode > MFOptionsNode;

    class H3DAPI_API BugWorkaroundDisplayList: 
      public H3DDisplayListObject::DisplayList {
    };

    class H3DAPI_API DisplayList: public BugWorkaroundDisplayList {
    public:
      virtual void callList( bool build_list = true );
    };

    X3DGeometryNode( Inst< SFNode      >  _metadata = 0,
                     Inst< SFBound     > _bound = 0,
                     Inst< DisplayList > _displayList = 0,
                     Inst< MFBool      > _isTouched = 0,
                     Inst< MFVec3f     > _force = 0,
                     Inst< MFVec3f     > _contactPoint = 0,
                     Inst< MFVec3f     > _contactNormal = 0);

    virtual void hlRender( HLHapticsDevice *hd, Matrix4f &transform ) {
      displayList->callList( false );
    }

    inline void useBackFaceCulling( bool enabled ) {
      use_back_face_culling = enabled;
    }

    inline bool usingBackFaceCulling() {
      return use_back_face_culling;
    }

    inline void allowBackFaceCulling( bool allow ) {
      allow_back_face_culling = allow;
    }

    inline bool allowingBackFaceCulling() {
      return allow_back_face_culling;
    }

    template< class OptionNodeType >
    void getOptionNode( OptionNodeType * &option ) {
       for( MFOptionsNode::const_iterator i = options->begin();
           i != options->end(); i++ ) {
        OptionNodeType *options = dynamic_cast< OptionNodeType * >( *i );
        if( options ) {
          option = options;
          return;
        }
       }
      option = NULL;
    }

 #ifdef HAVE_OPENHAPTICS   
    virtual ~X3DGeometryNode();
 
    HLuint getHLShapeId( HLHapticsDevice *hd,
                         unsigned int index );

    HapticShape *getOpenGLHapticShape( H3DSurfaceNode *_surface,
                                       const Matrix4f &_transform,
                                       HLint _nr_vertices = -1 );
#endif
    virtual string defaultXMLContainerField() {
      return "geometry";
    }
   
    auto_ptr< MFBool >  isTouched;

    auto_ptr< MFVec3f >  force;

    auto_ptr< MFVec3f >  contactPoint;

    auto_ptr< MFVec3f >  contactNormal;

    auto_ptr< MFOptionsNode > options;

    static H3DNodeDatabase database;

  protected:

  #ifdef HAVE_OPENHAPTICS

    static void HLCALLBACK touchCallback( HLenum event,
                                          HLuint object,
                                          HLenum thread,
                                          HLcache *cache,
                                          void *userdata );

    static void HLCALLBACK untouchCallback( HLenum event,
                                            HLuint object,
                                            HLenum thread,
                                            HLcache *cache,
                                            void *userdata );

    static void HLCALLBACK motionCallback( HLenum event,
                                           HLuint object,
                                           HLenum thread,
                                           HLcache *cache,
                                           void *userdata );

    typedef map< HLHapticsDevice *, vector< HLuint > > ShapeIdMap;

    ShapeIdMap hl_shape_ids;

    struct CallbackData {
      CallbackData( X3DGeometryNode *g, int i ): geometry( g ), device_index( i ) {}
      X3DGeometryNode *geometry;
      int device_index;
    };
    
    AutoPtrVector< CallbackData > callback_data; 

    bool use_back_face_culling, allow_back_face_culling;

  #endif
  };
}

#endif

---