Vector.cpp

/*----------------------------------------------------------
* COSC363  Ray Tracer
*
*  The vector class
*  Use this class for defining vectors and points
*    and for performing operations on them.
-------------------------------------------------------------*/

#include <math.h>
#include "Vector.h"

// Default constructor, initialises all values to 0. 
Vector::Vector() : x(0), y(0), z(0) {}

// Constructor that takes initial x, y, z  values.
Vector::Vector(float a_x, float a_y, float a_z)
: x(a_x), y(a_y), z(a_z) {}


// Scales the input vector by scale 
const Vector& Vector::operator*=(float scale)
{
    x *= scale;
    y *= scale;
    z *= scale;
    return *this;
}

// Returns a new vector, containing this vector scaled by the input scale factor
Vector Vector::operator*(float scale) const 
{
    return Vector(*this) *= scale;
}

// Divides this vector by the input scale
const Vector& Vector::operator/=(float scale) 
{
    return operator*=(1.0f / scale);
}

// Returns a new vector containing the value of this vector divide by the given scale
Vector Vector::operator/(float scale) const 
{
    return Vector(*this) *= 1.0f / scale;
}

// Add the given vector to this one.
const Vector& Vector::operator+=(const Vector rhs) 
{
    x += rhs.x;
    y += rhs.y;
    z += rhs.z;
    return *this;
}

// Returns a new vector containing the result of adding the given vector to this one.
Vector Vector::operator+(const Vector rhs) const 
{
    return Vector(x + rhs.x, y + rhs.y, z + rhs.z);
}

// Subtracts the given vector from this one.
const Vector& Vector::operator-=(const Vector rhs) 
{
    x -= rhs.x;
    y -= rhs.y;
    z -= rhs.z;
    return *this;
}

// Returns a new vector containing the result of subtract rhs from this one.
Vector Vector::operator-(const Vector rhs) const 
{
    return Vector(x -rhs.x, y - rhs.y, z - rhs.z);
}

// Compares two vectors
const bool Vector::operator<(const Vector rhs) 
{
    float l1 = length();
    float l2 = rhs.length();
    return (l1 < l2);
}

// Scales the current vector by the given scale factor.
void Vector::scale(float scale) 
{
    operator*=(scale);
}

Vector Vector::rotation(float theta, Vector axis)
{
	Vector rotated = Vector();
	theta = theta * 3.14159265359 / 180.0;

	if (axis.x == 1)
	{
		rotated.x = x;
		rotated.y = y * cos(theta) - z * sin(theta);
		rotated.z = y * sin(theta) + z * cos(theta);
	} 
	else if (axis.y == 1)
	{
		rotated.x = x * cos(theta) + z * sin(theta);
		rotated.y = y;
		rotated.z = -x * sin(theta) + z * cos(theta);
	}
	else if (axis.z == 1)
	{
		rotated.x = x * cos(theta) - y * sin(theta);
		rotated.y = x * sin(theta) + y * cos(theta);
		rotated.z = z;
	}

	return rotated;
}

// Returns the cross product of this vector and rhs.
Vector Vector::cross(const Vector rhs) const 
{
    float tx = y * rhs.z - z * rhs.y;
    float ty = z * rhs.x - x * rhs.z;
    float tz = x * rhs.y - y * rhs.x;
    return Vector(tx, ty, tz);
}

// Gives the dot product of this vector and rhs
float Vector::dot(const Vector rhs) const 
{
    return x*rhs.x + y*rhs.y + z*rhs.z;
}

// Gives the distance between this point and rhs
float Vector::dist(const Vector rhs) const 
{
    Vector vdif = (*this)-rhs;
    return vdif.length();
}

// Returns the length of this vector
float Vector::length() const 
{
    return sqrt(dot(*this));
}

//Normalises this vector.
void Vector::normalise() 
{
    scale(1.0f / length());
}