Collision.hh

/*
 * Copyright 2011 Nate Koenig & Andrew Howard
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/
/* Desc: Collision class
 * Author: Nate Koenig
 * Date: 13 Feb 2006
 */

#ifndef COLLISION_HH
#define COLLISION_HH

#include "common/Event.hh"
#include "common/CommonTypes.hh"

#include "physics/PhysicsTypes.hh"
#include "physics/Entity.hh"

namespace gazebo
{
    namespace physics
  {

    class Collision : public Entity
    {
      public: Collision(LinkPtr link);
    
      public: virtual ~Collision();
  
      public: void Fini();
  
      public: virtual void Load( sdf::ElementPtr &_sdf );

      public: virtual void Init();

      public: virtual void UpdateParameters( sdf::ElementPtr &_sdf );

      public: void Save(std::string &prefix, std::ostream &stream);
   
      public: void SetCollision(bool placeable);
    
      public: bool IsPlaceable() const;
      
      public: virtual void SetCategoryBits(unsigned int bits) = 0;
    
      public: virtual void SetCollideBits(unsigned int bits) = 0;
    
      public: void SetLaserRetro(float retro);
    
      public: float GetLaserRetro() const;
  
      public: void ShowBoundingBox(const bool &show);
  
      public: LinkPtr GetLink() const;
  
      public: ModelPtr GetModel() const;
  
      public: virtual math::Box GetBoundingBox() const = 0;
  
      public: unsigned int GetShapeType();
  
      public: void SetShape(ShapePtr shape);
              
      public: ShapePtr GetShape() const;
  
      public: void SetContactsEnabled(bool _enable);
  
      public: bool GetContactsEnabled() const;
  
      public: void AddContact(const Contact &contact);
  
      public: virtual math::Vector3 GetRelativeLinearVel() const;
  
      public: virtual math::Vector3 GetWorldLinearVel() const;
  
      public: virtual math::Vector3 GetRelativeAngularVel() const;
  
      public: virtual math::Vector3 GetWorldAngularVel() const;
  
      public: virtual math::Vector3 GetRelativeLinearAccel() const;
              
      public: virtual math::Vector3 GetWorldLinearAccel() const;
  
      public: virtual math::Vector3 GetRelativeAngularAccel() const;
  
      public: virtual math::Vector3 GetWorldAngularAccel() const;
  
      public: template< typename T>
              event::ConnectionPtr ConnectContact( T subscriber )
              { return contact.Connect(subscriber); }
      public: void DisconnectContact( event::ConnectionPtr &c )
              { contact.Disconnect(c); }

      public: void FillCollisionMsg( msgs::Collision &_msg );

      public: void ProcessMsg(const msgs::Collision &_msg);

      private: void EnabledCB(bool enabled);
  
      private: void CreateBoundingBox();

      private: msgs::Visual CreateCollisionVisual();
 
      protected: LinkPtr link;
    
      protected: bool placeable;
  
      private: float transparency;
  
      private: std::string bbVisual;
  
      protected: ShapePtr shape;

      private: bool contactsEnabled;
  
      public: event::EventT<void (const std::string &,
                                  const Contact &)> contact;

      public: SurfaceParamsPtr surface; 
      private: std::vector<event::ConnectionPtr> connections;
    };
  }
}
#endif