RTVolumeRendering/Source/Vector3.h

Go to the documentation of this file.

#ifndef VECTOR3_H
#define VECTOR3_H

#include <cmath>

template<class T>
class Vector3
{
public:
        T x, y, z;
        
        Vector3() : x((T)0), y((T)0), z((T)0) {}
        Vector3(T _x, T _y, T _z) : x(_x), y(_y), z(_z) {}

        void Set(T _x, T _y, T _z) { x = _x; y = _y; z = _z; }
        
        T Dot(const Vector3 &v) const
        {
                return x*v.x + y*v.y + z*v.z;
        }
        
        T Length() const
        {
                return std::sqrt( x*x + y*y + z*z );
        }
        
        T SquaredLength() const
        {
                return x*x + y*y + z*z;
        }

        // Returns the angle between this vector and v
        T Angle(const Vector3 &v) const
        {
                T denom = Length() * v.Length();
                if( denom == (T)0 )
                        return (T)0;

                return std::acos( Dot(v) / denom );
        }
        
        void Normalize()
        {
                T len = Length();
                x = x / len;
                y = y / len;
                z = z / len;
        }

        // Reflects this vector about the normal vector n
        const Vector3 Reflect(const Vector3 &n) const
        {
                // 
                //  v1 - this vector
                //  v2 - reflected vector
                //  n - normal to reflect against
                //
                //  v2 = v1 - 2 * n * Dot(v1, n)
                //

                Vector3 v1 = *this;

                return v1 - 2 * n * Dot(n);
        }

        Vector3 Project(const Vector3 &L) const
        {
                return L * Dot(L);
        }

        Vector3 Cross(const Vector3 &v) const\
        {
                return Vector3(y*v.z - z*v.y,
                                           z*v.x - x*v.z,
                                           x*v.y - y*v.x);
        }
        
        const Vector3 operator+(const Vector3 &v) const
        {
                return Vector3(x + v.x, y + v.y, z + v.z);
        }
        
        const Vector3 operator-(const Vector3 &v) const
        {
                return Vector3(x - v.x, y - v.y, z - v.z);
        }

        Vector3 operator-() const
        {
                return Vector3(-x, -y, -z);
        }
        
        const Vector3 operator*(T c) const
        {
                return Vector3(x*c, y*c, z*c);
        }
        
        const Vector3 operator/(T c) const
        {
                return Vector3(x/c, y/c, z/c);
        }
        
        T& operator[](int i)
        {
                return ((T*)this)[i];
        }

        T operator[](int i) const
        {
                return ((T*)this)[i];
        }

        bool operator==(const Vector3 &v) const
        {
                return (x == v.x) && (y == v.y) && (z == v.z);
        }

        friend const Vector3 operator*(T c, const Vector3 &v)
        {
                return Vector3(v.x*c, v.y*c, v.z*c);
        }
};

template<class T>
Vector3<T> Normalize(const Vector3<T> &v)
{
        T len = v.Length();
        return Vector3<T>(v.x / len, v.y / len, v.z / len);
}

template<class T>
T Dot(const Vector3<T> &v1, const Vector3<T> &v2)
{
        return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z;
}

template<class T>
Vector3<T> Cross(const Vector3<T> &v1, const Vector3<T> &v2)
{
        return Vector3<T>(v1.y*v2.z - v1.z*v2.y,
                                          v1.z*v2.x - v1.x*v2.z,
                                          v1.x*v2.y - v1.y*v2.x);
}

typedef Vector3<float> Vector3f;
typedef Vector3<double> Vector3d;

#endif

---