World.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: The world; all models are collected here
 * Author: Andrew Howard and Nate Koenig
 * Date: 3 Apr 2007
 */

#ifndef WORLD_HH
#define WORLD_HH

#include <vector>
#include <list>
#include <string>
#include <boost/enable_shared_from_this.hpp>
#include <boost/shared_ptr.hpp>

#include "transport/TransportTypes.hh"

#include "msgs/msgs.h"

#include "sensors/SensorTypes.hh"

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

#include "physics/PhysicsTypes.hh"
#include "sdf/sdf.h"

namespace boost
{
  class thread;
  class mutex;
  class recursive_mutex;
}

namespace gazebo
{
    namespace physics
  {


    /*
     * The world class keps a list of all models, handles loading and saving,
     * object dynamics and collision detection for contact joints
     */
    class World : public boost::enable_shared_from_this<World>
    {
      public: World(const std::string &_name="");
    
      public: ~World();
    
      public: void Load( sdf::ElementPtr _sdf );
    
      public: void Save(const std::string &_filename);

      public: void Init();
    
      public: void Run();

      public: void Stop();
 
      public: void Fini();
    
      public: void Clear();
    
      public: std::string GetName() const;
    
      public: unsigned int GetParamCount() const;
    
      public: common::Param *GetParam(unsigned int index) const;
    
      public: PhysicsEnginePtr GetPhysicsEngine() const;
   
      public: unsigned int GetModelCount() const;
    
      public: ModelPtr GetModel(unsigned int index);
    
      public: void Reset(bool _resetTime=true);
    
      public: EntityPtr GetSelectedEntity() const;

      public: void PrintEntityTree();
    
      public: common::Time GetSimTime() const;
    
      public: void SetSimTime(common::Time t);
    
      public: common::Time GetPauseTime() const;
    
      public: common::Time GetStartTime() const;
    
      public: common::Time GetRealTime() const;
    
      public: bool IsPaused() const;
    
      public: void SetPaused(bool p);
    
      public: BasePtr GetByName(const std::string &name);

      public: ModelPtr GetModelById(unsigned int _id);

      public: ModelPtr GetModelByName(const std::string &name);

      public: EntityPtr GetEntityByName(const std::string &_name);

      public: ModelPtr GetModelBelowPoint(const math::Vector3 &_pt);

      public: EntityPtr GetEntityBelowPoint(const math::Vector3 &_pt);

      private: void LoadEntities( sdf::ElementPtr &_sdf , BasePtr parent);

      private: ModelPtr LoadModel( sdf::ElementPtr &_sdf, BasePtr parent);
 
      private: void RunLoop();
    
      private: void Update();
 
      private: void OnPause(bool p);
    
      private: void OnStep();

      private: void OnControl( ConstWorldControlPtr &data );
    
      private: void OnRequest( ConstRequestPtr &_msg );

      private: void DeleteEntityCB(const std::string &name);
    
      private: void SetSelectedEntityCB( const std::string &name );
    
      private: void OnEntitiesRequest( ConstRequestPtr &_data );

      private: void BuildSceneMsg(msgs::Scene &scene, BasePtr entity);

      private: void JointLog(ConstJointPtr &msg);

      private: void OnFactoryMsg(
                   ConstFactoryPtr &data);
      private: void OnModelMsg(
                   ConstModelPtr &_msg);

      private: void ModelUpdateTBB();

      private: void ModelUpdateSingleLoop();

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

      private: void FillModelMsg(msgs::Model &_msg, ModelPtr &_model);

      private: void ProcessEntityMsgs();
      private: void ProcessRequestMsgs();
      private: void ProcessFactoryMsgs();
      private: void ProcessModelMsgs();

      private: PhysicsEnginePtr physicsEngine;
    
      private: BasePtr rootElement;
 
      private: boost::thread *thread;
    
      private: bool stop;
 
      protected: common::Param_V parameters;
    
      private: EntityPtr selectedEntity;
    
      private: std::vector<google::protobuf::Message> messages;
    
      private: std::string name;
               
      private: common::Time simTime, pauseTime, startTime;
      private: bool pause;
      private: bool stepInc;
    
      private: event::Connection_V connections;

      private: transport::NodePtr node;    
      private: transport::PublisherPtr selectionPub;
      private: transport::PublisherPtr statPub, responsePub, modelPub;
      private: transport::PublisherPtr guiPub, scenePub;

      private: transport::SubscriberPtr controlSub;
      private: transport::SubscriberPtr factorySub, jointSub;
      private: transport::SubscriberPtr modelSub, requestSub;

      private: msgs::WorldStatistics worldStatsMsg;
      private: msgs::Scene sceneMsg;

      private: void (World::*modelUpdateFunc)();

      private: common::Time statPeriod;
      private: common::Time prevStatTime;
      private: common::Time pauseStartTime;
      private: common::Time realTimeOffset;

      private: boost::mutex *receiveMutex;

      public: boost::recursive_mutex *modelWorldPoseUpdateMutex;

      private: sdf::ElementPtr sdf;

      private: std::vector<WorldPluginPtr> plugins;
      private: std::list<std::string> deleteEntity;

      public: std::list<Entity*> dirtyPoses;

      private: std::list<msgs::Request> requestMsgs;
      private: std::list<msgs::Factory> factoryMsgs;
      private: std::list<msgs::Model> modelMsgs;

      private: bool needsReset;
    };

  }
}
#endif