ScenePrivate.hh

Go to the documentation of this file.

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

#include <list>
#include <map>
#include <string>
#include <vector>

#include <boost/unordered/unordered_map.hpp>
#include <boost/thread/recursive_mutex.hpp>

#include <sdf/sdf.hh>

#include "gazebo/common/Events.hh"
#include "gazebo/gazebo_config.h"
#include "gazebo/msgs/msgs.hh"
#include "gazebo/rendering/RenderTypes.hh"
#include "gazebo/transport/TransportTypes.hh"

namespace SkyX
{
  class SkyX;
  class BasicController;
}

namespace Ogre
{
  class SceneManager;
  class RaySceneQuery;
}

namespace boost
{
  class mutex;
}

namespace gazebo
{
  namespace rendering
  {
    class Projector;
    class Visual;
    class Grid;
    class Heightmap;

    typedef std::map<uint32_t, VisualPtr> Visual_M;

    typedef std::list<boost::shared_ptr<msgs::Visual const> > VisualMsgs_L;

    typedef std::list<boost::shared_ptr<msgs::Light const> > LightMsgs_L;

    typedef std::map<uint32_t, msgs::Pose> PoseMsgs_M;

    typedef std::list<boost::shared_ptr<msgs::Scene const> > SceneMsgs_L;

    typedef std::list<boost::shared_ptr<msgs::Joint const> > JointMsgs_L;

    typedef std::list<boost::shared_ptr<msgs::Link const> > LinkMsgs_L;

    typedef std::list<boost::shared_ptr<msgs::Model const> > ModelMsgs_L;

    typedef std::list<boost::shared_ptr<msgs::Sensor const> > SensorMsgs_L;

    typedef std::list<boost::shared_ptr<msgs::Request const> > RequestMsgs_L;

    typedef std::map<std::string, LightPtr> Light_M;
    typedef std::list<boost::shared_ptr<msgs::PoseAnimation const> >
                                                        SkeletonPoseMsgs_L;

    typedef boost::unordered_map<std::string,
        boost::shared_ptr<msgs::Joint const> > JointMsgs_M;

    class ScenePrivate
    {
/*      public: enum SkyXMode {
        GZ_SKYX_ALL = 0x0FFFFFFF,
        GZ_SKYX_CLOUDS = 0x0000001,
        GZ_SKYX_MOON = 0x0000002,
        GZ_SKYX_NONE = 0
      };*/

      public: std::string name;

      public: sdf::ElementPtr sdf;

      public: std::vector<CameraPtr> cameras;

      public: std::vector<UserCameraPtr> userCameras;

#ifdef HAVE_OCULUS
      public: std::vector<OculusCameraPtr> oculusCameras;
#endif

      public: Ogre::SceneManager *manager;

      public: Ogre::RaySceneQuery *raySceneQuery;

      public: std::vector<Grid *> grids;

      public: static uint32_t idCounter;

      public: uint32_t id;

      public: std::string idString;

      public: VisualMsgs_L visualMsgs;

      public: LightMsgs_L lightMsgs;

      public: PoseMsgs_M poseMsgs;

      public: SceneMsgs_L sceneMsgs;

      public: JointMsgs_L jointMsgs;

      public: LinkMsgs_L linkMsgs;

      public: ModelMsgs_L modelMsgs;

      public: SensorMsgs_L sensorMsgs;

      public: RequestMsgs_L requestMsgs;

      public: Visual_M visuals;

      public: Light_M lights;

      public: SkeletonPoseMsgs_L skeletonPoseMsgs;

      public: boost::shared_ptr<msgs::Selection const> selectionMsg;

      public: boost::mutex *receiveMutex;

      public: boost::recursive_mutex poseMsgMutex;

      public: transport::NodePtr node;

      public: transport::SubscriberPtr sensorSub;

      public: transport::SubscriberPtr sceneSub;

      public: transport::SubscriberPtr requestSub;

      public: transport::SubscriberPtr visSub;

      public: transport::SubscriberPtr lightSub;

      public: transport::SubscriberPtr poseSub;

      public: transport::SubscriberPtr jointSub;

      public: transport::SubscriberPtr selectionSub;

      public: transport::SubscriberPtr responseSub;

      public: transport::SubscriberPtr skeletonPoseSub;

      public: transport::SubscriberPtr skySub;

      public: transport::SubscriberPtr modelInfoSub;

      public: transport::PublisherPtr lightPub;

      public: transport::PublisherPtr responsePub;

      public: transport::PublisherPtr requestPub;

      public: std::vector<event::ConnectionPtr> connections;

      public: VisualPtr worldVisual;

      public: VisualPtr selectedVis;

      public: std::string selectionMode;

      public: msgs::Request *requestMsg;

      public: bool enableVisualizations;

      public: Heightmap *terrain;

      public: std::map<std::string, Projector *> projectors;

      public: SkyX::SkyX *skyx;

      public: SkyX::BasicController *skyxController;

      public: bool showCOMs;

      public: bool showCollisions;

      public: bool showJoints;

      public: bool transparent;

      public: bool wireframe;

      public: bool initialized;

      public: common::Time sceneSimTimePosesReceived;

      public: common::Time sceneSimTimePosesApplied;

      public: uint32_t contactVisId;

      public: JointMsgs_M joints;
    };
  }
}
#endif