CollisionModel.h

Go to the documentation of this file.

/******************************************************************************
*       SOFA, Simulation Open-Framework Architecture, version 1.0 beta 3      *
*                (c) 2006-2008 MGH, INRIA, USTL, UJF, CNRS                    *
*                                                                             *
* This library is free software; you can redistribute it and/or modify it     *
* under the terms of the GNU Lesser General Public License as published by    *
* the Free Software Foundation; either version 2.1 of the License, or (at     *
* your option) any later version.                                             *
*                                                                             *
* This library 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 Lesser General Public License *
* for more details.                                                           *
*                                                                             *
* You should have received a copy of the GNU Lesser General Public License    *
* along with this library; if not, write to the Free Software Foundation,     *
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.          *
*******************************************************************************
*                              SOFA :: Framework                              *
*                                                                             *
* Authors: M. Adam, J. Allard, B. Andre, P-J. Bensoussan, S. Cotin, C. Duriez,*
* H. Delingette, F. Falipou, F. Faure, S. Fonteneau, L. Heigeas, C. Mendoza,  *
* M. Nesme, P. Neumann, J-P. de la Plata Alcade, F. Poyer and F. Roy          *
*                                                                             *
* Contact information: contact@sofa-framework.org                             *
******************************************************************************/
#ifndef SOFA_CORE_COLLISIONMODEL_H
#define SOFA_CORE_COLLISIONMODEL_H

#include <vector>
#include <sofa/core/objectmodel/BaseObject.h>
#include <sofa/core/CollisionElement.h>


namespace sofa
{

namespace core
{

class CollisionModel : public virtual objectmodel::BaseObject
{
public:

    typedef CollisionElementIterator Iterator;
    typedef componentmodel::topology::BaseMeshTopology Topology;

    CollisionModel()
    : bActive(initData(&bActive, true, "active", "flag indicating if this collision model is active and should be included in default collision detections"))
    , bMoving(initData(&bMoving, true, "moving", "flag indicating if this object is changing position between iterations"))
    , bSimulated(initData(&bSimulated, true, "simulated", "flag indicating if this object is controlled by a simulation"))
    , bSelfCollision(initData(&bSelfCollision, false, "selfCollision", "flag indication if the object can self collide"))
    , proximity(initData(&proximity, 0.0, "proximity", "Distance to the actual (visual) surface"))
    , contactStiffness(initData(&contactStiffness, 10.0, "contactStiffness", "Default contact stiffness"))
    , contactFriction(initData(&contactFriction, 0.01, "contactFriction", "Default contact friction (damping) coefficient"))
    , contactResponse(initData(&contactResponse, "contactResponse", "if set, indicate to the ContactManager that this model should use the given class of contacts.\nNote that this is only indicative, and in particular if both collision models specify a different class it is up to the manager to choose."))
    , group(initData(&group, 0, "group", "If not zero, ID of a group containing this model. No collision can occur between collision models of the same group (allowing the same object to have multiple collision models)"))
    , color(initData(&color, defaulttype::Vec4f(1,0,0,1), "color", "color used to display the collision model if requested"))
    , size(0), previous(NULL)  , next(NULL), numberOfContacts(0)
    {
    }

    virtual void bwdInit()
    {
      getColor4f(); //init the color to default value
    }
    virtual ~CollisionModel() { }    
    
    bool empty() const
    {
        return size==0;
    }

    int getSize() const
    {
        return size;
    }

    int getNumberOfContacts() const
    {
        return numberOfContacts;
    }

    void setNumberOfContacts(int i)
    {
        numberOfContacts = i;
    }

    virtual void resize(int s)
    {
        size = s;
    }

    Iterator begin()
    {
        return Iterator(this,0);
    }

    Iterator end()
    {
        return Iterator(this,size);
    }

    CollisionModel* getNext()
    {
        return next;
    }

    CollisionModel* getPrevious()
    {
        return previous;
    }

    void setNext(CollisionModel* val)
    {
        next = val;
    }

    void setPrevious(CollisionModel* val)
    {
        previous = val;
    }

