Visual.hh

/*
 * Copyright 2011 Nate Koenig & Andrew Howard
 *
 * 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.
 *
*/
/* Desc: Ogre Visual Class
 * Author: Nate Koenig
 * Date: 14 Dec 2007
 */

#ifndef VISUAL_HH
#define VISUAL_HH

#include <boost/enable_shared_from_this.hpp>
#include <string>

#include "common/Event.hh"
#include "math/Box.hh"
#include "math/Pose.hh"
#include "math/Quaternion.hh"
#include "math/Vector3.hh"
#include "math/Vector2d.hh"

#include "sdf/sdf.h"
#include "msgs/msgs.h"
#include "rendering/RenderTypes.hh"
#include "common/CommonTypes.hh"

namespace Ogre
{
  class MovableObject;
  class SceneNode;
  class StaticGeometry;
  class RibbonTrail;
  class AxisAlignedBox;
  class AnimationState;
}

namespace gazebo
{
    namespace rendering
  { 

    class Visual : public boost::enable_shared_from_this<Visual>
    {
      public: Visual (const std::string &name, VisualPtr _parent);
  
      public: Visual (const std::string &name, Scene *scene);
  
      public: virtual ~Visual();
  
      public: void Init();
      public: void Fini();
  
      public: void LoadFromMsg(const boost::shared_ptr< msgs::Visual const> &msg);
  
      public: void Load( sdf::ElementPtr &sdf );

      public: void Load();
  
      public: void Update();

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

      public: std::string GetName() 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: void DetachObjects();
  
      public: unsigned int GetChildCount();
  
      public: VisualPtr GetChild(unsigned int _num);
  
      public: void AttachMesh( const std::string &meshName );
  
      public: void SetScale( const math::Vector3 &scale );
  
      public: math::Vector3 GetScale();
  
      public: void SetMaterial(const std::string &materialName);

      public: void SetAmbient(const common::Color &_color);

      public: void SetDiffuse(const common::Color &_color);

      public: void SetSpecular(const common::Color &_color);

      public: void AttachAxes();
  
      public: void SetTransparency( float trans );
  
      public: float GetTransparency();

      public: void SetEmissive( const common::Color &_color );

      public: void SetCastShadows(const bool &shadows);
  
      public: void SetVisible(bool visible, bool cascade=true);
  
      public: void ToggleVisible();
  
      public: bool GetVisible() const;
  
      public: void SetPosition( const math::Vector3 &pos);
  
      public: void SetRotation( const math::Quaternion &rot);
  
      public: void SetPose( const math::Pose &pose);
  
      public: math::Vector3 GetPosition() const;
  
      public: math::Quaternion GetRotation() const;
  
      public: math::Pose GetPose() const;
  
      public: math::Pose GetWorldPose() const;
 
      public: void SetWorldPose(const math::Pose _pose);
      public: void SetWorldPosition(const math::Vector3 &_pos);
      public: void SetWorldRotation(const math::Quaternion &_q);

      public: Ogre::SceneNode *GetSceneNode() const;
  
      public: void MakeStatic();
  
      public: bool IsStatic() const;
  
      public: void EnableTrackVisual( Visual *vis );
  
      public: void DisableTrackVisual();
  
      public: std::string GetNormalMap() const;
  
      public: void SetNormalMap(const std::string &nmap);
  
      public: void SetRibbonTrail(bool value);
  
      public: math::Box GetBoundingBox() 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: static void InsertMesh( const common::Mesh *mesh);
  
      public: void UpdateFromMsg(const boost::shared_ptr< msgs::Visual const> &msg);

      public: bool IsPlane() const;

      public: VisualPtr GetParent() const;

      public: std::string GetShaderType() const;

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

      public: void MoveToPosition( const math::Vector3 &_end, 
                                   double _pitch, double _yaw, double _time);

      public: void ShowBoundingBox();
      public: void ShowCollision(bool _show);

      public: void SetScene(Scene *_scene);
      public: Scene *GetScene() const;

      private: void GetBoundsHelper(Ogre::SceneNode *node,
                                    math::Box &box) const;

      private: std::string GetMeshName() const;
  
      public: void ClearParent();

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

      private: sdf::ElementPtr sdf;

      private: std::string myMaterialName;
      private: std::string origMaterialName;
  
      protected: Ogre::SceneNode *sceneNode;
  
      private: float transparency;
  
      private: static unsigned int visualCounter;
  
      private: bool isStatic;
      private: Ogre::StaticGeometry *staticGeom;
      private: bool visible;
  
      private: static SelectionObj *selectionObj;
  
      private: Ogre::RibbonTrail *ribbonTrail;
  
      private: event::ConnectionPtr preRenderConnection;
  
      // List of all the lines created
      private: std::list<DynamicLines*> lines;

      private: std::list< std::pair<DynamicLines*, unsigned int> > lineVertices;

      private: std::string name;
      private: std::string physicsEntityName;
      public: VisualPtr parent;
      public: std::vector<VisualPtr> children;

      protected: std::vector<common::Param*> parameters;

      private: Ogre::AnimationState *animState;
      protected: Scene *scene;
    };
  }

}
#endif