AnimaL

Tutorial

Documentation

---

Documentation

• Overview
• Modules
• Namespace List
• Class Hierarchy
• Alphabetical List
• Compound List
• File List
• Namespace Members
• Compound Members
• File Members
• Examples

---

massSpringNode.cpp

Go to the documentation of this file.

#include "massSpringNode.h"
#include <X3DTK/private/X3D_Coordinate.h>
#include <animal/engine/massSpringEngine.inl>
#include <animal/value.h>
#include <animal/X3DTK/linearX3DTK.h>
#include <animal/engine/AnimalEngineNode.cpp>  //template class


namespace X3DTK
{
  template class animal::MassSpringSolver< X3DTK::MFVec3f, //Points
  X3DTK::MFVec3f, //Velocities
  X3DTK::MFFloat, //Masses
  X3DTK::MFFloat, //SpringStiffness
  X3DTK::MFInt32 //IndexedSprings
  >;
  template class animal::MassSpringEngine< X3DTK::MFFloat, //Masses
  X3DTK::MFVec3f, //Velocities
  X3DTK::MFFloat, //SpringStiffness
  X3DTK::MFInt32, //IndexedSprings
  X3DTK::MFVec3f, //Points
  float>;

  namespace X3D
  {

    template class AnimalEngineNode< AMassSpringEngine >;


    MassSpringNode::MassSpringNode()
        : _coordinate(0)
        /*, _integrationMethod(5)*/
    {

      // Defines the tag of the node. This string must be the same than the one
      // entered for the creation function, otherwise the node won't be loaded.
      // Node
      define(Recorder<MassSpringNode>::getTypeName("MassSpringNode"));

      // Attributes
      define(Recorder<MassSpringNode, MFFloat>::getAttribute("invMasses", &MassSpringNode::_invMassesX3D, MFFloat()));
      define(Recorder<MassSpringNode, MFVec3f>::getAttribute("velocities", &MassSpringNode::_velocitiesX3D, MFVec3f()));
      define(Recorder<MassSpringNode, MFFloat>::getAttribute("stiffnesses", &MassSpringNode::_stiffnessesX3D, MFFloat()));
      define(Recorder<MassSpringNode, MFFloat>::getAttribute("restLengths", &MassSpringNode::_restLengthsX3D, MFFloat()));
      define(Recorder<MassSpringNode, MFInt32>::getAttribute("links", &MassSpringNode::_linksX3D, MFInt32()));
      define(Recorder<MassSpringNode, SFInt32>::getAttribute("integrationMethod", &MassSpringNode::_method, 0));
      define(Recorder<MassSpringNode, SFFloat>::getAttribute("dampingRatio", &MassSpringNode::_dampingRatio, 0.1));
      define(Recorder<MassSpringNode, SFFloat>::getAttribute("exponentialDamping", &MassSpringNode::_exponentialDamping, 0.0));
      define(Recorder<MassSpringNode, SFVec3f>::getAttribute("gravity", &MassSpringNode::_gravity, SFVec3f(0.0, 0.0, 0.0)));

      // Children
      define(Recorder<MassSpringNode, Coordinate>::getSFNode("Coordinate", &MassSpringNode::_coordinate));

      //       // Defines the tag of the node. This string must be the same than the one
      //       // entered for the creation function, otherwise the node won't be loaded.
      //       defineTypeName("MassSpringNode");
      /*  _exponentialDamping = 0;
        _dampingRatio = 0.1;
        _gravity.x = 0;
        _gravity.y = 0;
        _gravity.z = 0;*/
    }

    MassSpringNode::~MassSpringNode()
    {
      removeParentFromChild(this, _coordinate);
    }

