quaternion.h

Go to the documentation of this file.

/*****************************************************************************
* Copyright (c) 2001 - 2008 Marcus Boerger.  All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
* ========================================================================= */

/* ------------------------------------------------------------------------ */
/* ------------------------------------------------------------------------ */

#pragma once

#ifndef _QUATERNION_H_
#define _QUATERNION_H_

#include "triplet.h"

namespace mbo
{

/****************************************************************************/

template<typename _Ty1, typename _Ty2, typename _Ty3, typename _Ty4>
struct quaternion: public triplet<_Ty1, _Ty2, _Ty3>
{
    typedef triplet<_Ty1, _Ty2, _Ty3>     _Mybase;
    typedef quaternion<_Ty1, _Ty2, _Ty3, _Ty4> _Myt;
    typedef _Ty4 forth_type;

    quaternion()
        : _Mybase()
        , forth()
    {
    }

    quaternion(const _Ty1& val1, const _Ty2& val2, const _Ty3& val3, const _Ty4& val4)
        : _Mybase(val1, val2, val3)
        , forth(val4)
    {
    }

    template<typename _O1, typename _O2, typename _O3, typename _O4>
    quaternion(const quaternion<_O1, _O2, _O3, _O4>& rhs)
        : _Mybase(rhs.first, rhs.second, rhs.third)
        , forth(rhs.forth)
    {
    }

    void swap(_Myt& rhs)
    {
        std::swap(first,  rhs.first);
        std::swap(second, rhs.second);
        std::swap(third,  rhs.third);
        std::swap(forth,  rhs.forth);
    }

    forth_type   forth;
};

template<typename _Ty1, typename _Ty2, typename _Ty3, typename _Ty4>
inline bool __cdecl operator == (const quaternion<_Ty1, _Ty2, _Ty3, _Ty4>& lhs, const quaternion<_Ty1, _Ty2, _Ty3, _Ty4>& rhs)
{
    return (lhs.first == rhs.first && lsh.second == rhs.second && lsh.third == rhs.third && lsh.forth == rhs.forth);
}

template<typename _Ty1, typename _Ty2, typename _Ty3, typename _Ty4>
inline bool __cdecl operator != (const quaternion<_Ty1, _Ty2, _Ty3, _Ty4>& lhs, const quaternion<_Ty1, _Ty2, _Ty3, _Ty4>& rhs)
{
    return (!(lhs == rhs));
}

template<typename _Ty1, typename _Ty2, typename _Ty3, typename _Ty4>
inline bool __cdecl operator < (const quaternion<_Ty1, _Ty2, _Ty3, _Ty4>& lhs, const quaternion<_Ty1, _Ty2, _Ty3, _Ty4>& rhs)
{
    return lhs::pair < rhs::pair  ||
        (!(rhs.first < lhs.first) && lhs.second < rhs.second) ||
        (!(rhs.first < lhs.first) && !(rhs.second < lhs.second) && lhs.third < rhs.third) ||
        (!(rhs.first < lhs.first) && !(rhs.second < lhs.second) && !(rhs.third < lhs.third) && lhs.forth < rhs.forth)
        ;
}

template<typename _Ty1, typename _Ty2, typename _Ty3, typename _Ty4>
inline bool __cdecl operator > (const quaternion<_Ty1, _Ty2, _Ty3, _Ty4>& lhs, const quaternion<_Ty1, _Ty2, _Ty3, _Ty4>& rhs)
{
    return (rhs < lhs);
}

template<typename _Ty1, typename _Ty2, typename _Ty3, typename _Ty4>
inline bool __cdecl operator <= (const quaternion<_Ty1, _Ty2, _Ty3, _Ty4>& lhs, const quaternion<_Ty1, _Ty2, _Ty3, _Ty4>& rhs)
{
    return (!(rhs < lhs));
}

template<typename _Ty1, typename _Ty2, typename _Ty3, typename _Ty4>
inline bool __cdecl operator >= (const quaternion<_Ty1, _Ty2, _Ty3, _Ty4>& lhs, const quaternion<_Ty1, _Ty2, _Ty3, _Ty4>& rhs)
{
    return (!(lhs < rhs));
}

template<typename _Ty1, typename _Ty2, typename _Ty3, typename _Ty4>
inline quaternion<_Ty1, _Ty2, _Ty3, _Ty4> __cdecl make_quaternion(_Ty1 val1, _Ty2 val2, _Ty3 val3, _Ty4 val4)
{
    return (quaternion<_Ty1, _Ty2, _Ty3, _Ty4>(val1, val2, val3, val4));
}

template<typename _Ty1, typename _Ty2, typename _Ty3, typename _Ty4>
inline void swap(quaternion<_Ty1, _Ty2, _Ty3, _Ty4>& lhs, quaternion<_Ty1, _Ty2, _Ty3, _Ty4>& rhs)
{
    lhs.swap(rhs);
}

} // namespace mbo

#endif // _QUATERNION_H_

---