vec3.h

Go to the documentation of this file.

/*
    mesh3d
    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 MESH3D__VEC3__H
#define MESH3D__VEC3__H

#include <cmath>

namespace mesh3d {

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();
}

} 

#endif