PhysicsObject.h

Go to the documentation of this file.

/********************************************************************
**                Image Component Library (ICL)                    **
**                                                                 **
** Copyright (C) 2006-2014 CITEC, University of Bielefeld          **
**                         Neuroinformatics Group                  **
** Website: www.iclcv.org and                                      **
**          http://opensource.cit-ec.de/projects/icl               **
**                                                                 **
** File   : ICLPhysics/src/ICLPhysics/PhysicsObject.h              **
** Module : ICLPhysics                                             **
** Author : Christof Elbrechter, Matthias Esau                     **
**                                                                 **
**                                                                 **
** GNU LESSER GENERAL PUBLIC LICENSE                               **
** This file may be used under the terms of the GNU Lesser General **
** Public License version 3.0 as published by the                  **
**                                                                 **
** Free Software Foundation and appearing in the file LICENSE.LGPL **
** included in the packaging of this file.  Please review the      **
** following information to ensure the license requirements will   **
** be met: http://www.gnu.org/licenses/lgpl-3.0.txt                **
**                                                                 **
** The development of this software was supported by the           **
** Excellence Cluster EXC 277 Cognitive Interaction Technology.    **
** The Excellence Cluster EXC 277 is a grant of the Deutsche       **
** Forschungsgemeinschaft (DFG) in the context of the German       **
** Excellence Initiative.                                          **
**                                                                 **
********************************************************************/
#pragma once

#include <ICLGeom/SceneObject.h>
#include <ICLUtils/Uncopyable.h>
#include <ICLUtils/Mutex.h>
#include <ICLUtils/Function.h>
class btCollisionObject;

namespace icl {
  namespace physics{

    class PhysicsWorld;

    class ICLPhysics_API PhysicsObject : public geom::SceneObject, public utils::Uncopyable{
      PhysicsWorld *m_world;
      btCollisionObject *m_physicalObject;
      int m_collisionGroup;
      protected:
      bool m_stateChanged;

      utils::Function<void,PhysicsObject*,PhysicsObject*, geom::Vec> m_collisionCallback;

                        std::string m_id;

      public:
                        PhysicsObject():m_world(0), m_physicalObject(0),m_collisionGroup(0), m_stateChanged(true), m_id("") {
        setLockingEnabled(true);
        //create an empty default callback
        struct defaultCallback {
          static void callback(PhysicsObject* self, PhysicsObject* other, geom::Vec pos) {}
        };
                m_collisionCallback = utils::function(&defaultCallback::callback);
      }

      virtual ~PhysicsObject();

      void setPhysicalObject(btCollisionObject *obj);

      void forgetPhysicalObject(bool removeFromWorld=true);


      virtual btCollisionObject *getCollisionObject() {
        return m_physicalObject;
      }

      virtual const btCollisionObject *getCollisionObject() const{
        return m_physicalObject;
      }

      virtual void updateSceneObject();

      virtual void prepareForRendering() {
        lock();
        updateSceneObject();
        unlock();
      }

      virtual void setTransformation(const geom::Mat &m);
      virtual void transform(const geom::Mat &m);
      geom::Mat getTransformation();

      void setScale(geom::Vec scale);
      geom::Vec getScale();

      void setCollisionMargin(float margin);

      void setFriction(float friction);

      void setRollingFriction(float friction);

      void setCollisionGroup(int group);

      int getCollisionGroup();

      void setContactResponse(bool response);

      bool hasContactResponse();

      void setRestitution(float restitution);

      void activate(bool forceActivation = false);

                        int getCollisionObjectType();

                        void setCollisionObjectType(int type);

                        int getCollisionFlags();

                        void setCollisionFlags(int flags);

      void stateChanged();

      void setCurrentPhysicsWorld(PhysicsWorld *world);

      void setCollisionCallback(utils::Function<void,PhysicsObject*,PhysicsObject*, geom::Vec> collisionCallback);

      void collisionCallback(PhysicsObject* self, PhysicsObject* other, geom::Vec pos);

                        void setObjectID(std::string const &id);

                        std::string getObjectID();

                        std::string getObjectID() const;
    };
  }
}