Quaternion.h

Go to the documentation of this file.

/*
 * Copyright 2015 Jaroslaw Glowacki
 * jarek (dot) glowacki (at) gmail (dot) com
 *
 * This file is part of algebra3d.
 *
 * algebra3d is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * algebra3d 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with algebra3d.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef _QUATERNION_H_
#define _QUATERNION_H_

#include<algebra3d/global.h>

namespace algebra3d {

/* Forward declarations */
template<class fpType>
class Matrix3;
template<class fpType>
class Vector3;

template<class fpType>
class Quaternion {
    // Friendship declarations
    template<class fpT>
    friend std::istream& operator>>(std::istream &stream,
            Quaternion<fpT> &quat);

protected:
    fpType data[4];

public:
    fpType &x;
    fpType &y;
    fpType &z;
    fpType &w;

public:
    Quaternion();

    Quaternion(const fpType(&data)[4]);

    Quaternion(fpType x, fpType y, fpType z, fpType w);

    Quaternion(const Quaternion<fpType> &quat);

    Quaternion(const Vector3<fpType> &vec);

    Quaternion(Vector3<fpType> axis, fpType angle);

    Quaternion(const Matrix3<fpType> &mat);

    virtual ~Quaternion();

    virtual void set(const fpType *data);

    virtual void set(const Matrix3<fpType> &mat);

    virtual void get(fpType *storage) const;

    virtual fpType getAngle() const;

    virtual Vector3<fpType> getAxis() const;

    virtual fpType getNorm() const;

    virtual void normalize();

    virtual bool isUnit() const;

    virtual Quaternion<fpType> getSqrtRotation() const;

    virtual Quaternion<fpType> getSqrtRotationTowards(
            const Quaternion<fpType> &quat) const;

    virtual void operator=(const Quaternion<fpType> &quat);

    virtual const fpType &operator[](int ind) const;

    virtual fpType &operator[](int ind);

    virtual bool compareRotations(const Quaternion<fpType> &quat,
            fpType precision = PRECISION) const;

    virtual bool compare(const Quaternion<fpType> &quat,
            const fpType &precision = PRECISION) const;

    virtual bool operator==(const Quaternion<fpType> &quat) const;

    virtual bool operator!=(const Quaternion<fpType> &quat) const;

    virtual Quaternion<fpType> inv() const;

    virtual void operator*=(const Quaternion<fpType> &quat);

    virtual Quaternion<fpType> operator*(const Quaternion<fpType> &quat) const;

    virtual void scaleAngle(const fpType &mult);

    virtual Quaternion<fpType> getScaledAngleRotation(const fpType &mult) const;

    virtual Vector3<fpType> operator*(const Vector3<fpType> &vec) const;
};

template<class fpType>
std::ostream& operator<<(std::ostream &stream, const Quaternion<fpType> &quat);

template<class fpType>
std::istream& operator>>(std::istream &stream, Quaternion<fpType> &quat);

typedef Quaternion<double> QuaternionD;

typedef Quaternion<float> QuaternionF;

}  /* namespace algebra3d */

#endif // _QUATERNION_H_