World.hh

Go to the documentation of this file.

/*
 * Copyright (C) 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.
 *
*/
#ifndef GAZEBO_PHYSICS_WORLD_HH_
#define GAZEBO_PHYSICS_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 <memory>

#include <boost/enable_shared_from_this.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/common/URI.hh"

#include "gazebo/physics/Base.hh"
#include "gazebo/physics/PhysicsTypes.hh"
#include "gazebo/physics/WorldState.hh"
#include "gazebo/physics/Wind.hh"
#include "gazebo/util/system.hh"

// Forward declare reference and pointer parameters
namespace ignition
{
  namespace msgs
  {
    class Plugin_V;
    class StringMsg;
  }
}

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: const sdf::ElementPtr SDF();

      public: void Save(const std::string &_filename);

      public: void Init();

      public: void Run(const unsigned int _iterations = 0);

      public: bool Running() const;

      public: void Stop();

      public: void Fini();

      public: void Clear();

      public: std::string Name() const;

      public: PhysicsEnginePtr Physics() const;

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

      public: PresetManagerPtr PresetMgr() const;

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

      public: common::SphericalCoordinatesPtr SphericalCoords() 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 ModelCount() const;

      public: ModelPtr ModelByIndex(const unsigned int _index) const;

      public: Model_V Models() 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 SimTime() const;

      public: void SetSimTime(const common::Time &_t);

      public: common::Time PauseTime() const;

      public: common::Time StartTime() const;

      public: common::Time RealTime() const;

      public: bool IsPaused() const;

      public: void SetPaused(const bool _p);

      public: BasePtr BaseByName(const std::string &_name) const;

      public: ModelPtr ModelByName(const std::string &_name) const;

      public: LightPtr LightByName(const std::string &_name) const;

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

      public: ModelPtr ModelBelowPoint(
                  const ignition::math::Vector3d &_pt) const;

      public: EntityPtr EntityBelowPoint(
                  const ignition::math::Vector3d &_pt) const;

      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(const 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: std::mutex &WorldPoseMutex() const;

      public: bool PhysicsEnabled() const;

      public: void SetPhysicsEnabled(const 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 Iterations() const;

      public: msgs::Scene SceneMsg() const;

      public: void RunBlocking(const 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);

      public: common::URI URI() const;

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

      private: ModelPtr ModelById(const unsigned int _id) const;

      private: void LoadPlugins();

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

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

      public: 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 RegisterIntrospectionItems();

      private: void UnregisterIntrospectionItems();

      private: void OnLightFactoryMsg(ConstLightPtr &_msg);

      private: void OnLightModifyMsg(ConstLightPtr &_msg);

      private: bool PluginInfoService(const ignition::msgs::StringMsg &_request,
          ignition::msgs::Plugin_V &_plugins);

      private: std::unique_ptr<WorldPrivate> dataPtr;

      private: friend class DARTLink;

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