BaseContext.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_OBJECTMODEL_BASECONTEXT_H
#define SOFA_CORE_OBJECTMODEL_BASECONTEXT_H

#include <sofa/core/objectmodel/Base.h>
#include <sofa/core/objectmodel/ClassInfo.h>
#include <sofa/defaulttype/SolidTypes.h>
#include <set>

namespace sofa
{
  namespace simulation
  {
      class Visitor;
  }

  namespace core
  {

    // forward declaration of classes accessible from the context
    namespace componentmodel
    {
      namespace topology
      {
    class Topology;
    class BaseTopology;
    class BaseMeshTopology;
      }
    }

    namespace objectmodel
    {

      class BaseObject;
      class Event;

      class BaseContext : public virtual Base
      {
      public:

#ifdef SOFA_FLOAT
    typedef defaulttype::SolidTypes<float> SolidTypes;
#else
    typedef defaulttype::SolidTypes<double> SolidTypes;
#endif
    typedef SolidTypes::Transform Frame;
    typedef SolidTypes::Vec Vec3;
    typedef SolidTypes::Rot Quat;
    typedef SolidTypes::Mat Mat33;
    typedef SolidTypes::SpatialVector SpatialVector;

    BaseContext();
    virtual ~BaseContext();

    static BaseContext* getDefault();

    enum SearchDirection { SearchUp = -1, Local = 0, SearchDown = 1, SearchRoot = 2 };


    virtual bool isActive() const;

    virtual void setActive(bool){};

    virtual double getTime() const;

    virtual double getDt() const;

    virtual bool getAnimate() const;

    virtual bool getMultiThreadSimulation() const;

    virtual bool getShowCollisionModels() const;

    virtual bool getShowBoundingCollisionModels() const;

    virtual bool getShowBehaviorModels() const;

    virtual bool getShowVisualModels() const;

    virtual bool getShowMappings() const;

    virtual bool getShowMechanicalMappings() const;

    virtual bool getShowForceFields() const;

    virtual bool getShowInteractionForceFields() const;

    virtual bool getShowWireFrame() const;

    virtual bool getShowNormals() const;

    virtual int getCurrentLevel() const;
    
    virtual int getCoarsestLevel() const;
    
    virtual int getFinestLevel() const;
    
    //     virtual unsigned int nbLevels() const;



    virtual const Frame& getPositionInWorld() const;
    virtual void setPositionInWorld(const Frame&)
    {}

    virtual const SpatialVector& getVelocityInWorld() const;
    virtual void setVelocityInWorld(const SpatialVector&)
    {}

    virtual const Vec3& getVelocityBasedLinearAccelerationInWorld() const;
    virtual void setVelocityBasedLinearAccelerationInWorld(const Vec3& )
    {}


    virtual Vec3 getLocalGravity() const;
    //virtual void setGravity( const Vec3& ) { }
    virtual const Vec3& getGravityInWorld() const;
    virtual void setGravityInWorld( const Vec3& )
    { }


    virtual BaseObject* getMechanicalState() const;

    virtual core::componentmodel::topology::Topology* getTopology() const;
    
    virtual core::componentmodel::topology::BaseMeshTopology* getMeshTopology() const;
    
    virtual BaseObject* getMass() const;

    virtual BaseObject* getShader() const;

    virtual void* getObject(const ClassInfo& class_info, SearchDirection dir = SearchUp) const;

    virtual void* getObject(const ClassInfo& class_info, const std::string& path) const;

    class GetObjectsCallBack
    {
    public:
      virtual ~GetObjectsCallBack() {}
      virtual void operator()(void* ptr) = 0;
    };

    virtual void getObjects(const ClassInfo& class_info, GetObjectsCallBack& container, SearchDirection dir = SearchUp) const;

    template<class T>
      T* get(SearchDirection dir = SearchUp) const
      {
        return reinterpret_cast<T*>(this->getObject(classid(T), dir));
      }

    template<class T>
      void get(T*& ptr, SearchDirection dir = SearchUp) const
      {
        ptr = this->get<T>(dir);
      }

    template<class T>
      T* get(const std::string& path) const
      {
        return reinterpret_cast<T*>(this->getObject(classid(T), path));
      }

    template<class T>
      void get(T*& ptr, const std::string& path) const
      {
        ptr = this->get<T>(path);
      }

    template<class T, class Container>
      class GetObjectsCallBackT : public GetObjectsCallBack
    {
    public:
      Container* dest;
    GetObjectsCallBackT(Container* d) : dest(d) {}
      virtual void operator()(void* ptr)
      {
        dest->push_back(reinterpret_cast<T*>(ptr));
      }
    };

    template<class T, class Container>
      void get(Container* list, SearchDirection dir = SearchUp) const
    {
      GetObjectsCallBackT<T,Container> cb(list);
      this->getObjects(classid(T), cb, dir);
    }





    virtual void setDt( double /*dt*/ )
    { }

    virtual void setAnimate(bool /*val*/)
    { }

    virtual void setMultiThreadSimulation(bool /*val*/)
    { }

    virtual void setShowCollisionModels(bool /*val*/)
    { }

    virtual void setShowBoundingCollisionModels(bool /*val*/)
    { }

    virtual void setShowBehaviorModels(bool /*val*/)
    { }

    virtual void setShowVisualModels(bool /*val*/)
    { }

    virtual void setShowMappings(bool /*val*/)
    { }

    virtual void setShowMechanicalMappings(bool /*val*/)
    { }

    virtual void setShowForceFields(bool /*val*/)
    { }

    virtual void setShowInteractionForceFields(bool /*val*/)
    { }

    virtual void setShowWireFrame(bool /*val*/)
    { }

    virtual void setShowNormals(bool /*val*/)
    { }
    
    virtual bool setCurrentLevel(int )
    {
      return false;
    }
    
    virtual void setCoarsestLevel(int ){}
    
    virtual void setFinestLevel(int ){}



    virtual void setMechanicalState( BaseObject* )
    { }

    virtual void setTopology( BaseObject* )
    { }



    virtual bool addObject( BaseObject* /*obj*/ )
    {
      return false;
    }

    virtual bool removeObject( BaseObject* /*obj*/ )
    {
      return false;
    }



    virtual void executeVisitor( simulation::Visitor* );

    virtual void propagateEvent( Event* );


      };

    } // namespace objectmodel

  } // namespace core

} // namespace sofa

#endif