Actor.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_ACTOR_HH_
#define GAZEBO_PHYSICS_ACTOR_HH_
 
#include <string>
#include <map>
#include <memory>
#include <vector>
 
#include <ignition/math/Color.hh>
 
#include "gazebo/physics/Model.hh"
#include "gazebo/common/Time.hh"
#include "gazebo/common/Animation.hh"
#include "gazebo/util/system.hh"
 
namespace gazebo
{
  namespace common
  {
    class Mesh;
    class Skeleton;
  }
 
  namespace physics
  {
    class ActorPrivate;
 
    class GZ_PHYSICS_VISIBLE TrajectoryInfo
    {
      public: TrajectoryInfo();
 
      public: unsigned int id;
 
      public: std::string type;
 
      public: double duration;
 
      public: double startTime;
 
      public: double endTime;
 
      public: bool translated;
    };
 
 
    class GZ_PHYSICS_VISIBLE Actor : public Model
    {
      public: typedef std::map<std::string, common::SkeletonAnimation *>
              SkeletonAnimation_M;
 
      public: explicit Actor(BasePtr _parent);
 
      public: virtual ~Actor();
 
      public: void Load(sdf::ElementPtr _sdf);
 
      public: void AlignBvh(common::Skeleton *_skel,
          const std::map<std::string, std::string> &_skelMap);
 
      public: virtual void Init();
 
      public: virtual void Play();
 
      public: virtual void Stop();
 
      public: virtual bool IsActive() const;
 
      public: void Update();
 
      public: virtual void Fini();
 
      public: virtual void UpdateParameters(sdf::ElementPtr _sdf);
 
      public: virtual const sdf::ElementPtr GetSDF();
 
      public: void Reset();
      using Model::Reset;
 
      public: void SetScriptTime(const double _time);
 
      public: double ScriptTime() const;
 
      public: const SkeletonAnimation_M &SkeletonAnimations() const;
 
      public: void SetCustomTrajectory(TrajectoryInfoPtr &_trajInfo);
 
      public: const common::Mesh *Mesh() const;
 
      public: TrajectoryInfoPtr CustomTrajectory() const;
 
      public: void ResetCustomTrajectory();
 
      public: virtual bool GetSelfCollide() const;
 
      public: virtual void SetSelfCollide(bool _selfCollide);
 
      public: virtual bool WindMode() const;
 
      public: virtual void SetWindMode(const bool _enabled);
 
      private: void AddSphereInertia(const sdf::ElementPtr &_linkSdf,
                   const ignition::math::Pose3d &_pose,
                   const double _mass, const double _radius);
 
      private: void AddSphereCollision(const sdf::ElementPtr &_linkSdf,
                   const std::string &_name,
                   const ignition::math::Pose3d &_pose,
                   const double _radius);
 
      private: void AddBoxCollision(const sdf::ElementPtr &_linkSdf,
                   const std::string &_name,
                   const ignition::math::Pose3d &_pose,
                   const ignition::math::Vector3d &_size);
 
      private: void AddSphereVisual(const sdf::ElementPtr &_linkSdf,
                   const std::string &_name,
                   const ignition::math::Pose3d &_pose, const double _radius,
                   const std::string &_material,
                   const ignition::math::Color &_ambient);
 
      private: void AddBoxVisual(const sdf::ElementPtr &_linkSdf,
                   const std::string &_name,
                   const ignition::math::Pose3d &_pose,
                   const ignition::math::Vector3d &_size,
                   const std::string &_material,
                   const ignition::math::Color &_ambient);
 
      private: void AddActorVisual(const sdf::ElementPtr &_linkSdf,
                   const std::string &_name,
                   const ignition::math::Pose3d &_pose);
 
      private: bool LoadSkin(sdf::ElementPtr _sdf);
 
      private: void LoadAnimation(sdf::ElementPtr _sdf);
 
      private: void LoadScript(sdf::ElementPtr _sdf);
 
      private: void SetPose(
                   std::map<std::string, ignition::math::Matrix4d> _frame,
                   std::map<std::string, std::string> _skelMap,
                   const double _time);
 
      protected: const common::Mesh *mesh = nullptr;
 
      protected: common::Skeleton *skeleton = nullptr;
 
      protected: std::string skinFile;
 
      protected: double skinScale;
 
      protected: double startDelay;
 
      protected: double scriptLength;
 
      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: SkeletonAnimation_M skelAnimation;
 
      protected: std::map<std::string, std::map<std::string, std::string> >
                                                            skelNodesMap;
 
      // direction.
      protected: std::map<std::string, bool> interpolateX;
 
      protected: ignition::math::Vector3d lastPos;
 
      protected: double pathLength;
 
      protected: unsigned int lastTraj;
 
      protected: std::string visualName;
 
      protected: uint32_t visualId;
 
      protected: transport::PublisherPtr bonePosePub;
 
      private: double scriptTime;
 
      private: TrajectoryInfoPtr customTrajectoryInfo;
 
      private: std::unique_ptr<ActorPrivate> dataPtr;
    };
  }
}
#endif