RTVolumeRendering/Source/Point3.h

Go to the documentation of this file.

#ifndef POINT3_H
#define POINT3_H

#include "Vector3.h"

template<class T>
class Point3
{
public:
        T x, y, z;
        
        Point3() : x((T)0.0), y((T)0.0), z((T)0.0) {}
        Point3(T _x, T _y, T _z) : x(_x), y(_y), z(_z) {}
        Point3(const Vector3<T> &v) : x(v.x), y(v.y), z(v.z) {}
        
        void Set(T _x, T _y, T _z) { x = _x; y = _y; z = _z; }
        
        Point3 operator+(const Point3 &p) const
        {
                return Point3(x + p.x, y + p.y, z + p.z);
        }
        
        Point3 operator+(const Vector3<T> &v) const
        {
                return Point3(x + v.x, y + v.y, z + v.z);
        }
        
        Point3 &operator+=(const Point3 &p)
        {
                x += p.x;
                y += p.y;
                z += p.z;
                return *this;
        }
        
        Vector3<T> operator-(const Point3 &p) const
        {
                return Vector3<T>(x - p.x, y - p.y, z - p.z);
        }
        
        Vector3<T> operator-(const Vector3<T> &v) const
        {
                return Vector3<T>(x - v.x, y - v.y, z - v.z);
        }

        Point3 operator-() const
        {
                return Point3(-x, -y, -z);
        }
        
        Point3 &operator-=(const Point3 &p)
        {
                x -= p.x;
                y -= p.y;
                z -= p.z;
                return *this;
        }
        
        Point3 operator/(T c) const
        {
                return Point3(x / c,-y / c, z / c);
        }

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

        T operator[](int i) const
        {
                return ((T*)this)[i];
        }
        
        Point3 operator*(T c) const
        {
                return Point3(c*x, c*y, c*z);
        }
        
        friend Point3 operator*(float c, const Point3 &p)
        {
                return Point3(c*p.x, c*p.y, c*p.z);
        }
};

typedef Point3<float> Point3f;
typedef Point3<double> Point3d;

// Useful function for manipulating Points and vectors together
template<class T>
T Dot(const Vector3<T> &v, const Point3<T> &p)
{
        return v.x*p.x + v.y*p.y + v.z*p.z;
}

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

template<class T>
T Dot(const Point3<T> &p1, const Point3<T> &p2)
{
        return p1.x*p2.x + p1.y*p2.y + p1.z*p2.z;
}

#endif

---