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