World.hh

Go to the documentation of this file.

/*
 * Copyright 2012 Open Source Robotics Foundation
 *
 * 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 <set>
#include <deque>
#include <string>
#include <boost/thread.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/shared_ptr.hpp>

#include <sdf/sdf.hh>

#include "gazebo/transport/TransportTypes.hh"

#include "gazebo/msgs/msgs.hh"

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

#include "gazebo/physics/Base.hh"
#include "gazebo/physics/PhysicsTypes.hh"
#include "gazebo/physics/WorldState.hh"

namespace gazebo
{
  namespace physics
  {

    class World : public boost::enable_shared_from_this<World>
    {
      public: explicit 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(unsigned int _iterations = 0);

      public: bool GetRunning() const;

      public: void Stop();

      public: void Fini();

      public: void Clear();

      public: std::string GetName() const;

      public: PhysicsEnginePtr GetPhysicsEngine() const;

      public: unsigned int GetModelCount() const;

      public: ModelPtr GetModel(unsigned int _index) const;

      public: Model_V GetModels() const;

      public: void ResetEntities(Base::EntityType _type = Base::BASE);

      public: void ResetTime();

      public: void Reset();

      public: EntityPtr GetSelectedEntity() const;

      public: void PrintEntityTree();

      public: common::Time GetSimTime() const;

      public: void SetSimTime(const 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 GetModel(const std::string &_name);

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

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

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

      public: void SetState(const WorldState &_state);

      public: void InsertModelFile(const std::string &_sdfFilename);

      public: void InsertModelString(const std::string &_sdfString);

      public: void InsertModelSDF(const sdf::SDF &_sdf);

      public: std::string StripWorldName(const std::string &_name) const;

      public: void EnableAllModels();

      public: void DisableAllModels();

      public: void StepWorld(int _steps);

      public: void LoadPlugin(const std::string &_filename,
                              const std::string &_name,
                              sdf::ElementPtr _sdf);

      public: void RemovePlugin(const std::string &_name);

      public: boost::mutex *GetSetWorldPoseMutex() const
        {return this->setWorldPoseMutex;}

      public: bool GetEnablePhysicsEngine()
              {return this->enablePhysicsEngine;}

      public: void EnablePhysicsEngine(bool _enable)
              {this->enablePhysicsEngine = _enable;}

      public: void UpdateStateSDF();

      public: bool IsLoaded() const;

      public: void PublishModelPose(physics::ModelPtr _model);

      private: ModelPtr GetModelById(unsigned int _id);

      private: void LoadPlugins();

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

      private: ModelPtr LoadModel(sdf::ElementPtr _sdf, BasePtr _parent);

      private: ActorPtr LoadActor(sdf::ElementPtr _sdf, BasePtr _parent);

      private: RoadPtr LoadRoad(sdf::ElementPtr _sdf, BasePtr _parent);

      private: void RunLoop();

      private: void Step();

      private: void LogStep();

      private: void Update();

      private: void OnPause(bool _p);

      private: void OnStep();

      private: void OnControl(ConstWorldControlPtr &_data);

      private: void OnRequest(ConstRequestPtr &_msg);

      private: void SetSelectedEntityCB(const std::string &_name);

      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: bool OnLog(std::ostringstream &_stream);

      private: void ProcessMessages();

      private: void PublishWorldStats();

      private: void LogWorker();

      private: common::Time prevStepWallTime;

      private: PhysicsEnginePtr physicsEngine;

      private: BasePtr rootElement;

      private: boost::thread *thread;

      private: bool stop;

      private: EntityPtr selectedEntity;

      private: std::string name;

      private: common::Time simTime;

      private: common::Time pauseTime;

      private: common::Time startTime;

      private: bool pause;

      private: int stepInc;

      private: event::Connection_V connections;

      private: transport::NodePtr node;

      private: transport::PublisherPtr selectionPub;

      private: transport::PublisherPtr statPub;

      private: transport::PublisherPtr diagPub;

      private: transport::PublisherPtr responsePub;

      private: transport::PublisherPtr modelPub;

      private: transport::PublisherPtr guiPub;

      private: transport::PublisherPtr lightPub;

      private: transport::PublisherPtr posePub;

      private: transport::SubscriberPtr controlSub;

      private: transport::SubscriberPtr factorySub;

      private: transport::SubscriberPtr jointSub;

      private: transport::SubscriberPtr modelSub;

      private: transport::SubscriberPtr requestSub;

      private: msgs::WorldStatistics worldStatsMsg;

      private: msgs::Scene sceneMsg;

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

      private: common::Time prevStatTime;

      private: common::Time pauseStartTime;

      private: common::Time realTimeOffset;

      private: boost::recursive_mutex *receiveMutex;

      private: boost::mutex *loadModelMutex;

      private: boost::mutex *setWorldPoseMutex;

      private: boost::recursive_mutex *worldUpdateMutex;

      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;

      private: bool resetAll;

      private: bool resetTimeOnly;

      private: bool resetModelOnly;

      private: bool initialized;

      private: bool loaded;

      private: bool enablePhysicsEngine;

      private: RayShapePtr testRay;

      private: bool pluginsLoaded;

      private: common::Time sleepOffset;

      private: common::Time prevProcessMsgsTime;

      private: common::Time processMsgsPeriod;

      private: std::deque<WorldState> states[2];

      private: int currentStateBuffer;

      private: WorldState prevStates[2];
      private: int stateToggle;

      private: sdf::ElementPtr logPlayStateSDF;
      private: WorldState logPlayState;

      private: sdf::SDFPtr factorySDF;

      private: std::set<ModelPtr> publishModelPoses;

      private: common::UpdateInfo updateInfo;

      private: uint64_t iterations;

      private: uint64_t stopIterations;

      private: boost::condition_variable logCondition;

      private: boost::condition_variable logContinueCondition;

      private: uint64_t logPrevIteration;

      private: common::Time logRealTime;

      private: boost::mutex logMutex;

      private: boost::mutex logBufferMutex;

      private: boost::mutex entityDeleteMutex;

      private: boost::thread *logThread;
    };
  }
}
#endif