/**

 * @file  vector.h

 * @brief Vector class with Colour alias

 *

 * This file is part of Pyrit Ray Tracer.

 *

 * Copyright 2006, 2007, 2008  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>

#include "common.h"

#include "simd.h"

using namespace std;

/**

 */

class Vector

{

public:

	// data

	union {

#ifndef NO_SIMD

		mfloat4 mf4;

#endif

		Float cell[4];

		struct { Float x, y, z, w; };

		struct { Float r, g, b, a; };

	};

	// constructors

#ifndef NO_SIMD

	Vector(mfloat4 m): mf4(m) {};

#endif

	Vector(): x(0.0f), y(0.0f), z(0.0f), w(1.0) {};

	Vector(Float ax, Float ay, Float az): x(ax), y(ay), z(az), w(1.0) {};

	// index operator

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

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

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

	/** Normalize the vector */

	Vector normalize()

	{

		const Float f = 1.0f / mag();

		*this *= f;

		return *this;

	};

	/** Get normalized copy of vector */

	friend Vector normalize(const Vector &v)

	{

		const Float f = 1.0f / v.mag();

		return v * f;

	};

	/** Square magnitude */

	Float mag2() const	{ return dot(*this, *this); };

	/** Vector magnitude */

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

	/** Get negative vector */

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

	/** Accumulate. Useful for colors. */

	Vector operator+=(const Vector &v)

	{

		x += v.x;

		y += v.y;

		z += v.z;

#else

		mf4 = madd(mf4, v.mf4);

#endif

		return *this;

	};

	/** Multiply by scalar */

	Vector operator*=(const Float &f)

	{

		x *= f;

		y *= f;

		z *= f;

		return *this;

	};

	/** Cut with scalar */

	Vector operator/=(const Float &f)

	{

		Float finv = 1.0f / f;

		x *= finv;

		y *= finv;

		z *= finv;

		return *this;

	};

	/** Sum of two vectors */

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

	{

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

#else

		return Vector(madd(a.mf4, b.mf4));

#endif

	};

	/** Difference of two vectors */

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

	{

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

#else

		return Vector(msub(a.mf4, b.mf4));

#endif

	};

	/** Dot product */

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

	{

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

	};

	/** Cross product */

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

	{

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

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

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

	};

	/** Get vector multiplied by scalar */

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

	{

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

	};

	/** Get vector multiplied by scalar */

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

	{

		return v * f;

	};

	/** Get vector divided by scalar */

	friend Vector operator/(const Vector &v, const Float &f)

	{

		const Float finv = 1.0f / f;

		return Vector(v.x * finv, v.y * finv, v.z * finv);

	};

	/** Get f/v, i.e. inverted vector multiplied by scalar */

	friend Vector operator/(const Float &f, const Vector &v)

	{

		return Vector(f / v.x, f / v.y, f / v.z);

#else

		return Vector(mdiv(mset1(f), v.mf4));

#endif

	};

	/** Add scalar to the vector */

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

	{

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

	};

	/** Subtract scalar from the vector */

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

	{

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

	};

	/** Cell by cell product (only useful for colors) */

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

	{

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

#else

		return Vector(mmul(a.mf4, b.mf4));

#endif

	};

	/** Write textual representation of the vector to stream */

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

	{

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

	};

	/** Read the vector from stream */

	friend istream & operator>>(istream &st, Vector &v)

	{

		char s[10];

		st.getline(s, 10, '(');

		st >> v.x;

		st.getline(s, 10, ',');

		st >> v.y;

		st.getline(s, 10, ',');

		st >> v.z;

		st.getline(s, 10, ')');

		return st;

	};

};

/** Colour is a alias name of Vector. */

typedef Vector Colour;

#ifndef NO_SIMD

/**

  * Packet of four Vectors

  */

class VectorPacket

{

public:

	union {

		mfloat4 ma[3];

		struct {

			mfloat4 mx;

			mfloat4 my;

			mfloat4 mz;

		};

		struct {

			float x[4];

			float y[4];

			float z[4];

		};

	};

	VectorPacket() {};

	VectorPacket(mfloat4 ax, mfloat4 ay, mfloat4 az):

		mx(ax), my(ay), mz(az) {};

	VectorPacket(const Vector &v):

		mx(mset1(v.x)), my(mset1(v.y)), mz(mset1(v.z)) {};

	Vector getVector(int i) const

	{

		return Vector(x[i], y[i], z[i]);

	};

	void setVector(int i, const Vector &v)

	{

		x[i] = v.x; y[i] = v.y; z[i] = v.z;

	};

	void normalize()

	{

		mfloat4 m,x,y,z;

		x = mmul(mx, mx); // x*x

		y = mmul(my, my); // y*y

		z = mmul(mz, mz); // z*z

		m = madd(madd(x, y), z);     // x*x + y*y + z*z

		m = mdiv(mOne, msqrt(m));   // m = 1/sqrt(m)

		mx = mmul(mx, m);

		my = mmul(my, m);

		mz = mmul(mz, m);

	};

	// accumulate

	VectorPacket operator+=(const VectorPacket &v)

	{

		mx = madd(mx, v.mx);

		my = madd(my, v.my);

		mz = madd(mz, v.mz);

		return *this;

	};

	// add to non-masked components

	VectorPacket selectiveAdd(const mfloat4 &mask, const VectorPacket &v)

	{

		mx = mselect(mask, madd(mx, v.mx), mx);

		my = mselect(mask, madd(my, v.my), my);

		mz = mselect(mask, madd(mz, v.mz), mz);

		return *this;

	};

	// add scalar to non-masked components

	VectorPacket selectiveAdd(const mfloat4 &mask, const mfloat4 &m)

	{

		mx = mselect(mask, madd(mx, m), mx);

		my = mselect(mask, madd(my, m), my);

		mz = mselect(mask, madd(mz, m), mz);

		return *this;

	};

	// dot product

	friend mfloat4 dot(const VectorPacket &a, const VectorPacket &b)

	{

		return madd(madd(

			mmul(a.mx, b.mx),

			mmul(a.my, b.my)),

			mmul(a.mz, b.mz));

	};

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

	{

		return VectorPacket(

			madd(a.mx, b.mx),

			madd(a.my, b.my),

			madd(a.mz, b.mz));

	};

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

	{

		return VectorPacket(

			msub(a.mx, b.mx),

			msub(a.my, b.my),

			msub(a.mz, b.mz));

	};

	friend VectorPacket operator*(const VectorPacket &v,  const mfloat4 &m)

	{

		return VectorPacket(

			mmul(v.mx, m),

			mmul(v.my, m),

			mmul(v.mz, m));

	};

	friend VectorPacket operator/(const mfloat4 &m, const VectorPacket &v)

	{

		return VectorPacket(

			mdiv(m, v.mx),

			mdiv(m, v.my),

			mdiv(m, v.mz));

	};

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

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

	{

		return VectorPacket(

			mmul(a.mx, b.mx),

			mmul(a.my, b.my),

			mmul(a.mz, b.mz));

	};

	// write to character stream

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

	{

		return st << "[" << v.getVector(0) << "," << v.getVector(1)

			<< "," << v.getVector(2) << "," << v.getVector(3) << ")";

	};

};

#endif

#endif