Pose.h

#pragma once
// ===========================================================================
// Copyright (c) 2015 Toolchefs Ltd. All rights reserved.
//
// Use of this software is subject to the terms of the Toolchefs license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
 
#include <AtomsCore/Globals.h>
#include <AtomsCore/AtomsMath.h>
#include <AtomsCore/JointPose.h>
#include <AtomsCore/Metadata/MapMetadata.h>
#include <AtomsCore/Serialiser.h>
#include <string>
#include <vector>
#include <map>
 
namespace AtomsCore
{
    class Pose; 
 
    typedef Pose*  PosePtr; 
 
    typedef const Pose * PoseCPtr; 
 
 
    class ATOMSCORE_EXPORT Pose
    {
    public:
 
        typedef std::map<unsigned short, MapMetadata> JointMetadataMap;
 
        Pose();
 
 
        Pose(const Skeleton* skeleton, bool inParentSpace = false);
 
        Pose(const Pose& rhs);
 
        ~Pose();
 
        Pose& operator=(const Pose& rhs);
 
 
        void setNumberJoints(unsigned short n);
 
 
        inline unsigned short numJoints() const;
 
 
        inline JointPose& jointPose(unsigned short index);
 
 
        inline const JointPose& jointPose(unsigned short index) const;
 
 
        inline void setJointPose(unsigned short index, const JointPose& jointPose);
 
        inline void clearAllPose();
 
 
        inline void setDirection(const AtomsCore::Vector3& direction);
 
 
        inline const AtomsCore::Vector3& getDirection() const;
 
 
        bool jointHasMetadata(unsigned short index) const;
 
 
        inline JointMetadataMap& jointsMetadata();
 
 
        inline const JointMetadataMap& jointsMetadata() const;
 
 
        inline MapMetadata& jointMetadata(unsigned short index);
 
 
        const MapMetadata& jointMetadata(unsigned short index) const;
 
 
        inline void setJointMetadata(unsigned short index, const MapMetadata& data);
 
 
        inline void addJointMetadata(unsigned short index, const std::string& key, Metadata *data);
 
 
        inline void addJointMetadata(unsigned short index, const std::string& key, const AtomsPtr<Metadata> data);
        
 
        void clearJointMetadata(unsigned short index);
 
 
        inline MapMetadata& poseMetadata();
 
 
        inline const MapMetadata& poseMetadata() const;
 
 
        inline void addPoseMetadata(const std::string& key, Metadata *data);
 
        inline void clearPoseMetadata();
 
        inline void clearJointsMetadata();
 
        size_t memSize() const;
 
        std::vector<unsigned short> jointMetadataIds() const;
 
 
        size_t hash(short roundBits = 10) const;
 
        void resetActiveJoints();
 
        void setActiveJoints(const std::vector<short>& flags);
 
        void setActiveJoint(size_t index, bool value);
 
        bool isJointActive(size_t index) const;
 
        inline void setInParentSpace(bool flag);
 
        inline bool inParentSpace() const;
 
        void convertToParentSpace(const Skeleton* skeleton);
 
        void convertToLocalSpace(const Skeleton* skeleton);
 
    private:
 
        std::vector<JointPose> m_jointPose;
 
        MapMetadata m_poseMetadata;
 
        JointMetadataMap m_jointMetadata;
 
        AtomsCore::Vector3 m_direction;
 
        std::vector<short> m_activeJoints;
 
        bool m_inParentSpace;
    };
}
 
namespace AtomsCore
{
    ATOMSCORE_EXPORT AtomsCore::Archive& operator<<(AtomsCore::Archive& os, const AtomsCore::Pose& pose);
 
    ATOMSCORE_EXPORT AtomsCore::Archive& operator >> (AtomsCore::Archive& is, AtomsCore::Pose& pose);
}
#include "Pose.impl.h"