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_
 
#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;
    class Boolean;
  }
}
 
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: const sdf::World *GetSDFDom() const;
 
      public: void Save(const std::string &_filename);
 
      public: void Init() GAZEBO_DEPRECATED(11.0);
 
      public: void Init(UpdateScenePosesFunc _func);
 
      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: 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);
 
      public: void SetSensorWaitFunc(std::function<void(double, double)> _func);
 
      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: void ProcessPlaybackControlMsgs();
 
      private: bool OnLog(std::ostringstream &_stream);
 
      private: void LogModelResources();
 
      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: bool SceneInfoService(msgs::Scene &_response);
 
      private: bool ShadowCasterMaterialNameService(
          ignition::msgs::StringMsg &_response);
 
      private: bool ShadowCasterRenderBackFacesService(
          ignition::msgs::Boolean &_response);
 
      private: std::unique_ptr<WorldPrivate> dataPtr;
 
      private: friend class DARTLink;
 
      private: friend class SimbodyPhysics;
    };
  }
}
#endif