AnimaL

Tutorial

Documentation

---

Documentation

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

---

massSpringEngine.inl

Go to the documentation of this file.

#ifndef MASS_SPRING_ENGINE_INL
#define MASS_SPRING_ENGINE_INL

#include "massSpringEngine.h"
#include <animal/linear.h>
#include <animal/massspringsolver.inl>
#include <animal/container_traits.h>
#include <animal/picking.h>
#include <animal/value.h>

#include <iostream>
#include <vector>
using std::cerr;
using std::endl;

namespace animal
{

template< class Inv_Masses,
class Velocities,
class SpringStiffness,
class IndexedSprings,
class Points,
class Real >
MassSpringEngine< Inv_Masses, Velocities, SpringStiffness, IndexedSprings, Points, Real >
::MassSpringEngine()
        : _velocities(0)
        , _points(0)
        , _pointSize(8)
        , _lineWidth(4)
{
    compressed_ok = false;
    elongated_ok = false;
    displayMassSpring = true;
}

template< class Inv_Masses,
class Velocities,
class SpringStiffness,
class IndexedSprings,
class Points,
class Real >
MassSpringEngine< Inv_Masses, Velocities, SpringStiffness, IndexedSprings, Points, Real >
::~MassSpringEngine()
{}

//===============================================================
// Virtual methods
//===============================================================

template< class Inv_Masses,
class Velocities,
class SpringStiffness,
class IndexedSprings,
class Points,
class Real >
void MassSpringEngine< Inv_Masses, Velocities, SpringStiffness, IndexedSprings, Points, Real >
::reset()
{

    if (_points && _velocities)
    {
        v_eq(*_points, _initialPoints);
        v_eq(*_velocities, _initialVelocities);
        resize(elongation,size(*_stiffnesses));
        resize(colours,size(*_stiffnesses));
        for(unsigned i=0;i<size(*_links);i+=2)
        {
            elongation[i/2]=v_norm((*_points)[(*_links)[i]]-(*_points)[(*_links)[i+1]]) - (*get_rest_lengths())[i/2]; // elongation[i] = norme du vecteur correspondant au ressort i - sa longueur au repos
            colours[i/2].r=0.0;
            colours[i/2].g=0.0;
            colours[i/2].b=0.0;
        }
    }
}

template< class Inv_Masses,
class Velocities,
class SpringStiffness,
class IndexedSprings,
class Points,
class Real >
void MassSpringEngine< Inv_Masses, Velocities, SpringStiffness, IndexedSprings, Points, Real >
::draw()
{
    if (get_displayMassSpring())
    {
        //cerr<<"MassSpringEngine::draw()"<<endl;
        glPushAttrib(GL_LIGHTING_BIT | GL_POINT_BIT| GL_LINE_BIT);
        glDisable(GL_LIGHTING);
        glLineWidth(_lineWidth);
        if( _links )
        {
            glBegin(GL_LINES);
            unsigned i=0;
            /*int*/
            Index p1=0;
            /*int*/
            Index p2=0;
            float elong;
            //for(unsigned k=0;k<size(*_links);k++) cerr<<l[k]<<endl;;
            /* on parcourt les ressorts */
            while(i<size(*_links)-1)
            {
                float r,g,b;
                p1=(*_links)[i];
                p2=(*_links)[i+1];
                elong = v_norm((*_points)[p1]-(*_points)[p2]) - (*get_rest_lengths())[i/2]; // elong = norme du vecteur correspondant au ressort - sa longueur au repos

                //compressed
                if(elongation[i/2]>elong && compressed_ok)
                {
                    r=0.0;
                    g=1.0;
                    b=0.0;    // r,g,b are used to indicate the colour of the springs
                    glColor3f(r,g,b);
                    elongation[i/2]=elong;
                    colours[i/2].r=r;
                    colours[i/2].g=g;
                    colours[i/2].b=b;
                }
                //elongated
                else if(elongation[i/2]<elong && elongated_ok)
                {
                    r=1.0;
                    g=0.0;
                    b=1.0;
                    glColor3f(r,g,b);
                    elongation[i/2]=elong;
                    colours[i/2].r=r;
                    colours[i/2].g=g;
                    colours[i/2].b=b;
                }
                // no mass_spring display
                else
                {
                    glColor3f(0,0,0);
                    elongation[i/2]=elong;
                }
                glVertex3f((*_points)[p1].x,(*_points)[p1].y,(*_points)[p1].z);
                glVertex3f((*_points)[p2].x,(*_points)[p2].y,(*_points)[p2].z);
                i=i+2;
            }
            glEnd();
        }

        // Particles
        glDisable(GL_POINT_SMOOTH);
        glPointSize(_pointSize);
        glBegin(GL_POINTS);
        glColor3f(1,1,1);
        for( unsigned int i=0; i<size(*_points); ++i )
        {
            glVertex3f((*_points)[i].x,(*_points)[i].y,(*_points)[i].z);
        }
        glEnd();
        glPopAttrib();
    }
}

template< class Inv_Masses,
class Velocities,
class SpringStiffness,
class IndexedSprings,
class Points,
class Real >
void MassSpringEngine< Inv_Masses, Velocities, SpringStiffness, IndexedSprings, Points, Real >
::move(double dt)
{
    Velocities force;
    resize(force, size(*_velocities));
    if (_points && _velocities)
    {
        this->_MassSpringSolver::solveODE( *_points, *_velocities, dt );
        //std::cout<<"MassSpringEngine::move particles to " << v_output(*_points) << std::endl;
        if (get_displayMassSpring())
            this->_MassSpringSolver::computeForces(force,*_points,*_velocities);

    }
}

template< class Inv_Masses,
class Velocities,
class SpringStiffness,
class IndexedSprings,
class Points,
class Real >
void MassSpringEngine< Inv_Masses, Velocities, SpringStiffness, IndexedSprings, Points, Real >
::getBoundingBox(float &minX, float &minY, float &minZ, float &maxX, float &maxY, float &maxZ)
{
    if(_points->size()==0 )
    {
        cerr<<"MassSpringEngine::getBoundingBox can not find bounding box because there are no particles" << endl;
        return;
    }
    minX=maxX=(*_points)[0].x;
    minY=maxY=(*_points)[1].y;
    minZ=maxZ=(*_points)[2].z;
    for( unsigned i=1; i<_points->size(); ++i )
    {
        if( (*_points)[i].x<minX )
            minX=(*_points)[i].x;
        if( (*_points)[i].x>maxX )
            maxX=(*_points)[i].x;
        if( (*_points)[i].y<minY )
            minY=(*_points)[i].y;
        if( (*_points)[i].y>maxY )
            maxY=(*_points)[i].y;
        if( (*_points)[i].z<minZ )
            minZ=(*_points)[i].z;
        if( (*_points)[i].z>maxZ )
            maxZ=(*_points)[i].z;
    }
    //cout<<"MassSpringEngine::getBoundingBox = "<< minX <<", "<< minY <<", "<<minZ<<", "<<maxX<<", "<<maxY<<", "<<maxZ<<endl;;
}

template< class Inv_Masses,
class Velocities,
class SpringStiffness,
class IndexedSprings,
class Points,
class Real >
void MassSpringEngine< Inv_Masses, Velocities, SpringStiffness, IndexedSprings, Points, Real >
::mousePressEvent( MouseEvent* )
{
    //cerr<<"MassSpringEngine::mousePressEvent"<<endl;
}


// ----------  FF: picking -----------------------------
template< class Inv_Masses,
class Velocities,
class SpringStiffness,
class IndexedSprings,
class Points,
class Real >
MassSpringEngine< Inv_Masses, Velocities, SpringStiffness, IndexedSprings, Points, Real >
::ConstrainedPoint::ConstrainedPoint( MassSpringEngine* mse, int index )
        : _mse(mse)
        , _index(index)
        , invmass( (*mse->_invMasses)[index] )
{
    //std::cout<<"ConstrainedPoint::ConstrainedPoint"<<endl;
}

template< class Inv_Masses,
class Velocities,
class SpringStiffness,
class IndexedSprings,
class Points,
class Real >
void MassSpringEngine< Inv_Masses, Velocities, SpringStiffness, IndexedSprings, Points, Real >
::ConstrainedPoint::getPoint( float& x, float& y, float& z ) const
{
    x= (*_mse->_points)[_index].x;
    y= (*_mse->_points)[_index].y;
    z= (*_mse->_points)[_index].z;
}

template< class Inv_Masses,
class Velocities,
class SpringStiffness,
class IndexedSprings,
class Points,
class Real >
void MassSpringEngine< Inv_Masses, Velocities, SpringStiffness, IndexedSprings, Points, Real >
::ConstrainedPoint::moveTo( float x, float y, float z ) const
{
    (*_mse->_points)[_index].x = x;
    (*_mse->_points)[_index].y = y;
    (*_mse->_points)[_index].z = z;
    (*_mse->_invMasses)[_index] = 0.0;
    typedef typename container_traits<Velocities>::value_type Velocity;
    (*_mse->_velocities)[_index] = Value<Velocity>::zero() ;

    //std::cout<<"ConstrainedPoint::moveTo " << (*_p)[_index] << std::endl;
}

template< class Inv_Masses,
class Velocities,
class SpringStiffness,
class IndexedSprings,
class Points,
class Real >
void MassSpringEngine< Inv_Masses, Velocities, SpringStiffness, IndexedSprings, Points, Real >
::ConstrainedPoint::print() const
{
    //std::cout<<"ConstrainedPoint: "<<(*_mse->_points)[_index].x <<", "<< (*_mse->_points)[_index].y <<", "<< (*_mse->_points)[_index].z << std::endl;;
}

template< class Inv_Masses,
class Velocities,
class SpringStiffness,
class IndexedSprings,
class Points,
class Real >
MassSpringEngine< Inv_Masses, Velocities, SpringStiffness, IndexedSprings, Points, Real >
::ConstrainedPoint::~ConstrainedPoint()
{
    (*_mse->_invMasses)[_index] = invmass;
}

template< class Inv_Masses,
class Velocities,
class SpringStiffness,
class IndexedSprings,
class Points,
class Real >
bool MassSpringEngine< Inv_Masses, Velocities, SpringStiffness, IndexedSprings, Points, Real >
::ConstrainedPoint::operator == ( const ConstrainedItem* it ) const
{
    const ConstrainedPoint* ptr_item = dynamic_cast<const ConstrainedPoint*>(it);
    if( ptr_item )
    {
        if(ptr_item->_mse == this->_mse)
        {
            //std::cout<<"ConstrainedPoint::operator ==, same engine, indices == "<<this->_index<<", "<<ptr_item->_index<< std::endl;
        }
        return (ptr_item->_mse == this->_mse) && (ptr_item->_index == this->_index);
    }
    else
        return false;

}

template< class Inv_Masses,
class Velocities,
class SpringStiffness,
class IndexedSprings,
class Points,
class Real >
ConstrainedItem* MassSpringEngine< Inv_Masses, Velocities, SpringStiffness, IndexedSprings, Points, Real >
::pickPoint( float origin[3], float direction[3], float threshold )
{
    //std::cerr<<"MassSpringEngine::pickPoint"<<std::endl;
    int index;
    float distance;
    typedef typename container_traits<Points>::value_type Vect;
    Vect lineOrigin(origin[0], origin[1], origin[2]);
    Vect lineDirection(direction[0],direction[1],direction[2]);
    if( findClosestPointToLine( index, distance, *_points, lineOrigin, lineDirection, threshold ) )
        return new ConstrainedPoint(this,index);
    else
        return 0;
}
// ----------  end FF: picking -----------------------------


template< class Inv_Masses,
class Velocities,
class SpringStiffness,
class IndexedSprings,
class Points,
class Real >
bool MassSpringEngine< Inv_Masses, Velocities, SpringStiffness, IndexedSprings, Points, Real >
::get_compressed_ok()
{
    return compressed_ok;
}

template< class Inv_Masses,
class Velocities,
class SpringStiffness,
class IndexedSprings,
class Points,
class Real >
void MassSpringEngine< Inv_Masses, Velocities, SpringStiffness, IndexedSprings, Points, Real >
::set_compressed_ok(bool ok)
{
    compressed_ok = ok;
}

template< class Inv_Masses,
class Velocities,
class SpringStiffness,
class IndexedSprings,
class Points,
class Real >
bool MassSpringEngine< Inv_Masses, Velocities, SpringStiffness, IndexedSprings, Points, Real >
::get_elongated_ok()
{
    return elongated_ok;
}

template< class Inv_Masses,
class Velocities,
class SpringStiffness,
class IndexedSprings,
class Points,
class Real >
void MassSpringEngine< Inv_Masses, Velocities, SpringStiffness, IndexedSprings, Points, Real >
::set_elongated_ok(bool ok)
{
    elongated_ok = ok;
}

template< class Inv_Masses,
class Velocities,
class SpringStiffness,
class IndexedSprings,
class Points,
class Real >
bool MassSpringEngine< Inv_Masses, Velocities, SpringStiffness, IndexedSprings, Points, Real >
::get_displayMassSpring()
{
    return displayMassSpring;
}

template< class Inv_Masses,
class Velocities,
class SpringStiffness,
class IndexedSprings,
class Points,
class Real >
void MassSpringEngine< Inv_Masses, Velocities, SpringStiffness, IndexedSprings, Points, Real >
::set_displayMassSpring(bool display)
{
    displayMassSpring=display;
}


template< class Inv_Masses,
class Velocities,
class SpringStiffness,
class IndexedSprings,
class Points,
class Real >
int MassSpringEngine< Inv_Masses, Velocities, SpringStiffness, IndexedSprings, Points, Real >
::get_pointSize() const
{
    return _pointSize;
}

template< class Inv_Masses,
class Velocities,
class SpringStiffness,
class IndexedSprings,
class Points,
class Real >
void MassSpringEngine< Inv_Masses, Velocities, SpringStiffness, IndexedSprings, Points, Real >
::set_pointSize(int s)
{
    _pointSize=s;
}

template< class Inv_Masses,
class Velocities,
class SpringStiffness,
class IndexedSprings,
class Points,
class Real >
int MassSpringEngine< Inv_Masses, Velocities, SpringStiffness, IndexedSprings, Points, Real >
::get_lineWidth() const
{
    return _lineWidth;
}

template< class Inv_Masses,
class Velocities,
class SpringStiffness,
class IndexedSprings,
class Points,
class Real >
void MassSpringEngine< Inv_Masses, Velocities, SpringStiffness, IndexedSprings, Points, Real >
::set_lineWidth(int s)
{
    _lineWidth=s;
}


//===============================================================

//template< class Inv_Masses,
//          class Velocities,
//          class SpringStiffness,
//          class IndexedSprings,
//          class Points,
//          class Real >
//void MassSpringEngine< Inv_Masses, Velocities, SpringStiffness, IndexedSprings, Points, Real >
//::connect( Inv_Masses * invMasses,
//           Velocities * velocities,
//           IndexedSprings * indexedSprings,
//           SpringStiffness * springStiffness,
//           SpringStiffness * restLengths,
//           Points * points)
//{
//  _invMasses    = invMasses;
//  _velocities   = velocities;
//  _links        = indexedSprings;
//  _stiffnesses  = springStiffness;
//  _restLengths  = restLengths;
//  _points       = points;
//
//  assert( this->_links );
//  assert( size(*_points)==size(*_velocities) );
//  assert( size(*_points)==size(*_invMasses) );
//  assert( size(*_links)/2==size(*_stiffnesses) );
//  assert( size(*_restLengths)==size(*_stiffnesses) );
//
//  // Initialize the initial points and velocities
//  if (_points)
//  {
//    resize(_initialPoints, size(*_points));
//    v_eq(_initialPoints, *_points);
//  }
//  if (_velocities)
//  {
//
//    resize(_initialVelocities, size(*_velocities));
//    v_eq(_initialVelocities, *_velocities);
//  }
//
//  resize(elongation,size(*_stiffnesses));
//  resize(colours,size(*_stiffnesses));
//    for(unsigned i=0;i<size(*_links);i+=2)
//    elongation[i/2]=v_norm((*_points)[(*_links)[i]]-(*_points)[(*_links)[i+1]]) - (*get_rest_lengths())[i/2]; // elongation[i] = norme du vecteur correspondant au ressort i - sa longueur au repos
//  //  cerr << "elongation tab size " << size(elongation) << endl;
//  //cerr << "colours tab size " << size(colours) << endl;
//
//}

}// animal

#endif //MASS_SPRING_ENGINE_INL

---