Transform.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "AstMath/Rotation.hpp"
 
AST_NAMESPACE_BEGIN
 
 
class Transform
{
public:
 
    Transform() = default;
 
    Transform(const Vector3d& trans, const Rotation& rot);
 
    static Transform Identity();
 
    const Rotation& getRotation() const { return rotation_; }
    Rotation& getRotation() { return rotation_; }
 
    void setRotation(const Rotation& rotation) { rotation_ = rotation; }
 
    const Vector3d& getTranslation() const { return translation_; }
    Vector3d& getTranslation() { return translation_; }
 
    void setTranslation(const Vector3d& translation) { translation_ = translation; }
 
    const Matrix3d& getMatrix() const { return rotation_.getMatrix(); }
 
    Transform& compose(const Transform& next);
 
    Transform composed(const Transform& next) const;
 
    Transform operator*(const Transform& next) const;
 
    Transform& operator*=(const Transform& next);
 
    void getInverse(Transform& inversed) const;
 
    Transform inverse() const;
 
    void setIdentity() { rotation_ = Rotation::Identity(); translation_ = Vector3d::Zero(); }
 
    void transformPosition(const Vector3d& position, Vector3d& positionOut) const;
 
    Vector3d transformPosition(const Vector3d& position) const;
 
protected:
    Vector3d translation_;  
    Rotation rotation_;     
};
 
A_ALWAYS_INLINE Transform::Transform(const Vector3d &trans, const Rotation &rot)
    : translation_(trans), rotation_(rot)
{
}
 
A_ALWAYS_INLINE Transform Transform::Identity()
{
    return Transform(Vector3d::Zero(), Rotation::Identity());
}
 
A_ALWAYS_INLINE Transform &Transform::compose(const Transform &next)
{
    translation_ += next.getTranslation() * getMatrix();
    rotation_ = rotation_.composed(next.getRotation());
    return *this;
}
 
A_ALWAYS_INLINE Transform Transform::composed(const Transform &next) const
{
    return Transform(
        translation_ + next.getTranslation() * getMatrix(),
        rotation_.composed(next.getRotation())
    );
}
 
A_ALWAYS_INLINE Transform Transform::operator*(const Transform &next) const
{
    return this->composed(next);
}
 
A_ALWAYS_INLINE Transform &Transform::operator*=(const Transform &next)
{
    return this->compose(next);
}
 
A_ALWAYS_INLINE void Transform::getInverse(Transform &inversed) const
{
    rotation_.transformVector(-translation_, inversed.getTranslation());
    rotation_.getInverse(inversed.getRotation());
}
 
A_ALWAYS_INLINE Transform Transform::inverse() const
{
    Transform retval;
    this->getInverse(retval);
    return retval;
}
 
A_ALWAYS_INLINE void Transform::transformPosition(const Vector3d &position, Vector3d &positionOut) const
{
    rotation_.transformVector(position - translation_, positionOut);
}
 
A_ALWAYS_INLINE Vector3d Transform::transformPosition(const Vector3d &position) const
{
    Vector3d retval;
    this->transformPosition(position, retval);
    return retval;
}
 
AST_NAMESPACE_END