D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/SceneGraph/Animation/spAnimationJoint.hpp

Go to the documentation of this file.

/*
 * Animation bone header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_ANIMATION_BONE_H__
#define __SP_ANIMATION_BONE_H__


#include "Base/spStandard.hpp"
#include "Base/spInputOutputString.hpp"
#include "Base/spDimension.hpp"
#include "Base/spMemoryManagement.hpp"
#include "SceneGraph/spSceneMesh.hpp"
#include "Base/spTransformation3D.hpp"
#include "SceneGraph/Animation/spAnimationBaseStructures.hpp"

#include <vector>


namespace sp
{
namespace scene
{


class AnimationSkeleton;


class SP_EXPORT AnimationJoint : public BaseObject
{
    
    public:
        
        AnimationJoint(
            const Transformation &OriginTransform, const io::stringc Name = ""
        );
        virtual ~AnimationJoint();
        
        /* === Functions === */
        
        virtual dim::matrix4f getGlobalTransformation() const;
        virtual dim::matrix4f getVertexTransformation() const;
        
        /* === Inline functions === */
        
        inline void setEnable(bool Enable) // !TODO! -> RENAME this to "setAutoTransform"
        {
            isEnable_ = Enable;
        }
        inline bool getEnable() const
        {
            return isEnable_;
        }
        
        inline AnimationJoint* getParent() const
        {
            return Parent_;
        }
        
        inline void setVertexGroups(const std::vector<SVertexGroup> &VertexGroups)
        {
            VertexGroups_ = VertexGroups;
        }
        
        inline const std::vector<SVertexGroup>& getVertexGroups() const
        {
            return VertexGroups_;
        }
        inline std::vector<SVertexGroup>& getVertexGroups()
        {
            return VertexGroups_;
        }
        
        inline void setOriginTransformation(const Transformation &Transform)
        {
            OriginTransform_ = Transform;
        }
        inline Transformation getOriginTransformation() const
        {
            return OriginTransform_;
        }
        
        inline void setTransformation(const Transformation &Transform)
        {
            Transform_ = Transform;
        }
        inline const Transformation& getTransformation() const
        {
            return Transform_;
        }
        inline Transformation& getTransformation()
        {
            return Transform_;
        }
        
        inline dim::matrix4f getOriginMatrix() const
        {
            return OriginMatrix_;
        }
        
        inline const std::vector<AnimationJoint*>& getChildren() const
        {
            return Children_;
        }
        
    protected:
        
        friend class AnimationSkeleton;
        
        /* === Functions === */
        
        void transformVertices(scene::Mesh* MeshObj, dim::matrix4f BaseMatrix, bool useTangentSpace) const;
        
        bool checkParentIncest(AnimationJoint* Joint) const;
        
        /* === Inline functions === */
        
        inline void setParent(AnimationJoint* Parent)
        {
            Parent_ = Parent;
        }
        
        inline void addChild(AnimationJoint* Child)
        {
            Children_.push_back(Child);
        }
        inline void removeChild(AnimationJoint* Child)
        {
            MemoryManager::removeElement(Children_, Child);
        }
        
    private:
        
        /* === Members === */
        
        bool isEnable_;
        
        AnimationJoint* Parent_;
        std::vector<AnimationJoint*> Children_;
        
        Transformation OriginTransform_;    
        Transformation Transform_;          
        
        dim::matrix4f OriginMatrix_;        
        
        std::vector<SVertexGroup> VertexGroups_;
        
};


} // /namespace scene

} // /namespace sp


#endif



// ================================================================================