quaternion.hpp

Go to the documentation of this file.

/*
    RenderStack  Support library for OpenGL 3+
    Copyright (C) 2010  Timo Suoranta

    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
*/

#ifndef QUATERNION_HPP
#define QUATERNION_HPP

#include "renderstack/rs.h"
#include "renderstack/vec3.hpp"

namespace renderstack {

class matrix;

class quaternion 
{
public:
    quaternion()
    :   x(0.0f)
    ,   y(0.0f)
    ,   z(0.0f)
    ,   w(1.0f)
    {
    }
    quaternion(float x_, float y_, float z_, float w_)
    :   x(x_)
    ,   y(y_)
    ,   z(z_)
    ,   w(w_)
    {
    }
    quaternion(quaternion const &other)
    :   x(other.x)
    ,   y(other.y)
    ,   z(other.z)
    ,   w(other.w)
    {
    }
    explicit quaternion(matrix const &m);
    quaternion(vec3 const &axis, float half_a_sin, float half_a_cos)
    :   x(axis.x * half_a_sin)
    ,   y(axis.y * half_a_sin)
    ,   z(axis.z * half_a_sin)
    ,   w(half_a_cos)
    {
    }

    vec3 hpb        () const;
    vec3 view_axis  () const;
    vec3 up_axis    () const;
    vec3 right_axis () const;

    quaternion operator*    (quaternion const &other) const;
    quaternion &operator*=  (quaternion const &other) { return *this = *this * other; }

public:
    float x;
    float y;
    float z;
    float w;
};

inline quaternion normalize(quaternion const &q)
{
    float dot   = q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w;
    float t     = 1.5f - 0.5f * dot;
    return quaternion(q.x * t, q.y * t, q.z * t, q.w * t);
}

}

#endif