WorldPrivate.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2015-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_PRIVATE_HH_
#define _GAZEBO_WORLD_PRIVATE_HH_

#include <atomic>
#include <deque>
#include <vector>
#include <list>
#include <set>
#include <boost/thread.hpp>
#include <sdf/sdf.hh>
#include <string>

#include "gazebo/common/Event.hh"
#include "gazebo/common/Time.hh"

#include "gazebo/msgs/msgs.hh"

#include "gazebo/transport/TransportTypes.hh"

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

namespace gazebo
{
  namespace physics
  {
    class WorldPrivate
    {
      public: common::Time prevStepWallTime;

      public: PhysicsEnginePtr physicsEngine;

      public: common::SphericalCoordinatesPtr sphericalCoordinates;

      public: BasePtr rootElement;

      public: boost::thread *thread;

      public: bool stop;

      public: std::string name;

      public: common::Time simTime;

      public: common::Time pauseTime;

      public: common::Time startTime;

      public: bool pause;

      public: int stepInc;

      public: event::Connection_V connections;

      public: transport::NodePtr node;

      public: transport::PublisherPtr statPub;

      public: transport::PublisherPtr responsePub;

      public: transport::PublisherPtr modelPub;

      public: transport::PublisherPtr guiPub;

      public: transport::PublisherPtr lightPub;

      public: transport::PublisherPtr posePub;

      public: transport::PublisherPtr poseLocalPub;

      public: transport::SubscriberPtr controlSub;

      public: transport::SubscriberPtr playbackControlSub;

      public: transport::SubscriberPtr factorySub;

      public: transport::SubscriberPtr jointSub;

      public: transport::SubscriberPtr lightSub;

      public: transport::SubscriberPtr lightFactorySub;

      public: transport::SubscriberPtr lightModifySub;

      public: transport::SubscriberPtr modelSub;

      public: transport::SubscriberPtr requestSub;

      public: msgs::WorldStatistics worldStatsMsg;

      public: msgs::Scene sceneMsg;

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

      public: common::Time prevStatTime;

      public: common::Time pauseStartTime;

      public: common::Time realTimeOffset;

      public: boost::recursive_mutex *receiveMutex;

      public: boost::mutex *loadModelMutex;

      public: std::mutex loadLightMutex;

      public: boost::mutex *setWorldPoseMutex;

      public: boost::recursive_mutex *worldUpdateMutex;

      public: sdf::ElementPtr sdf;

      public: std::vector<WorldPluginPtr> plugins;

      public: std::list<std::string> deleteEntity;

      public: std::list<msgs::Request> requestMsgs;

      public: std::list<msgs::Factory> factoryMsgs;

      public: std::list<msgs::Model> modelMsgs;

      public: std::list<msgs::Light> lightFactoryMsgs;

      public: std::list<msgs::Light> lightModifyMsgs;

      public: bool needsReset;

      public: bool resetAll;

      public: bool resetTimeOnly;

      public: bool resetModelOnly;

      public: bool initialized;

      public: bool loaded;

      public: bool enablePhysicsEngine;

      public: RayShapePtr testRay;

      public: bool pluginsLoaded;

      public: common::Time sleepOffset;

      public: common::Time prevProcessMsgsTime;

      public: common::Time processMsgsPeriod;

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

      public: int currentStateBuffer;

      public: WorldState prevStates[2];

      public: int stateToggle;

      public: sdf::ElementPtr logPlayStateSDF;

      public: WorldState logPlayState;

      public: sdf::SDFPtr factorySDF;

      public: std::set<ModelPtr> publishModelPoses;

      public: std::set<ModelPtr> publishModelScales;

      public: std::set<LightPtr> publishLightPoses;

      public: common::UpdateInfo updateInfo;

      public: uint64_t iterations;

      public: uint64_t stopIterations;

      public: boost::condition_variable logCondition;

      public: boost::condition_variable logContinueCondition;

      public: uint64_t logPrevIteration;

      public: common::Time logRealTime;

      public: boost::mutex logMutex;

      public: boost::mutex logBufferMutex;

      public: boost::mutex entityDeleteMutex;

      public: boost::thread *logThread;

      public: Model_V models;

      public: Light_V lights;

      public: boost::mutex factoryDeleteMutex;

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

      public: PresetManagerPtr presetManager;

      public: UserCmdManagerPtr userCmdManager;

      public: std::atomic_bool sensorsInitialized;
    };
  }
}

#endif