Model.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: Base class for all models
 * Author: Nathan Koenig and Andrew Howard
 * Date: 8 May 2003
 */

#ifndef MODEL_HH
#define MODEL_HH

#include <string>

#include "common/CommonTypes.hh"
#include "physics/PhysicsTypes.hh"

#include "physics/Entity.hh"

namespace boost
{
  class recursive_mutex;
}

namespace gazebo
{
  namespace physics
  {

    class Model : public Entity
    {
      public: Model(BasePtr parent);
    
      public: virtual ~Model();
    
      public: void Load( sdf::ElementPtr &_sdf );
    
      public: virtual void Init();
    
      public: void Update();

      public: virtual void Fini();

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

      public: virtual const sdf::ElementPtr &GetSDF();

      public: virtual void RemoveChild(EntityPtr child);
  
      public: void Reset();
    
      public: void SetLinearVel( const math::Vector3 &vel );
  
      public: void SetAngularVel( const math::Vector3 &vel );
  
      public: void SetLinearAccel( const math::Vector3 &vel );
  
      public: void SetAngularAccel( const math::Vector3 &vel );
  
      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: virtual math::Box GetBoundingBox() const;
    
      public: unsigned int GetJointCount() const;
  
      public: JointPtr GetJoint( unsigned int index ) const;
  
      public: JointPtr GetJoint(const std::string &name);
 
      public: LinkPtr GetLinkById(unsigned int _id) const;

      public: LinkPtr GetLink(const std::string &name="canonical") const;
 
      public: void SetGravityMode( const bool &v );
  
      public: void SetCollideMode( const std::string &m );
  
      public: void SetLaserRetro( const float &retro );

      public: void FillModelMsg(msgs::Model &_msg);

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

      public: void SetJointPositions(
                  const std::map<std::string, double> &_jointPositions);

      public: void SetJointAnimation(
                  const std::map<std::string, common::NumericAnimationPtr> anim,
                  boost::function<void()> _onComplete);

      public: void AttachStaticModel(ModelPtr &_model, math::Pose _offset);

      public: void DetachStaticModel(const std::string &_model);

      protected: virtual void OnPoseChange();

      private: void RotateBodyAndChildren(LinkPtr _body1, 
                   const math::Vector3 &_anchor, const math::Vector3 &_axis, 
                   double _dangle, bool _updateChildren);
               
      private: void SlideBodyAndChildren(LinkPtr _body1,
                   const math::Vector3 &_anchor, const math::Vector3 &_axis,
                   double _dposition, bool _updateChildren);

      private: void GetAllChildrenBodies(std::vector<LinkPtr> &_bodies, 
                   const LinkPtr &_body);

      private: void GetAllParentBodies(std::vector<LinkPtr> &_bodies, 
                   const LinkPtr &_body, const LinkPtr &_origParentBody);

      private: bool InBodies(const LinkPtr &_body, 
                             const std::vector<LinkPtr> &_bodies);

      private: void LoadJoint( sdf::ElementPtr &_sdf );
   
      private: void LoadPlugin( sdf::ElementPtr &_sdf );

      private: LinkPtr canonicalLink;

      private: Joint_V joints;

      private: std::vector<ModelPluginPtr> plugins;

      private: transport::PublisherPtr jointPub;
      private: std::map<std::string, common::NumericAnimationPtr> jointAnimations;
      private: boost::function<void()> onJointAnimationComplete;
      private: common::Time prevAnimationTime;

      private: boost::recursive_mutex *updateMutex;

      protected: std::vector<ModelPtr> attachedModels;
      protected: std::vector<math::Pose> attachedModelsOffset;
    };
  }
}
#endif