include/cglib/vector3.h

Go to the documentation of this file.

/*
 * pbrt source code Copyright(c) 1998-2005 Matt Pharr and Greg Humphreys
 *
 * All Rights Reserved.
 * For educational use only; commercial use expressly forbidden.
 * NO WARRANTY, express or implied, for this software.
 * (See file License.txt for complete license)
 */

#ifndef _VECTOR3_H_
#define _VECTOR3_H_

#include "cglib/definitions.h"

struct Point3;

struct Vector3 
{
public:
    float x; 
    float y; 
    float z; 

    Vector3(): x(0), y(0), z(0) 
    {
    }
    
    Vector3(float c): x(c), y(c), z(c) 
    {
    }
    

    Vector3(float _x, float _y, float _z)
        : x(_x), y(_y), z(_z) 
    {
    }
    
    explicit Vector3(const Point3 &p);

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

    Vector3 operator-(const Vector3 &v) const 
    {
        return Vector3(x - v.x, y - v.y, z - v.z);
    }
    
    Vector3& operator-=(const Vector3 &v) 
    {
        x -= v.x; y -= v.y; z -= v.z;
        return *this;
    }
    
    bool operator==(const Vector3 &v) const 
    {
        return x == v.x && y == v.y && z == v.z;
    }
    
    Vector3 operator*(float f) const 
    {
        return Vector3(f*x, f*y, f*z);
    }
    
    Vector3 &operator*=(float f) 
    {
        x *= f; y *= f; z *= f;
        return *this;
    }
    
    Vector3 operator/(float f) const 
    {
        float inv = 1.f / f;
        return Vector3(x * inv, y * inv, z * inv);
    }
    
    Vector3 &operator/=(float f) 
    {
        float inv = 1.f / f;
        x *= inv; y *= inv; z *= inv;
        return *this;
    }
    
    Vector3 operator-() const 
    {
        return Vector3(-x, -y, -z);
    }
    

    float operator[](int i) const 
    {
        return (&x)[i];
    }
    
    bool operator!=(const Vector3 &other) const
    {
        return !(*this == other);
    }
    

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

    void fill_array_3(float *a)
    {
        a[0] = x;
        a[1] = y;
        a[2] = z;
    }
    

    void fill_array_4(float *a)
    {
        a[0] = x;
        a[1] = y;
        a[2] = z;
        a[3] = 0.0f;
    }
    
    float length_squared() const 
    { 
        return x*x + y*y + z*z; 
    }
    
    float length() const 
    { 
        return sqrtf(x*x + y*y + z*z); 
    }


    bool is_near(const Vector3 &other, float threshold=EPSILON) const
    {
        float absx = fabs(x-other.x);
        float absy = fabs(y-other.y);
        float absz = fabs(z-other.z);
        return (absx < EPSILON && absy < EPSILON && absz < EPSILON);
    }
};  

inline Vector3 operator*(float f, const Vector3 &v) 
{
    return v*f;
}

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

inline float absdot(const Vector3 &v1, const Vector3 &v2) 
{
    return fabsf(dot(v1, v2));
}

inline Vector3 cross(const Vector3 &v1, const Vector3 &v2) 
{
    return Vector3((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 Vector3 normalize(const Vector3 &v) 
{
    return v / v.length();
}

#endif /* _VECTOR3_H_ */

---