vec4.hpp

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 VEC4_HPP
#define VEC4_HPP

#include <cmath>

namespace renderstack {

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

    vec4(vec3 const &v3, float _w = 0)
    :   x(v3.x)
    ,   y(v3.y)
    ,   z(v3.z)
    ,   w(_w)
    {
    }

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

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

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

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

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

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

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

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

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

    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 + w * w; }
    float length() const { return std::sqrt(length_squared()); }

    float x;
    float y;
    float z;
    float w;
};

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

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

inline vec3 homogenize(vec4 const &v)
{
    return vec3(v.x / v.w, v.y / v.w, v.z / v.w);
}

inline vec4 cross(vec4 const &r, vec4 const &s, vec4 const &t)
{
    return vec4(
        r.y * s.z * t.w + r.z * s.w * t.y + r.w * s.y * t.z - r.y * s.w * t.z - r.z * s.y * t.w - r.w * s.z * t.y,
        r.x * s.w * t.z + r.z * s.x * t.w + r.w * s.z * t.x - r.x * s.z * t.w - r.z * s.w * t.x - r.w * s.x * t.z,
        r.x * s.y * t.w + r.y * s.w * t.x + r.w * s.x * t.y - r.x * s.w * t.y - r.y * s.x * t.w - r.w * s.y * t.x,
        r.x * s.z * t.y + r.y * s.x * t.z + r.z * s.y * t.x - r.x * s.y * t.z - r.y * s.z * t.x - r.z * s.x * t.y
    );
}

} 

#endif