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_
 
#include <boost/enable_shared_from_this.hpp>
#include <optional>
#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 GetByIdRecursive(unsigned int _id);
 
 
      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: std::string StripScopedName(const std::string &_name) const;
 
      public: std::string StripParentScopedName(const std::string &_name) 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();
 
      public: virtual std::optional<sdf::SemanticPose> SDFSemanticPose() const;
 
      public: ignition::math::Pose3d SDFPoseRelativeToParent() const;
 
      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