vec3.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 VEC3_HPP
#define VEC3_HPP

#include <cmath>

namespace renderstack {

class vec3
{
public:
    vec3(float _x = 0, float _y = 0, float _z = 0)
    :   x(_x)
    ,   y(_y)
    ,   z(_z)
    {
    }

    vec3 operator+(vec3 const &v) const 
    {
        return vec3(x + v.x, y + v.y, z + v.z);
    }

    vec3 &operator+=(vec3 const &v)
    {
        x += v.x;
        y += v.y;
        z += v.z;
        return *this;
    }

    vec3 operator-(vec3 const &v) const
    {
        return vec3(x - v.x, y - v.y, z - v.z);
    }

    vec3 &operator-=(vec3 const &v) 
    {
        x -= v.x;
        y -= v.y;
        z -= v.z;
        return *this;
    }

    bool operator==(vec3 const &v) const
    {
        return 
            (x == v.x) && 
            (y == v.y) && 
            (z == v.z);
    }
    vec3 operator*(float f) const
    {
        return vec3(f * x, f * y, f * z);
    }

    vec3 &operator*=(float f) 
    {
        x *= f;
        y *= f;
        z *= f;
        return *this;
    }

    vec3 operator/(float f) const
    {
        float inv = 1.0f / f;
        return vec3(x * inv, y * inv, z * inv);
    }

    vec3 &operator/=(float f)
    {
        float inv = 1.f / f;
        x *= inv; 
        y *= inv; 
        z *= inv;
        return *this;
    }

    vec3 operator-() const 
    {
        return vec3(-x, -y, -z);
    }

    float operator[](int i) const 
    {
        return (&x)[i];
    }

    float &operator[](int i)
    {
        return (&x)[i];
    }

    float length_squared() const { return x * x + y * y + z * z; }
    float length() const { return std::sqrt(length_squared()); }

    float x;
    float y;
    float z;
};

inline float dot(vec3 const &v1, vec3 const &v2)
{
    return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
}

inline vec3 cross(vec3 const &v1, vec3 const &v2)
{
    return vec3(
        (v1.y * v2.z) - (v1.z * v2.y),
        (v1.z * v2.x) - (v1.x * v2.z),
        (v1.x * v2.y) - (v1.y * v2.x)
    );
}

inline vec3 normalize(vec3 const &v)
{
    return v / v.length();
}

inline float radian_mod_2pi(float angle_radians)
{
    while(angle_radians > RS_TWO_PI) angle_radians -= RS_TWO_PI;
    while(angle_radians < 0        ) angle_radians += RS_TWO_PI;

    return angle_radians;
}

inline vec3 hpb_mod_2pi(vec3 const &hpb)
{
    float h = hpb.x;
    float p = hpb.y;
    float b = hpb.z;

    while(h > RS_TWO_PI) h -= RS_TWO_PI;
    while(h < 0        ) h += RS_TWO_PI;
    while(p > RS_TWO_PI) p -= RS_TWO_PI;
    while(p < 0        ) p += RS_TWO_PI;
    while(b > RS_TWO_PI) b -= RS_TWO_PI;
    while(b < 0        ) b += RS_TWO_PI;

    return vec3(h, p, b);
}

} 

#endif