DeformableShape.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 __DEFORMABLESHAPE_H__
#define __DEFORMABLESHAPE_H__
 
#include <H3D/X3DShapeNode.h>
#include <H3D/Coordinate.h>
#include <H3D/X3DComposedGeometryNode.h>
#include <H3D/H3DCoordinateDeformerNode.h>
 
namespace H3D {
 
  class H3DAPI_API DeformableShape : public X3DShapeNode {
  public:
    typedef TypedSFNode< Coordinate > SFCoordinateNode;
    typedef TypedSFNode< H3DCoordinateDeformerNode > SFCoordinateDeformer;
    
    class SFGeometryNode: public X3DShapeNode::SFGeometryNode {
      public:
      ~SFGeometryNode() {
        value = NULL;
      }
 
      protected:
      virtual void onAdd( Node *n ) {
        X3DComposedGeometryNode *cg = 
          dynamic_cast< X3DComposedGeometryNode * >( n );
        if( !cg ) {
          stringstream s;
          s << "Expecting X3DComposedGeometryNode";
          throw InvalidNodeType( n->getTypeName(),
                                 s.str(),
                                 H3D_FULL_LOCATION );
        }
        
        X3DShapeNode::SFGeometryNode::onAdd( n );
        DeformableShape *dg = 
          static_cast< DeformableShape * >( getOwner() );
        if( n  ) {
          Coordinate *cg_coord = 
            dynamic_cast< Coordinate * >( cg->coord->getValue() ); 
          Coordinate *dg_orig_coord = dg->origCoord->getValue(); 
          Coordinate *dg_deformed_coord = dg->deformedCoord->getValue(); 
          Coordinate *dg_resting_coord = dg->restingCoord->getValue(); 
          if( cg_coord ) {
            if( dg_orig_coord ) {
              dg_orig_coord->point->setValue( cg_coord->point->getValue() ); 
            }
            if( dg_deformed_coord ) {
              dg_deformed_coord->point->setValue( cg_coord->point->getValue() ); 
            }
            if( dg_resting_coord ) {
              dg_resting_coord->point->setValue( cg_coord->point->getValue() ); 
            }
          }
        }
      }
    };
 
    DeformableShape( Inst< SFAppearanceNode > _appearance     = 0,
                     Inst< SFGeometryNode   > _geometry       = 0,
                     Inst< SFHapticGeometry > _hapticGeometry = 0,
                     Inst< SFNode           > _metadata       = 0,
                     Inst< SFBound          > _bound          = 0,
                     Inst< SFVec3f          > _bboxCenter     = 0,
                     Inst< SFVec3f          > _bboxSize       = 0,
                     Inst< SFCoordinateNode > _origCoord      = 0,
                     Inst< SFCoordinateNode > _restingCoord   = 0,
                     Inst< SFCoordinateNode > _deformedCoor   = 0,
                     Inst< SFCoordinateDeformer > _deformer   = 0 );
 
    virtual void traverseSG( TraverseInfo &ti );
 
    H3DUniquePtr< SFCoordinateNode > origCoord;
 
    H3DUniquePtr< SFCoordinateNode > restingCoord;
 
    H3DUniquePtr< SFCoordinateNode > deformedCoord;   
 
    H3DUniquePtr< SFCoordinateDeformer > deformer;   
 
    static H3DNodeDatabase database;
 
  protected:
    TraverseInfo *last_ti;
    
  };
}
 
#endif