/*

 * vector.h: Vector3 class with Colour alias

 *

 * This file is part of Pyrit Ray Tracer.

 *

 * Copyright 2006, 2007  Radek Brich

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */

#ifndef VECTOR_H

#define VECTOR_H

#include <math.h>

#include <iostream>

using namespace std;

/**

 * three cell vector

 */

class Vector3

{

public:

	// data

	union {

		struct {

			Float x, y, z;

		};

		struct {

			Float r, g, b;

		};

		Float cell[3];

	};

	// constructors

	Vector3(): x(0.0f), y(0.0f), z(0.0f) {};

	Vector3(Float ax, Float ay, Float az): x(ax), y(ay), z(az) {};

	// index operator

	const Float &operator[](int index) const { return cell[index]; };

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

	// normalize

	Vector3 normalize()

	{

		Float f = 1.0f / mag();

		x *= f;

		y *= f;

		z *= f;

		return *this;

	}

	// get normalized copy

	Vector3 unit() const

	{

		Vector3 u(*this);

		return u.normalize();;

	}

	// square magnitude, magnitude

	Float mag2() const	{ return x * x + y * y + z * z; }

	Float mag() const	{ return sqrtf(mag2()); }

	// negative

	Vector3 operator-() const { return Vector3(-x, -y, -z); }

	// accumulate

	Vector3 operator+=(const Vector3 &v)

	{

		x += v.x;

		y += v.y;

		z += v.z;

		return *this;

	};

	// cut

	Vector3 operator/=(const Float &f)

	{

		x /= f;

		y /= f;

		z /= f;

		return *this;

	};

	// sum

	friend Vector3 operator+(const Vector3 &a, const Vector3 &b)

	{

		return Vector3(a.x + b.x, a.y + b.y, a.z + b.z);

	};

	// difference

	friend Vector3 operator-(const Vector3 &a, const Vector3 &b)

	{

		return Vector3(a.x - b.x, a.y - b.y, a.z - b.z);

	};

	// dot product

	friend Float dot(const Vector3 &a, const Vector3 &b)

	{

		return a.x * b.x + a.y * b.y + a.z * b.z;

	};

	// cross product

	friend Vector3 cross(const Vector3 &a, const Vector3 &b)

	{

		return Vector3(a.y * b.z - a.z * b.y,

			a.z * b.x - a.x * b.z,

			a.x * b.y - a.y * b.x);

	};

	// product of vector and scalar

	friend Vector3 operator*(const Vector3 &v, const Float &f)

	{

		return Vector3(f * v.x, f * v.y, f * v.z);

	}

	friend Vector3 operator*(const Float &f, const Vector3 &v)

	{

		return v * f;

	};

	// vector plus scalar

	friend Vector3 operator+(const Vector3 &v, const Float &f)

	{

		return Vector3(v.x + f, v.y + f, v.z + f);

	}

	// vector minus scalar

	friend Vector3 operator-(const Vector3 &v, const Float &f)

	{

		return Vector3(v.x - f, v.y - f, v.z - f);

	}

	// cell by cell product (only usable for colours)

	friend Vector3 operator*(const Vector3 &a,  const Vector3 &b)

	{

		return Vector3(a.x * b.x, a.y * b.y, a.z * b.z);

	};

	// print

	friend ostream & operator<<(ostream &st, const Vector3 &v)

	{

		return st << "(" << v.x << ", " << v.y  << ", " << v.z << ")";

	}

};

typedef Vector3 Colour;

#endif