Actor.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2012-2014 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 _ACTOR_HH_
#define _ACTOR_HH_

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

#include "gazebo/physics/Model.hh"
#include "gazebo/common/Time.hh"
#include "gazebo/common/Skeleton.hh"
#include "gazebo/common/Animation.hh"

namespace gazebo
{
  namespace common
  {
    class Mesh;
    class Color;
  }

  namespace physics
  {
    struct TrajectoryInfo
    {
      unsigned int id;
      std::string type;
      double duration;
      double startTime;
      double endTime;
      bool translated;
    };


    class Actor : public Model
    {
      public: explicit Actor(BasePtr _parent);

      public: virtual ~Actor();

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

      public: virtual void Init();

      public: virtual void Play();

      public: virtual void Stop();

      public: virtual bool IsActive();

      public: void Update();

      public: virtual void Fini();

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

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

      private: void AddSphereInertia(sdf::ElementPtr _linkSdf,
                                     const math::Pose &_pose,
                                     double _mass, double _radius);

      private: void AddSphereCollision(sdf::ElementPtr _linkSdf,
                                       const std::string &_name,
                                       const math::Pose &_pose,
                                       double _radius);

      private: void AddSphereVisual(sdf::ElementPtr _linkSdf,
                                    const std::string &_name,
                                    const math::Pose &_pose,
                                    double _radius,
                                    const std::string &_material,
                                    const common::Color &_ambient);

      private: void AddBoxVisual(sdf::ElementPtr _linkSdf,
                                 const std::string &_name,
                                 const math::Pose &_pose,
                                 const math::Vector3 &_size,
                                 const std::string &_material,
                                 const common::Color &_ambient);

      private: void AddActorVisual(sdf::ElementPtr _linkSdf,
                                   const std::string &_name,
                                   const math::Pose &_pose);

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

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

      private: void SetPose(std::map<std::string, math::Matrix4> _frame,
                     std::map<std::string, std::string> _skelMap, double _time);

      protected: const common::Mesh *mesh;

      protected: common::Skeleton *skeleton;

      protected: std::string skinFile;

      protected: double skinScale;

      protected: double startDelay;

      protected: double scriptLength;

      protected: double lastScriptTime;

      protected: bool loop;

      protected: bool active;

      protected: bool autoStart;

      protected: LinkPtr mainLink;

      protected: common::Time prevFrameTime;

      protected: common::Time playStartTime;

      protected: std::map<unsigned int, common::PoseAnimation*> trajectories;

      protected: std::vector<TrajectoryInfo> trajInfo;

      protected: std::map<std::string, common::SkeletonAnimation*>
                                                            skelAnimation;

      protected: std::map<std::string, std::map<std::string, std::string> >
                                                            skelNodesMap;

      protected: std::map<std::string, bool> interpolateX;

      protected: math::Vector3 lastPos;

      protected: double pathLength;

      protected: unsigned int lastTraj;

      protected: std::string visualName;

      protected: uint32_t visualId;

      protected: transport::PublisherPtr bonePosePub;

      protected: std::string oldAction;
    };
  }
}
#endif