Node.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 __NODE_H__
#define __NODE_H__
 
#include <H3D/Instantiate.h>
#include <H3D/H3DNodeDatabase.h>
#include <H3D/TraverseInfo.h>
#include <H3DUtil/RefCountedClass.h>
#include <H3DUtil/Console.h>
 
namespace H3D {
  class X3DPrototypeInstance;
 
  class H3DAPI_API Node: public RefCountedClass {
  public:
 
    typedef HAPI::Collision::IntersectionInfo IntersectionInfo;
 
    typedef std::map < Node*, Node* > DeepCopyMap;
 
    Node();
 
    virtual Node* clone ( bool deepCopy= true, DeepCopyMap *deepCopyMap = NULL );
    
    virtual ~Node();
 
    template< class N >
    static Node *newInstance() { return new N; }
 
    inline X3DPrototypeInstance *getProtoInstanceParent() {
      return proto_parent;
    }
 
    inline void setProtoInstanceParent( X3DPrototypeInstance *p) {
      proto_parent = p;
    }
    
    virtual void render()     { };
 
    virtual void traverseSG( TraverseInfo &ti );
 
    struct H3DAPI_API NodeIntersectResult {
      // Constructor.
      NodeIntersectResult( void * _user_data = 0,
                           bool _override_no_collision = false,
                           bool _collide_invisible = false ) :
        user_data( _user_data ),
        override_no_collision( _override_no_collision ),
        collide_invisible( _collide_invisible ) {
        current_matrix.push( Matrix4f() );
      }
 
      vector< Node * > theNodes;
 
      vector< IntersectionInfo > result;
 
      void * user_data;
 
      bool override_no_collision;
 
      bool collide_invisible;
 
      inline void addTransform() {
        geometry_transforms.push_back( getCurrentTransform() );
      }
 
      inline const vector< Matrix4f > &getGeometryTransforms() {
        return geometry_transforms;
      }
 
      inline const Matrix4f &getCurrentTransform() {
        return current_matrix.top();
      }
 
      inline void pushTransform( const Matrix4f &matrix ) {
        current_matrix.push( current_matrix.top() * matrix );
      }
 
      inline void popTransform() {
        current_matrix.pop();
      }
 
      inline void transformResult() {
        for( unsigned int i = 0; i < result.size(); ++i ) {
          result[i].point = geometry_transforms[i] * result[i].point;
          result[i].normal = geometry_transforms[i].getRotationPart() *
                             result[i].normal;
        }
      }
 
      inline void addResults( IntersectionInfo &temp_result,
                              Node * the_node,
                              bool add_transform = true ) {
        result.push_back( temp_result );
        theNodes.push_back( the_node );
        if( add_transform )
          addTransform();
      }
 
      virtual void clearData() {
        theNodes.clear();
        result.clear();
        geometry_transforms.clear();
        while( !current_matrix.empty() )
          current_matrix.pop();
        current_matrix.push( Matrix4f() );
      }
 
    protected:
      vector< Matrix4f > geometry_transforms;
 
      stack< Matrix4f > current_matrix;
 
    };
 
    struct H3DAPI_API LineIntersectResult : public NodeIntersectResult {
 
      LineIntersectResult( bool _override_no_collision = false,
                           bool _detect_pt_device = false,
                           void *_user_data = 0,
                           bool _collide_invisible = false ) :
        NodeIntersectResult( _user_data, _override_no_collision,
                             _collide_invisible ),
        detect_pt_device( _detect_pt_device ) {}
 
      bool detect_pt_device;
 
      struct H3DAPI_API PointingDeviceResultStruct {
        list< Node * > x3dptd;
        list< Node * > lowest_enabled;
        Matrix4f global_to_local;
      };
 
      inline void pushCurrentPtDevice( PointingDeviceResultStruct &tmp ) {
        PointingDeviceResultStruct temp_struct;
        if( !current_pt_device.empty() )
          temp_struct = current_pt_device.top();
        current_pt_device.push( tmp );
        list< Node * > &tmp_list = current_pt_device.top().x3dptd;
        for( list< Node * >::iterator i = tmp_list.begin();
          i != tmp_list.end(); ++i ) {
          current_pt_device.top().lowest_enabled.push_back( *i );
        }
        tmp_list.insert( tmp_list.end(),
                         temp_struct.x3dptd.begin(),
                         temp_struct.x3dptd.end() );
      }
 
      inline void popCurrentPtDevice() {
        current_pt_device.pop();
      }
 
      inline void addPtDevMap() {
        if( detect_pt_device && !current_pt_device.empty() ) {
          geom_ptd_map[ (unsigned int) result.size() - 1 ] = current_pt_device.top();
        }
      }
 
      typedef map< unsigned int,
                   PointingDeviceResultStruct > GeomX3DPtdMap;
 
      GeomX3DPtdMap geom_ptd_map;
 
      virtual void clearData() {
        NodeIntersectResult::clearData();
        while( !current_pt_device.empty() )
          current_pt_device.pop();
      }
 
      bool hasCurrentPointingDevice() {
        return !current_pt_device.empty();
      }
 
    protected:
      stack< PointingDeviceResultStruct > current_pt_device;
    };
 
    virtual bool lineIntersect( const Vec3f &from,
                                const Vec3f &to,
                                LineIntersectResult &result );
 
    virtual void closestPoint( const Vec3f &p,
                               NodeIntersectResult &result );
 
    virtual bool movingSphereIntersect( H3DFloat radius,
                                        const Vec3f &from,
                                        const Vec3f &to,
                                        NodeIntersectResult &result );
 
    virtual string defaultXMLContainerField() {
      return "children";
    }
    
    virtual Field *getField( const string &_name ) const;
    
    int addDestructCallback( void (*func)( Node *, void * ), void *args );
 
    int removeDestructCallback( void (*func)( Node *, void * ), void *args );
 
    static int getClosestPointIndex( NodeIntersectResult* result, Vec3f& point ){
     H3DDouble dist = 10000.0;
     unsigned int index = 0;
     for( unsigned int i = 0; i < result->result.size(); ++i ) {
        H3DDouble d = (result->result[i].point - point).length();
        if( d < dist ){
          dist = d;
          index = i;          
        }          
      }
      return index;
    };
 
 
    friend class Field;
    template <class Type>
    friend class SField;
    template <class Type>
    friend class MField;
    template<class RefClass, class BaseField>
    friend class RefCountSField;
 
    inline static unsigned int nrNodesAlive() {
      return nr_nodes_alive;
    }
 
    inline static int nrNodesCreated() {
      return nr_nodes_created;
    }
 
  protected:
 
    static Node* getClonedInstance ( Node* original, bool deepCopy, DeepCopyMap& deepCopyMap );
 
    void cloneFieldValue ( Field& _from, Field& _to, bool deepCopy, DeepCopyMap& deepCopyMap );
 
    static H3DNodeDatabase database;
    int id;
    static int nr_nodes_created;
    typedef  vector< pair< void (*)(Node *, void *), void * > > DestructCallbacks;
    DestructCallbacks destruct_callbacks;
    X3DPrototypeInstance *proto_parent;
    
    // the number of nodes which have been constructed but not destructed yet.
    static unsigned int nr_nodes_alive;
 
  };
 
}
 
#endif