Transform.h

Go to the documentation of this file.

// Honeycomb, Copyright (C) 2015 NewGamePlus Inc.  Distributed under the Boost Software License v1.0.
#pragma once

#include "Honey/Math/Alge/Matrix/Matrix4.h"
#include "Honey/Math/Alge/Quat.h"

namespace honey
{


template<class Real>
class Transform_
{
protected:
    typedef Vec<2,Real>         Vec2;
    typedef Vec<3,Real>         Vec3;
    typedef Vec<4,Real>         Vec4;
    typedef Matrix<4,4,Real>    Matrix4;
    typedef Quat_<Real>         Quat;

public:
    Transform_()                                                        { fromIdentity(); }

    Transform_( const Vec3& trans,              const Quat& rot = Quat::identity,
                const Vec3& scale = Vec3::one,  const Quat& skew = Quat::identity)
                                                                        { fromTrs(trans, rot, scale, skew); }

    explicit Transform_(const Matrix4& mat)                             { fromMatrix(mat); }

    ~Transform_()                                                       {}

    Transform_& fromIdentity()
    {
        resetTrans();
        resetRot();
        resetScale();
        return *this;
    }

    Transform_& fromTrs( const Vec3& trans,              const Quat& rot = Quat::identity,
                         const Vec3& scale = Vec3::one,  const Quat& skew = Quat::identity)
    {
        setTrans(trans);
        setRot(rot);
        setScale(scale, skew);
        return *this;
    }

    Transform_& fromMatrix(const Matrix4& mat)
    {
        mat.decompose(_trans, _rot, _scale, _skew);
        return fromTrs(_trans, _rot, _scale, _skew);
    }

    Transform_& operator=(const Transform_& rhs)
    {
        _trans = rhs._trans;
        _rot = rhs._rot;
        _scale = rhs._scale;
        _skew = rhs._skew;
        _bTrans = rhs._bTrans;
        _bRot = rhs._bRot;
        _bScale = rhs._bScale;
        _bUniformScale = rhs._bUniformScale;
        _bSkew = rhs._bSkew;
        onTmChange();
        return *this;
    }

    Transform_ operator*(const Transform_& tm) const;
    
    Vec3 operator*(const Vec3& v) const
    {
        Vec3 ret = v;
        if (_bScale)
            ret = _bSkew ? _skew * (_skew.inverse()*ret).elemMul(_scale) : ret.elemMul(_scale);
        if (_bRot)
            ret = _rot * ret;
        ret += _trans;
        return ret;
    }

    Vec4 operator*(const Vec4& v) const                                 { return Vec4(operator*(Vec3(v)), v.w); }
    Vec2 operator*(const Vec2& v) const                                 { return Vec2(operator*(Vec3(v))); }

    Transform_& operator*=(const Transform_& tm)                        { return *this = operator*(tm); }

    Vec3 mulRotScale(const Vec3& v) const
    {
        Vec3 ret = v;
        if (_bScale)
            ret = _bSkew ? _skew * (_skew.inverse()*ret).elemMul(_scale) : ret.elemMul(_scale);
        if (_bRot)
            ret = _rot * ret;
        return ret;
    }

    bool operator == (const Transform_& rhs) const                      { return _trans == rhs._trans && _rot == rhs._rot && _scale == rhs._scale; }
    bool operator != (const Transform_& rhs) const                      { return !operator==(rhs); }

    Transform_ inverse() const;

    void resetTrans()                                                   { setTrans(Vec3::zero); }
    void resetRot()                                                     { setRot(Quat::identity); }
    void resetScale()                                                   { setScale(Vec3::one); }

    void setTrans(const Vec3& trans)
    {
        _trans = trans;
        _bTrans = _trans != Vec3::zero;
        onTmChange();
    }

    const Vec3& getTrans() const                                        { return _trans; }

    void setRot(const Quat& rot)
    {
        _rot = rot;
        _bRot = _rot != Quat::identity;
        onTmChange();
    }

    const Quat& getRot() const                                          { return _rot; }
    
    void setScale(const Vec3& scale, const Quat& skew = Quat::identity)
    {
        _skew = skew;
        _bSkew = _skew != Quat::identity;
        _scale = scale;
        _bScale = _scale != Vec3::one || _bSkew;
        _bUniformScale = _scale.x == _scale.y && _scale.x == _scale.z && !_bSkew;
        onTmChange();
    }

    void setScale(Real f)                                               { setScale(Vec3(f)); }

    const Vec3& getScale() const                                        { return _scale; }
    const Quat& getSkew() const                                         { return _skew; }

    void getTrs(optional<Vec3&> trans = optnull, optional<Quat&> rot = optnull,
                optional<Vec3&> scale = optnull, optional<Quat&> skew = optnull) const
    {
        if (trans) trans = _trans;
        if (rot) rot = _rot;
        if (scale) scale = _scale;
        if (skew) skew = _skew;
    }

    Transform_& translate(const Vec3& v)                                { Transform_ tm; tm.setTrans(v); return *this = tm * *this; }
    Transform_& preTranslate(const Vec3& v)                             { Transform_ tm; tm.setTrans(v); return operator*=(tm);  }

    Transform_& rotate(const Quat& q)                                   { Transform_ tm; tm.setRot(q); return *this = tm * *this; }
    Transform_& preRotate(const Quat& q)                                { Transform_ tm; tm.setRot(q); return operator*=(tm); }

    Transform_& scale(const Vec3& v, const Quat& skew = Quat::identity) { Transform_ tm; tm.setScale(v, skew); return *this = tm * *this; }
    Transform_& scale(Real f)                                           { return scale(Vec3(f)); }

    Transform_& preScale(const Vec3& v, const Quat& skew = Quat::identity)  { Transform_ tm; tm.setScale(v, skew); return operator*=(tm); }
    Transform_& preScale(Real f)                                        { return preScale(Vec3(f)); }

    bool isIdentity() const                                             { return !_bTrans && !_bRot && !_bScale; }
    bool hasTrans() const                                               { return _bTrans; }
    bool hasRot() const                                                 { return _bRot; }
    bool hasScale() const                                               { return _bScale; }
    bool hasUniformScale() const                                        { return _bUniformScale; }
    bool hasSkew() const                                                { return _bSkew; }

    friend ostream& operator<<(ostream& os, const Transform_& tm)
    {
        return os << "{ "   << "trans: " << tm._trans << ", rot: " << tm._rot
                            << ", scale: " << tm._scale << ", skew: " << tm._skew << " }";
    }

protected:
    virtual void onTmChange()                                           {}

private:
    Transform_(mt::tag<0>)                                              {}

    Vec3                _trans;
    Quat                _rot;
    Vec3                _scale;
    Quat                _skew;

    bool                _bTrans;
    bool                _bRot;
    bool                _bScale;
    bool                _bUniformScale;
    bool                _bSkew;

public:
    static const Transform_ identity;
};

template<class Real> const Transform_<Real> Transform_<Real>::identity;

typedef Transform_<Real>   Transform;
typedef Transform_<Float>  Transform_f;
typedef Transform_<Double> Transform_d;

extern template class Transform_<Float>;
extern template class Transform_<Double>;

}