Base.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_BASE_HH_
#define GAZEBO_PHYSICS_BASE_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 <boost/enable_shared_from_this.hpp>
#include <string>
#include <vector>

#include <sdf/sdf.hh>

#include "gazebo/common/URI.hh"
#include "gazebo/physics/PhysicsTypes.hh"
#include "gazebo/util/system.hh"

namespace gazebo
{
  namespace physics
  {

    static std::string EntityTypename[] = {
      "common",
      "entity",
      "model",
      "actor",
      "link",
      "collision",
      "light",
      "visual",
      "joint",
      "ball",
      "hinge2",
      "hinge",
      "slider",
      "universal",
      "shape",
      "box",
      "cylinder",
      "heightmap",
      "map",
      "multiray",
      "ray",
      "plane",
      "sphere",
      "trimesh",
      "polyline"
    };

    class GZ_PHYSICS_VISIBLE Base : public boost::enable_shared_from_this<Base>
    {
      public: enum EntityType {
                BASE            = 0x00000000,
                ENTITY          = 0x00000001,
                MODEL           = 0x00000002,
                LINK            = 0x00000004,
                COLLISION       = 0x00000008,
                LIGHT           = 0x00000010,
                VISUAL          = 0x00000020,

                JOINT           = 0x00000040,
                BALL_JOINT      = 0x00000080,
                HINGE2_JOINT    = 0x00000100,
                HINGE_JOINT     = 0x00000200,
                SLIDER_JOINT    = 0x00000400,
                SCREW_JOINT     = 0x00000800,
                UNIVERSAL_JOINT = 0x00001000,
                GEARBOX_JOINT   = 0x00002000,
                FIXED_JOINT     = 0x00004000,

                ACTOR           = 0x00008000,

                SHAPE           = 0x00010000,
                BOX_SHAPE       = 0x00020000,
                CYLINDER_SHAPE  = 0x00040000,
                HEIGHTMAP_SHAPE = 0x00080000,
                MAP_SHAPE       = 0x00100000,
                MULTIRAY_SHAPE  = 0x00200000,
                RAY_SHAPE       = 0x00400000,
                PLANE_SHAPE     = 0x00800000,
                SPHERE_SHAPE    = 0x01000000,
                MESH_SHAPE      = 0x02000000,
                POLYLINE_SHAPE  = 0x04000000,

                SENSOR_COLLISION = 0x10000000
              };

      public: explicit Base(BasePtr _parent);

      public: virtual ~Base();

      public: virtual void Load(sdf::ElementPtr _sdf);

      public: virtual void Fini();

      public: virtual void Init() {}

      public: virtual void Reset();

      public: virtual void Reset(Base::EntityType _resetType);

      public: virtual void Update() {}

      public: virtual void UpdateParameters(sdf::ElementPtr _sdf);

      public: virtual void SetName(const std::string &_name);

      public: std::string GetName() const;

      public: uint32_t GetId() const;

      public: void SetSaveable(bool _v);

      public: bool GetSaveable() const;

      public: int GetParentId() const;

      public: void SetParent(BasePtr _parent);

      public: BasePtr GetParent() const;

      public: void AddChild(BasePtr _child);

      public: virtual void RemoveChild(unsigned int _id);

      public: void RemoveChildren();

      public: unsigned int GetChildCount() const;

      public: BasePtr GetById(unsigned int _id) const;

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

      public: BasePtr GetChild(unsigned int _i) const;

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

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

      public: void RemoveChild(physics::BasePtr _child);

      public: void AddType(EntityType _type);

      public: bool HasType(const EntityType &_t) const;

      public: unsigned int GetType() const;

      public: std::string TypeStr() const;

      public: std::string GetScopedName(bool _prependWorldName = false) const;

      public: common::URI URI() const;

      public: void Print(const std::string &_prefix);

      public: virtual bool SetSelected(bool _show);

      public: bool IsSelected() const;

      public: bool operator ==(const Base &_ent) const;

      public: void SetWorld(const WorldPtr &_newWorld);

      public: const WorldPtr &GetWorld() const;

      public: virtual const sdf::ElementPtr GetSDF();

      protected: virtual void RegisterIntrospectionItems();

      protected: virtual void UnregisterIntrospectionItems();

      protected: void ComputeScopedName();

      protected: sdf::ElementPtr sdf;

      protected: BasePtr parent;

      protected: Base_V children;

      protected: WorldPtr world;

      protected: std::vector<common::URI> introspectionItems;

      private: bool saveable;

      private: uint32_t id;

      private: unsigned int type;

      private: std::string typeStr;

      private: bool selected;

      private: std::string name;

      private: std::string scopedName;

      protected: friend class Entity;
    };
  }
}
#endif