    void MassSpringNode::init()
    {
      _invMasses = &_invMassesX3D;
      _velocities = &_velocitiesX3D;
      _stiffnesses = &_stiffnessesX3D;
      _restLengths = &_restLengthsX3D;
      _links = &_linksX3D;

      if (_exponentialDamping != 0.0)  _useExponentialDamping = true;
      if (_gravity != SFVec3f(0.0, 0.0, 0.0)) _useGravity=true;

      // get the coordinate
      X3D::Coordinate * coord = dynamic_cast < X3D::Coordinate * >(_coordinate);

      if (!coord)
      {
        std::cerr<< "Warning: impossible to init a mass-spring engine: Coordinate node not found"<< std::endl;
        return;
      }

      // Get the points
      const MFVec3f * pointsTmp = &(coord->getPoint());
      MFVec3f * points = const_cast<MFVec3f *>(pointsTmp);

      bool fieldsOK=true;
      if( !points )
      {
        std::cerr<< "MassSpringNode::initEngine : could not read coordinate values" << std::endl;
        fieldsOK=false;
      }
      if( !_velocities )
      {
        std::cerr<< "MassSpringNode::initEngine : could not read velocit values" << std::endl;
        fieldsOK=false;
      }
      if( !_stiffnesses )
      {
        std::cerr<< "MassSpringNode::initEngine : could not read stiffness values" << std::endl;
        fieldsOK=false;
      }
      if( !_restLengths )
      {
        std::cerr<< "MassSpringNode::initEngine : could not read rest length values" << std::endl;
        fieldsOK=false;
      }
      if( !_invMasses )
      {
        std::cerr<< "MassSpringNode::initEngine : could not read mass values" << std::endl;
        fieldsOK=false;
      }
      else set_useMass(true);
      if( !_links )
      {
        std::cerr<< "MassSpringNode::initEngine : could not read spring indices" << std::endl;
        fieldsOK=false;
      }
      if( !fieldsOK ) return;

      if( _invMasses->size() != points->size() )
      {
        std::cerr<< "Warning: impossible to init a mass-spring engine. In the file .x3d, the masses size is different of the points size."<< std::endl;
        return;
      }

      if( _velocities->size() != points->size() )
      {
        std::cerr<< "Warning: impossible to init a mass-spring engine. In the file .x3d, the velocities size is different of the points size."<< std::endl;
        return;
      }

      if(_links->size() != 2*_stiffnesses->size())
      {
        std::cerr<< "Warning: impossible to init a mass-spring engine. In the file .x3d, the indexedSprings size is different of the double of the springStiffness size."<< std::endl;
        return;
      }

      if(_restLengths->size() != _stiffnesses->size())
      {
        std::cerr<< "Warning: impossible to init a mass-spring engine. In the file .x3d, the restLengths size is different of the springStiffness size."<< std::endl;
        return;
      }

      // init some attributes
      _points = points;
      animal::resize(_initialPoints, animal::size(*_points));
      animal::v_eq(_initialPoints, *_points);
      animal::resize(_initialVelocities, animal::size(*_velocities));
      animal::v_eq(_initialVelocities, *_velocities);

      // Init the engine
      animal::Engine::init();

    }

    void MassSpringNode::close()
    {
      _invMassesX3D = *_invMasses;
      _velocitiesX3D = *_velocities;
      _stiffnessesX3D = *_stiffnesses;
      _restLengthsX3D = *_restLengths;
      _linksX3D = *_links;
    }

    //     void MassSpringNode::getBoundingBox( float & minX, float & minY, float & minZ,
    //                                 float & maxX, float & maxY, float & maxZ)
    // {
    //     AMassSpringEngine::getBoundingBox(minX, minY, minZ, maxX, maxY, maxZ);
    //     setBBoxCenter(SFVec3f((minX+maxX)/2.0, (minY+maxY)/2.0, (minZ+maxZ)/2.0));
    //     setBBoxSize(SFVec3f(-minX+maxX, -minY+maxY, -minZ+maxZ));
    //
    // }

  }
}


void X3DTK::X3D::MassSpringNode::declareOutputs( X3D_X3DNodeList& list )
{
  list.push_back(_coordinate);
}




X3DTK::MFVec3f* X3DTK::X3D::MassSpringNode::getCoords()
{
  return _points;
}


X3DTK::MFVec3f* X3DTK::X3D::MassSpringNode::getVelocities()
{
  return _velocities;
}


X3DTK::MFFloat* X3DTK::X3D::MassSpringNode::getInvMasses()
{
  return _invMasses;
}

---