src/rcrt/math/Vec3D.cpp

Go to the documentation of this file.

#include <cmath>
#include "Vec3D.h"

namespace rcrt
{


Vec3D::Vec3D()
{
        values[0] = values[1] = values[2] = 0;
}

Vec3D::Vec3D(const float& val)
{
        values[0] = values[1] = values[2] = val;
}

Vec3D::Vec3D(const float& xc, const float& yc, const float& zc)
{
        values[0] = xc;
        values[1] = yc;
        values[2] = zc;
}


Vec3D::Vec3D(const Vec3D& vec)
{
        assign(vec);
}


Vec3D::~Vec3D()
{
}


void Vec3D::assign(const Vec3D& vec)
{
        if(&vec != this){
                values[0] = vec.values[0];
                values[1] = vec.values[1];
                values[2] = vec.values[2];
        }
}



const Vec3D& Vec3D::operator= (const Vec3D& vec)
{
        assign(vec);
                
        return *this;
}


Vec3D Vec3D::operator+ (const Vec3D& vec) const
{
        return Vec3D(values[0]+vec.values[0],
                        values[1]+vec.values[1],
                        values[2]+vec.values[2]);
}


Vec3D Vec3D::operator- (const Vec3D& vec) const
{
        return Vec3D(values[0]-vec.values[0],
                        values[1]-vec.values[1],
                        values[2]-vec.values[2]);
}


float Vec3D::operator* (const Vec3D& vec) const
{
        return values[0]*vec.values[0]+
        values[1]*vec.values[1]+
        values[2]*vec.values[2];
}

float Vec3D::operator[] (int i) const
{
        return values[i];
}

float& Vec3D::operator[] (int i)
{
        return values[i];
}


Vec3D Vec3D::operator* (const float& f) const
{
        return Vec3D(values[0]*f,values[1]*f,values[2]*f);
}


Vec3D Vec3D::operator/ (const float& f) const
{
        float g = 1/f;
        return Vec3D(values[0]*g,values[1]*g,values[2]*g);
}

bool Vec3D::operator!= (const Vec3D& v) const
{
        return values[0] != v.values[0] || values[1] != v.values[1]
                || values[2] != v.values[2];
}

bool Vec3D::operator== (const Vec3D& v) const
{
        return values[0] == v.values[0] && values[1] == v.values[1]
                && values[2] == v.values[2];
}


Vec3D Vec3D::crossP(const Vec3D& vec) const
{
        return Vec3D(values[1]*vec.values[2] - values[2] * vec.values[1],
                        values[2]*vec.values[0] - values[0]*vec.values[2],
                        values[0]*vec.values[1] - values[1]*vec.values[0]);
}


Vec3D Vec3D::abs() const
{
        return Vec3D(fabs(values[0]),fabs(values[1]),fabs(values[2]));
}


const Vec3D& Vec3D::normalize()
{
        float n = 1/norm();
        values[0] *= n;
        values[1] *= n;
        values[2] *= n;
        
        return *this;
}


Vec3D Vec3D::normalized() const
{
        return *this/norm();
}


float Vec3D::norm() const
{
        return sqrt(values[0]*values[0]+values[1]*values[1]+values[2]*values[2]);
}

Vec3D Vec3D::reflect(const Vec3D& normal) const
{
        return *this - 2*(normal* (*this))*normal;
}

void Vec3D::getCS(Vec3D& u, Vec3D& v) const
{
        if ((values[0] == 0) && (values[1] == 0))       {
                if (values[2] < 0){
                        u.values[0] = -1;
                        u.values[1] = 0;
                        u.values[2] = 0;
                } else {
                        u.values[0] = 1;
                        u.values[1] = 0;
                        u.values[2] = 0;
                }
                v.values[0] = 0;
                v.values[1] = 1;
                v.values[2] = 0;
        } else {
                const float d = 1.0/sqrt(values[1]*values[1] + values[0]*values[0]);
                u.values[0] = values[1]*d;
                u.values[1] = -values[0]*d;
                u.values[2] = 0;
                v = this->crossP(u).normalized();
        }
}

const float& Vec3D::x() const
{
        return values[0];
}


const float& Vec3D::y() const
{
        return values[1];
}


const float& Vec3D::z() const
{
        return values[2];
}

}

---