    virtual bool isActive() const { return bActive.getValue() && getContext()->isActive(); }

    virtual void setActive(bool val=true) { bActive.setValue(val); }

    virtual bool isMoving() const { return bMoving.getValue(); }

    virtual void setMoving(bool val=true) { bMoving.setValue(val); }

    virtual bool isSimulated() const { return bSimulated.getValue(); }

    virtual void setSimulated(bool val=true) { bSimulated.setValue(val); }

    virtual void computeBoundingTree(int maxDepth=0) = 0;

    virtual void computeContinuousBoundingTree(double /*dt*/, int maxDepth=0) { computeBoundingTree(maxDepth); }

    virtual std::pair<CollisionElementIterator,CollisionElementIterator> getInternalChildren(int /*index*/) const
    {
        return std::make_pair(CollisionElementIterator(),CollisionElementIterator());
    }

    virtual std::pair<CollisionElementIterator,CollisionElementIterator> getExternalChildren(int /*index*/) const
    {
        return std::make_pair(CollisionElementIterator(),CollisionElementIterator());
    }


    virtual bool isLeaf( int /*index*/ ) const
    {
        return true;  //e.g. Triangle will return true 
    }


    virtual bool canCollideWith(CollisionModel* model)
    {
    if (model != this && this->group.getValue() != 0 && this->group.getValue() == model->group.getValue())
        return false;
        else if (model->getContext() != this->getContext())
            return true;
        else return bSelfCollision.getValue();
    }
    //virtual bool canCollideWith(CollisionModel* model) { return model != this; }

    virtual bool canCollideWithElement(int /*index*/, CollisionModel* /*model2*/, int /*index2*/) { return true; }

    
    virtual void draw(int /*index*/) {}
    
    virtual void draw() {}

    CollisionModel* getFirst()
    {
        CollisionModel *cm = this;
        CollisionModel *cm2;
        while ((cm2 = cm->getPrevious())!=NULL)
            cm = cm2;
        return cm;
    }

    CollisionModel* getLast()
    {
        CollisionModel *cm = this;
        CollisionModel *cm2;
        while ((cm2 = cm->getNext())!=NULL)
                cm = cm2;
        return cm;
    }


    template<class DerivedModel>
    DerivedModel* createPrevious()
    {
      DerivedModel* pmodel = dynamic_cast<DerivedModel*>(previous);
      if (pmodel == NULL)
      {
    if (previous != NULL)
      delete previous;
    pmodel = new DerivedModel();
    pmodel->setContext(getContext());
    pmodel->setMoving(isMoving());
    pmodel->setSimulated(isSimulated());
    pmodel->proximity.setValue(proximity.getValue());
    pmodel->group.setValue(group.getValue());
    previous = pmodel;
    pmodel->setNext(this);
      }
      return pmodel;
    }
    

    double getProximity() { return proximity.getValue(); }

    double getContactStiffness(int /*index*/) { return contactStiffness.getValue(); }
    void setContactStiffness(double stiffness) { contactStiffness.setValue(stiffness); }

    double getContactFriction(int /*index*/) { return contactFriction.getValue(); }
    void setContactFriction(double friction) { contactFriction.setValue(friction); }
    
    std::string getContactResponse() { return contactResponse.getValue(); }
    
    
    virtual Topology* getTopology() { return getContext()->getMeshTopology(); }

    virtual sofa::core::componentmodel::topology::BaseMeshTopology* getMeshTopology() { return getContext()->getMeshTopology(); }

    const float* getColor4f();
    void setColor4f(const float *c){color.setValue(defaulttype::Vec4f(c[0],c[1],c[2],c[3]));};
protected:
    Data<bool> bActive;
    Data<bool> bMoving;
    Data<bool> bSimulated;
    Data<bool> bSelfCollision;
    Data<double> proximity;
    Data<double> contactStiffness;
    Data<double> contactFriction;
    Data<std::string> contactResponse;
    Data<int> group;
    Data<defaulttype::Vec4f> color;

    int size;

    CollisionModel* previous;

    CollisionModel* next;

    int numberOfContacts;

};

} // namespace core

} // namespace sofa

#endif