World.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2012-2016 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.
 *
*/
#ifndef _GAZEBO_WORLD_HH_
#define _GAZEBO_WORLD_HH_

#ifdef _WIN32
  // Ensure that Winsock2.h is included before Windows.h, which can get
  // pulled in by anybody (e.g., Boost).
  #include <Winsock2.h>
#endif

#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"
#include "gazebo/util/system.hh"

namespace gazebo
{
  namespace physics
  {
    class WorldPrivate;


    class GZ_PHYSICS_VISIBLE 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: physics::Atmosphere &Atmosphere() const;

      public: PresetManagerPtr GetPresetManager() const;

      public: physics::Wind &Wind() const;

      public: common::SphericalCoordinatesPtr GetSphericalCoordinates() const;

      public: ignition::math::Vector3d Gravity() const;

      public: void SetGravity(const ignition::math::Vector3d &_gravity);

      public: void SetGravitySDF(const ignition::math::Vector3d &_gravity);

      public: virtual ignition::math::Vector3d MagneticField() const;

      public: void SetMagneticField(const ignition::math::Vector3d &_mag);

      public: unsigned int GetModelCount() const;

      public: ModelPtr GetModel(unsigned int _index) const;

      public: Model_V GetModels() const;

      public: unsigned int LightCount() const;

      public: Light_V Lights() const;

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

      public: void ResetTime();

      public: void Reset();

      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: LightPtr Light(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 Step(unsigned 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;

      public: bool GetEnablePhysicsEngine();

      public: void EnablePhysicsEngine(bool _enable);

      public: bool WindEnabled() const;

      public: void SetWindEnabled(const bool _enable);

      public: bool AtmosphereEnabled() const;

      public: void SetAtmosphereEnabled(const bool _enable);

      public: void UpdateStateSDF();

      public: bool IsLoaded() const;

      public: void ClearModels();

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

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

      public: void PublishLightPose(const physics::LightPtr _light);

      public: uint32_t GetIterations() const;

      public: msgs::Scene GetSceneMsg() const;

      public: void RunBlocking(unsigned int _iterations = 0);

      public: void RemoveModel(ModelPtr _model);

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

      public: void ResetPhysicsStates();

      public: void _AddDirty(Entity *_entity);

      public: bool SensorsInitialized() const;

      public: void _SetSensorsInitialized(const bool _init);

      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: LightPtr LoadLight(const sdf::ElementPtr &_sdf,
          const 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 OnPlaybackControl(ConstLogPlaybackControlPtr &_data);

      private: void OnRequest(ConstRequestPtr &_msg);

      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: void ProcessLightFactoryMsgs();

      private: void ProcessLightModifyMsgs();

      private: bool OnLog(std::ostringstream &_stream);

      private: void ProcessMessages();

      private: void PublishWorldStats();

      private: void LogWorker();

      private: void OnLightMsg(ConstLightPtr &_msg);

      private: void OnLightFactoryMsg(ConstLightPtr &_msg);

      private: void OnLightModifyMsg(ConstLightPtr &_msg);

      private: WorldPrivate *dataPtr;

      private: friend class DARTLink;

      private: friend class SimbodyPhysics;
    };
  }
}
#endif