SkeletonComponent.hpp

#pragma once
 
#include <Core/Animation/HandleWeight.hpp>
#include <Core/Animation/KeyFramedValue.hpp>
#include <Core/Animation/Skeleton.hpp>
#include <Core/Asset/AnimationData.hpp>
#include <Core/Asset/HandleData.hpp>
 
#include <Engine/Scene/Component.hpp>
 
namespace Ra {
namespace Engine {
namespace Data {
class BlinnPhongMaterial;
class Mesh;
} // namespace Data
namespace Rendering {
class RenderObject;
class RenderTechnique;
} // namespace Rendering
 
namespace Scene {
 
class SkeletonBasedAnimationSystem;
 
class RA_ENGINE_API SkeletonComponent : public Component
{
  public:
    friend class SkeletonBasedAnimationSystem;
 
    using Animation = std::vector<Core::Animation::KeyFramedValue<Core::Transform>>;
 
    SkeletonComponent( const std::string& name, Entity* entity );
    ~SkeletonComponent() override;
    SkeletonComponent( const SkeletonComponent& )            = delete;
    SkeletonComponent& operator=( const SkeletonComponent& ) = delete;
 
 
    void initialize() override { setupIO(); }
 
    bool canEdit( const Core::Utils::Index& roIdx ) const override;
 
    Core::Transform getTransform( const Core::Utils::Index& roIdx ) const override;
    Core::Transform getBoneTransform( uint boneIdx,
                                      const Ra::Core::Animation::HandleArray::SpaceType MODE );
 
    void setTransform( const Core::Utils::Index& roIdx, const Core::Transform& transform ) override;
    void setBoneTransform( uint boneIdx,
                           const Core::Transform& transform,
                           const Ra::Core::Animation::HandleArray::SpaceType MODE );
 
 
    void handleSkeletonLoading( const Core::Asset::HandleData* data );
 
    void handleAnimationLoading( const std::vector<Core::Asset::AnimationData*>& data );
 
 
    inline const std::string& getSkelName() const { return m_skelName; }
 
    void setSkeleton( const Core::Animation::Skeleton& skel );
 
    inline const Core::Animation::Skeleton* getSkeleton() { return &m_skel; }
 
    inline size_t getAnimationCount() const { return m_animations.size(); }
 
    inline const Animation& getAnimation( const size_t i ) const { return m_animations[i]; }
 
    inline Animation& getAnimation( const size_t i ) { return m_animations[i]; }
 
    Animation& addNewAnimation();
 
    void removeAnimation( const size_t i );
 
    void useAnimation( const size_t i );
 
    size_t getAnimationId() const;
 
 
    void update( Scalar time );
 
    Scalar getAnimationTime() const;
 
    std::pair<Scalar, Scalar> getAnimationTimeInterval() const;
 
    void setSpeed( const Scalar value );
 
    Scalar getSpeed() const;
 
    void autoRepeat( const bool status );
 
    bool isAutoRepeat() const;
 
    void pingPong( const bool status );
 
    bool isPingPong() const;
 
 
    void setXray( bool on ) const;
 
    bool isXray() const;
 
    void toggleSkeleton( const bool status );
 
    bool isShowingSkeleton() const;
 
    const std::map<Core::Utils::Index, uint>* getBoneRO2idx() const;
 
    void updateDisplay();
 
    void setManipulationScheme( const Core::Animation::Skeleton::Manipulation& scheme );
 
    Core::Animation::Skeleton::Manipulation getManipulationScheme();
 
  private:
    void setupSkeletonDisplay();
 
    void printSkeleton( const Core::Animation::Skeleton& skeleton );
 
 
    void setupIO();
 
    const Core::Animation::RefPose* getRefPoseOutput() const;
 
    const Animation* getAnimationOutput() const;
 
    const Scalar* getTimeOutput() const;
 
    const bool* getWasReset() const;
 
  private:
    std::string m_skelName;
 
    Core::Animation::Skeleton m_skel;
 
    Core::Animation::RefPose m_refPose;
 
    std::vector<Animation> m_animations;
 
    size_t m_animationID { 0 };
 
    Scalar m_animationTime { 0_ra };
 
    Scalar m_speed { 1_ra };
 
    bool m_autoRepeat { false };
 
    bool m_pingPong { false };
 
    bool m_wasReset { false };
 
    std::vector<Rendering::RenderObject*> m_boneDrawables;
 
    std::map<Core::Utils::Index, uint> m_boneMap;
 
    static std::shared_ptr<Data::Mesh> s_boneMesh;
 
    static std::shared_ptr<Data::BlinnPhongMaterial> s_boneMaterial;
 
    static std::shared_ptr<Rendering::RenderTechnique> s_boneRenderTechnique;
};
 
} // namespace Scene
} // namespace Engine
} // namespace Ra