HAnimHumanoid.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 __HANIMHUMANOID_H__
#define __HANIMHUMANOID_H__
 
#include <H3D/X3DChildNode.h>
#include <H3D/X3DBoundedObject.h>
#include <H3D/X3DCoordinateNode.h>
#include <H3D/X3DNormalNode.h>
#include <H3D/DependentNodeFields.h>
#include <H3D/H3DDisplayListObject.h>
#include <H3D/Transform.h>
#include <H3D/SFRotation.h>
#include <H3D/MFString.h>
#include <H3D/HAnimJoint.h>
#include <H3D/HAnimSite.h>
 
namespace H3D {
 
  class H3DAPI_API HAnimHumanoid : 
    public X3DChildNode,
    public X3DBoundedObject,
    public H3DDisplayListObject {
  public:
 
    class MFJoint : public MFNode {
      virtual void onAdd( Node * );
      virtual void onRemove( Node * );
    };
 
    typedef MFNode MFSegment;
    typedef MFNode MFSite;
 
    class MFSkeletonNode: public MFNode {
      virtual void onAdd( Node * );
    };
 
    typedef MFNode MFChild;
      
    typedef DependentSFNode< X3DCoordinateNode,
                             FieldRef< X3DGeometricPropertyNode,
                                       Field,
                                       &X3DCoordinateNode::propertyChanged > > 
    SFCoordinateNode;
    
    typedef DependentSFNode< X3DNormalNode,
                             FieldRef< X3DGeometricPropertyNode,
                                       Field,
                                       &X3DNormalNode::propertyChanged > > 
    SFNormalNode;
    
    HAnimHumanoid( Inst< SFNode         > _metadata       = 0,
                   Inst< SFBound        > _bound          = 0,
                   Inst< SFVec3f        > _bboxCenter     = 0,
                   Inst< SFVec3f        > _bboxSize       = 0,
                   Inst< MFString       > _info           = 0,
                   Inst< SFString       > _name           = 0,
                   Inst< SFString       > _version        = 0,
                   Inst< MFChild        > _skin           = 0,
                   Inst< MFJoint        > _joints         = 0,
                   Inst< MFSegment      > _segments       = 0,
                   Inst< MFSite         > _sites          = 0,
                   Inst< MFSkeletonNode > _skeleton       = 0,
                   Inst< MFSite         > _viewpoints     = 0,
                   Inst< SFCoordinateNode > _skinCoord    = 0,
                   Inst< SFNormalNode     > _skinNormal   = 0,
                   Inst< SFVec3f        > _center         = 0,
                   Inst< SFRotation     > _rotation       = 0,
                   Inst< SFVec3f        > _scale          = 0,
                   Inst< SFRotation     > _scaleOrientation = 0,
                   Inst< SFVec3f        > _translation    = 0,
                   Inst< SFString       > _renderMode     = 0
                   );
 
    virtual void initialize();
 
    virtual void render();
 
    virtual void traverseSG( TraverseInfo &ti );
 
    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 );
  
    bool use_union_bound;
 
    H3DUniquePtr< MFString > info;
 
    H3DUniquePtr< SFString > name;
 
    H3DUniquePtr< SFString > version;
 
    H3DUniquePtr< MFChild > skin;
    
    H3DUniquePtr< MFJoint > joints;
 
    H3DUniquePtr< MFSegment > segments;
 
    H3DUniquePtr< MFSite > sites;
 
    H3DUniquePtr< MFSkeletonNode > skeleton; 
 
    H3DUniquePtr< MFSite > viewpoints;
 
    H3DUniquePtr< SFCoordinateNode > skinCoord;
 
    H3DUniquePtr< SFNormalNode > skinNormal;
 
    H3DUniquePtr< SFVec3f > center;
 
    H3DUniquePtr< SFRotation > rotation;
 
    H3DUniquePtr< SFVec3f > scale;
 
    H3DUniquePtr< SFRotation > scaleOrientation;
 
    H3DUniquePtr< SFVec3f > translation;
 
    H3DUniquePtr< SFString > renderMode;
    
    static H3DNodeDatabase database;
 
    protected:
    
      template< class VectorType >
      void updateCoordinates( const VectorType &orig_points,
                              const vector< Vec3f > &orig_normals,
                              VectorType &modified_points,
                              vector< Vec3f > &modified_normals );
 
      template< class VectorType >
      void updateCoordinatesLBS( const VectorType &orig_points,
                                 const vector< Vec3f > &orig_normals,
                                 VectorType &modified_points,
                                 vector< Vec3f > &modified_normals );
 
      template< class VectorType >
      void updateCoordinatesLBS2( const VectorType &orig_points,
                                  const vector< Vec3f > &orig_normals,
                                  VectorType &modified_points,
                                  vector< Vec3f > &modified_normals );
 
      template< class VectorType >
      void updateCoordinatesDLB( const VectorType &orig_points,
                                 const vector< Vec3f > &orig_normals,
                                 VectorType &modified_points,
                                 vector< Vec3f > &modified_normals );
 
      AutoRef< Transform > root_transform;
 
      vector< Vec3d > points_double;
 
      vector< Vec3f > points_single;
 
      vector< Vec3f > normals_single;
 
      AutoRef< X3DCoordinateNode > current_coordinate;
 
      AutoRef< X3DNormalNode > current_normal;
 
      H3DUniquePtr< Field > jointMatrixChanged;
  };
}
 
#endif