Visual.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_RENDERING_VISUAL_HH_
#define GAZEBO_RENDERING_VISUAL_HH_

#include <boost/enable_shared_from_this.hpp>
#include <boost/function.hpp>
#include <string>
#include <utility>
#include <vector>

#include <sdf/sdf.hh>
#include <ignition/math/Box.hh>
#include <ignition/math/Color.hh>
#include <ignition/math/Pose3.hh>
#include <ignition/math/Quaternion.hh>
#include <ignition/math/Vector3.hh>
#include <ignition/msgs/MessageTypes.hh>

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

#include "gazebo/msgs/MessageTypes.hh"

#include "gazebo/rendering/RenderTypes.hh"
#include "gazebo/util/system.hh"

namespace Ogre
{
  class MovableObject;
  class SceneNode;
}

namespace gazebo
{
  namespace rendering
  {
    class VisualPrivate;


    class GZ_RENDERING_VISIBLE Visual :
      public std::enable_shared_from_this<Visual>
    {
      public: enum VisualType
      {
        VT_ENTITY,
        VT_MODEL,
        VT_LINK,
        VT_VISUAL,
        VT_COLLISION,
        VT_SENSOR,
        VT_GUI,
        VT_PHYSICS
      };

      public: Visual(const std::string &_name, VisualPtr _parent,
                     bool _useRTShader = true);

      public: Visual(const std::string &_name, ScenePtr _scene,
                     bool _useRTShader = true);

      public: virtual ~Visual();

      public: void Init();

      public: virtual void Fini();

      public: VisualPtr Clone(const std::string &_name, VisualPtr _newParent);

      public: void LoadFromMsg(ConstVisualPtr &_msg);

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

      public: virtual void Load();

      public: void Update();

      public: sdf::ElementPtr GetSDF() const;

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

      public: std::string Name() const;

      public: void AttachVisual(VisualPtr _vis);

      public: void DetachVisual(VisualPtr _vis);

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

      public: void AttachObject(Ogre::MovableObject *_obj);

      public: bool HasAttachedObject(const std::string &_name);

      public: unsigned int GetAttachedObjectCount() const;

      public: void DetachObjects();

      public: unsigned int GetChildCount();

      public: VisualPtr GetChild(unsigned int _index);

      public: Ogre::MovableObject *AttachMesh(const std::string &_meshName,
                  const std::string &_subMesh="",
                  bool _centerSubmesh = false,
                  const std::string &_objName="");

      public: void SetScale(const ignition::math::Vector3d &_scale);

      public: ignition::math::Vector3d Scale() const;

      public: ignition::math::Vector3d DerivedScale() const;

      public: bool GetLighting() const;

      public: void SetLighting(bool _lighting);

      public: void SetMaterial(const std::string &_materialName,
                               bool _unique = true, const bool _cascade = true);

      public: void SetMaterialShaderParam(const std::string &_paramName,
          const std::string &_shaderType, const std::string &_value);

      public: void SetAmbient(const ignition::math::Color &_color,
          const bool _cascade = true);

      public: void SetDiffuse(const ignition::math::Color &_color,
          const bool _cascade = true);

      public: void SetSpecular(const ignition::math::Color &_color,
          const bool _cascade = true);

      public: virtual void SetEmissive(const ignition::math::Color &_color,
          const bool _cascade = true);

      public: ignition::math::Color Ambient() const;

      public: ignition::math::Color Diffuse() const;

      public: ignition::math::Color Specular() const;

      public: ignition::math::Color Emissive() const;

      public: void SetWireframe(bool _show);

      public: bool Wireframe() const;

      private: void SetTransparencyInnerLoop(Ogre::SceneNode *_sceneNode);

      public: void SetTransparency(float _trans);

      public: float GetTransparency();

      public: float DerivedTransparency() const;

      public: void SetInheritTransparency(const bool _inherit);

      public: bool InheritTransparency() const;

      public: virtual void SetHighlighted(bool _highlighted);

      public: bool GetHighlighted() const;

      public: bool GetCastShadows() const;

      public: void SetCastShadows(bool _shadows);

      public: virtual void SetVisible(bool _visible, bool _cascade = true);

      public: void ToggleVisible();

      public: bool GetVisible() const;

      public: void SetPosition(const ignition::math::Vector3d &_pos);

      public: void SetRotation(const ignition::math::Quaterniond &_rot);

      public: void SetPose(const ignition::math::Pose3d &_pose);

      public: ignition::math::Vector3d Position() const;

      public: ignition::math::Quaterniond Rotation() const;

      public: ignition::math::Pose3d Pose() const;

      public: ignition::math::Pose3d InitialRelativePose() const;

      public: ignition::math::Pose3d WorldPose() const;

      public: void SetWorldPose(const ignition::math::Pose3d &_pose);

      public: void SetWorldPosition(const ignition::math::Vector3d &_pos);

      public: void SetWorldRotation(const ignition::math::Quaterniond &_rot);

      public: Ogre::SceneNode *GetSceneNode() const;

      public: void MakeStatic();

      public: bool IsStatic() const;

      public: void EnableTrackVisual(VisualPtr _vis);

      public: void DisableTrackVisual();

      public: std::string GetNormalMap() const;

      public: void SetNormalMap(const std::string &_nmap);

      public: void SetRibbonTrail(bool _value,
                  const ignition::math::Color &_initialColor,
                  const ignition::math::Color &_changeColor);

      public: ignition::math::Box BoundingBox() const;

      public: DynamicLines *CreateDynamicLine(
                  RenderOpType _type = RENDERING_LINE_STRIP);

      public: void DeleteDynamicLine(DynamicLines *_line);

      public: void AttachLineVertex(DynamicLines *_line,
                                     unsigned int _index);

      public: std::string GetMaterialName() const;

      public: void InsertMesh(const std::string &_meshName,
                  const std::string &_subMesh = "",
                  bool _centerSubmesh = false);

      public: static void InsertMesh(const common::Mesh *_mesh,
                  const std::string &_subMesh = "",
                  bool _centerSubmesh = false);

      public: void UpdateFromMsg(ConstVisualPtr &_msg);

      public: bool IsPlane() const;

      public: VisualPtr GetParent() const;

      public: VisualPtr GetRootVisual();

      public: VisualPtr GetNthAncestor(unsigned int _n);

      public: bool IsAncestorOf(const rendering::VisualPtr _visual) const;

      public: bool IsDescendantOf(const rendering::VisualPtr _visual) const;

      public: unsigned int GetDepth() const;

      public: std::string GetShaderType() const;

      public: void SetShaderType(const std::string &_type);

      public: void MoveToPosition(const ignition::math::Pose3d &_pose,
                  const double _time);

      public: void MoveToPositions(
          const std::vector<ignition::math::Pose3d> &_pts, const double _time,
          std::function<void()> _onComplete = nullptr);

      public: void SetVisibilityFlags(uint32_t _flags);

      public: uint32_t GetVisibilityFlags();

      public: void ShowBoundingBox();

      public: void ShowCollision(bool _show);

      public: void ShowSkeleton(bool _show);

      public: void SetScene(ScenePtr _scene);

      public: ScenePtr GetScene() const;

      public: void ShowJoints(bool _show);

      public: void ShowCOM(bool _show);

      public: void ShowInertia(bool _show);

      public: void ShowLinkFrame(bool _show);

      public: void SetSkeletonPose(const msgs::PoseAnimation &_pose);

      public: void LoadPlugin(const std::string &_filename,
                               const std::string &_name,
                               sdf::ElementPtr _sdf);

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

      public: uint32_t GetId() const;

      public: void SetId(uint32_t _id);

      public: std::string GetGeometryType() const;

      public: ignition::math::Vector3d GetGeometrySize() const;

      public: std::string GetMeshName() const;

      public: std::string GetSubMeshName() const;

      public: void ClearParent();

      public: void ToggleLayer(const int32_t _layer);

      public: void SetLayer(const int32_t _layer);

      public: Visual::VisualType GetType() const;

      public: void SetType(const Visual::VisualType _type);

      public: bool UseRTShader() const;

      public: void SetTypeMsg(const google::protobuf::Message *_msg);

      public: void AddPendingChild(std::pair<VisualType,
          const google::protobuf::Message *> _pair);

      public: static Visual::VisualType ConvertVisualType(
          const msgs::Visual::Type &_type);

      public: static msgs::Visual::Type ConvertVisualType(
          const Visual::VisualType &_type);

      public: void FillMaterialMsg(ignition::msgs::Material &_msg) const;

      protected: Visual(VisualPrivate &_dataPtr,
                        const std::string &_name, VisualPtr _parent,
                        bool _useRTShader = true);

      protected: Visual(VisualPrivate &_dataPtr,
                        const std::string &_name, ScenePtr _scene,
                        bool _useRTShader = true);

      protected: void ProcessMaterialMsg(const ignition::msgs::Material &_msg);

      private: void Init(const std::string &_name, ScenePtr _scene,
          bool _useRTShader);

      private: void Init(const std::string &_name, VisualPtr _parent,
          bool _useRTShader);

      private: void LoadPlugins();

      private: void LoadPlugin(sdf::ElementPtr _sdf);

      private: void BoundsHelper(Ogre::SceneNode *_node,
                                 ignition::math::Box &_box) const;

      private: bool GetCenterSubMesh() const;

      private: void DestroyAllAttachedMovableObjects(
                   Ogre::SceneNode *_sceneNode);

      private: void UpdateGeomSize(const ignition::math::Vector3d &_scale);

      private: void UpdateTransparency(const bool _cascade = true);

      protected: VisualPrivate *dataPtr;
    };
  }
}
#endif