//+-----------------------------------------------------------------------------
//| Included files
//+-----------------------------------------------------------------------------
#include "Interpolator.h"
#include "Model.h"


//+-----------------------------------------------------------------------------
//| Static member variables
//+-----------------------------------------------------------------------------
REFERENCE_OBJECT<INTERPOLATOR*, INTERPOLATOR*> INTERPOLATOR::InterpolatorNodes;


//+-----------------------------------------------------------------------------
//| Constructor
//+-----------------------------------------------------------------------------
INTERPOLATOR::INTERPOLATOR()
{
	Name = "";
	GlobalSequenceId = INVALID_INDEX;
	Type = INTERPOLATOR_TYPE_NONE;
	InterpolationType = INTERPOLATION_TYPE_NONE;

	Static = TRUE;
	StaticVector = D3DXVECTOR4(0.0f, 0.0f, 0.0f, 0.0f);
	DefaultVector = D3DXVECTOR4(0.0f, 0.0f, 0.0f, 0.0f);

	GlobalSequenceNode.SetData(this);
	InterpolatorNode.SetData(this);

	InterpolatorNode.Attach(InterpolatorNodes);
}


//+-----------------------------------------------------------------------------
//| Copy constructor
//+-----------------------------------------------------------------------------
INTERPOLATOR::INTERPOLATOR(CONST INTERPOLATOR& CopyObject)
{
	NodeList = CopyObject.NodeList;

	GlobalSequenceId = CopyObject.GlobalSequenceId;
	Type = CopyObject.Type;
	InterpolationType = CopyObject.InterpolationType;

	Static = CopyObject.Static;
	StaticVector = CopyObject.StaticVector;
	DefaultVector = CopyObject.DefaultVector;

	GlobalSequenceNode = CopyObject.GlobalSequenceNode;
	InterpolatorNode = CopyObject.InterpolatorNode;
}


//+-----------------------------------------------------------------------------
//| Destructor
//+-----------------------------------------------------------------------------
INTERPOLATOR::~INTERPOLATOR()
{
	Clear();

	InterpolatorNode.Detach();
}


//+-----------------------------------------------------------------------------
//| Assignment operator
//+-----------------------------------------------------------------------------
CONST INTERPOLATOR& INTERPOLATOR::operator =(CONST INTERPOLATOR& CopyObject)
{
	NodeList = CopyObject.NodeList;

	GlobalSequenceId = CopyObject.GlobalSequenceId;
	Type = CopyObject.Type;
	InterpolationType = CopyObject.InterpolationType;

	Static = CopyObject.Static;
	StaticVector = CopyObject.StaticVector;
	DefaultVector = CopyObject.DefaultVector;

	GlobalSequenceNode = CopyObject.GlobalSequenceNode;
	InterpolatorNode = CopyObject.InterpolatorNode;

	return (*this);
}


//+-----------------------------------------------------------------------------
//| Clears the interpolator
//+-----------------------------------------------------------------------------
VOID INTERPOLATOR::Clear()
{
	NodeList.clear();

	Type = INTERPOLATOR_TYPE_NONE;
	InterpolationType = INTERPOLATION_TYPE_NONE;

	Static = TRUE;
	StaticVector = D3DXVECTOR4(0.0f, 0.0f, 0.0f, 0.0f);
}


//+-----------------------------------------------------------------------------
//| Returns the mdx size of the interpolator
//+-----------------------------------------------------------------------------
INT INTERPOLATOR::GetSize()
{
	INT NodeSize = 0;
	INT Factor = 1;

	if(GetNrOfNodes() <= 0) return 0;

	switch(InterpolationType)
	{
		case INTERPOLATION_TYPE_HERMITE:
		case INTERPOLATION_TYPE_BEZIER:
		{
			Factor = 3;
			break;
		}
	}

	switch(Type)
	{
		case INTERPOLATOR_TYPE_SCALAR:
		case INTERPOLATOR_TYPE_SCALAR_INT:
		{
			NodeSize = (Factor * 4) + 4;
			break;
		}

		case INTERPOLATOR_TYPE_VECTOR2:
		{
			NodeSize = (Factor * 8) + 4;
			break;
		}

		case INTERPOLATOR_TYPE_VECTOR3:
		{
			NodeSize = (Factor * 12) + 4;
			break;
		}

		case INTERPOLATOR_TYPE_VECTOR4:
		{
			NodeSize = (Factor * 16) + 4;
			break;
		}
	}

	NodeSize *= GetNrOfNodes();

	return NodeSize + 16;
}


//+-----------------------------------------------------------------------------
//| Checks if the interpolator is static
//+-----------------------------------------------------------------------------
BOOL INTERPOLATOR::IsStatic()
{
	return Static;
}


//+-----------------------------------------------------------------------------
//| Returns the nr of nodes
//+-----------------------------------------------------------------------------
INT INTERPOLATOR::GetNrOfNodes()
{
	return static_cast<INT>(NodeList.size());
}


//+-----------------------------------------------------------------------------
//| Adds a new node to the interpolator
//+-----------------------------------------------------------------------------
VOID INTERPOLATOR::AddNode(CONST INTERPOLATOR_NODE& Node)
{
	NodeList.push_back(Node);
	Static = FALSE;
}


//+-----------------------------------------------------------------------------
//| Sets a new type
//+-----------------------------------------------------------------------------
VOID INTERPOLATOR::SetType(INTERPOLATOR_TYPE NewType)
{
	Type = NewType;
}


//+-----------------------------------------------------------------------------
//| Returns the type
//+-----------------------------------------------------------------------------
INTERPOLATOR_TYPE INTERPOLATOR::GetType()
{
	return Type;
}


//+-----------------------------------------------------------------------------
//| Sets a new interpoaltion type
//+-----------------------------------------------------------------------------
VOID INTERPOLATOR::SetInterpolationType(INTERPOLATION_TYPE NewInterpolationType)
{
	InterpolationType = NewInterpolationType;
}


//+-----------------------------------------------------------------------------
//| Returns the interpolation type
//+-----------------------------------------------------------------------------
INTERPOLATION_TYPE INTERPOLATOR::GetInterpolationType()
{
	return InterpolationType;
}


//+-----------------------------------------------------------------------------
//| Sets a new global sequence ID
//+-----------------------------------------------------------------------------
VOID INTERPOLATOR::SetGlobalSequenceId(INT NewGlobalSequenceId)
{
	GlobalSequenceId = NewGlobalSequenceId;
}


//+-----------------------------------------------------------------------------
//| Returns the global sequence ID
//+-----------------------------------------------------------------------------
INT INTERPOLATOR::GetGlobalSequenceId()
{
	return GlobalSequenceId;
}


//+-----------------------------------------------------------------------------
//| Saves the interpolator
//+-----------------------------------------------------------------------------
BOOL INTERPOLATOR::Save(DATA_OUT_STREAM& DataStream, BOOL ReverseXZ)
{
	std::list<INTERPOLATOR_NODE>::iterator i;

	DataStream.WriteDWord(static_cast<DWORD>(NodeList.size()));
	switch(InterpolationType)
	{
		case INTERPOLATION_TYPE_NONE:
		{
			DataStream.WriteDWord(0);
			break;
		}

		case INTERPOLATION_TYPE_LINEAR:
		{
			DataStream.WriteDWord(1);
			break;
		}

		case INTERPOLATION_TYPE_HERMITE:
		{
			DataStream.WriteDWord(2);
			break;
		}

		case INTERPOLATION_TYPE_BEZIER:
		{
			DataStream.WriteDWord(3);
			break;
		}
	}

	DataStream.WriteDWord((GlobalSequenceId == INVALID_INDEX) ? 0xFFFFFFFF : GlobalSequenceId);

	i = NodeList.begin();
	while(i != NodeList.end())
	{
		DataStream.WriteDWord(i->Time);

		switch(Type)
		{
			case INTERPOLATOR_TYPE_SCALAR:
			{
				DataStream.WriteFloat(i->Vector.x);
				break;
			}

			case INTERPOLATOR_TYPE_SCALAR_INT:
			{
				DataStream.WriteDWord(static_cast<DWORD>(i->Vector.x));
				break;
			}

			case INTERPOLATOR_TYPE_VECTOR2:
			{
				DataStream.WriteFloat(i->Vector.x);
				DataStream.WriteFloat(i->Vector.y);
				break;
			}

			case INTERPOLATOR_TYPE_VECTOR3:
			{
				if(ReverseXZ)
				{
					DataStream.WriteFloat(i->Vector.z);
					DataStream.WriteFloat(i->Vector.y);
					DataStream.WriteFloat(i->Vector.x);
				}
				else
				{
					DataStream.WriteFloat(i->Vector.x);
					DataStream.WriteFloat(i->Vector.y);
					DataStream.WriteFloat(i->Vector.z);
				}
				break;
			}

			case INTERPOLATOR_TYPE_VECTOR4:
			{
				DataStream.WriteFloat(i->Vector.x);
				DataStream.WriteFloat(i->Vector.y);
				DataStream.WriteFloat(i->Vector.z);
				DataStream.WriteFloat(i->Vector.w);
				break;
			}
		}

		switch(InterpolationType)
		{
			case INTERPOLATION_TYPE_HERMITE:
			case INTERPOLATION_TYPE_BEZIER:
			{
				switch(Type)
				{
					case INTERPOLATOR_TYPE_SCALAR:
					{
						DataStream.WriteFloat(i->InTan.x);
						DataStream.WriteFloat(i->OutTan.x);
						break;
					}

					case INTERPOLATOR_TYPE_SCALAR_INT:
					{
						DataStream.WriteDWord(static_cast<DWORD>(i->InTan.x));
						DataStream.WriteDWord(static_cast<DWORD>(i->OutTan.x));
						break;
					}

					case INTERPOLATOR_TYPE_VECTOR2:
					{
						DataStream.WriteFloat(i->InTan.x);
						DataStream.WriteFloat(i->InTan.y);
						DataStream.WriteFloat(i->OutTan.x);
						DataStream.WriteFloat(i->OutTan.y);
						break;
					}

					case INTERPOLATOR_TYPE_VECTOR3:
					{
						if(ReverseXZ)
						{
							DataStream.WriteFloat(i->InTan.z);
							DataStream.WriteFloat(i->InTan.y);
							DataStream.WriteFloat(i->InTan.x);
							DataStream.WriteFloat(i->OutTan.z);
							DataStream.WriteFloat(i->OutTan.y);
							DataStream.WriteFloat(i->OutTan.x);
						}
						else
						{
							DataStream.WriteFloat(i->InTan.x);
							DataStream.WriteFloat(i->InTan.y);
							DataStream.WriteFloat(i->InTan.z);
							DataStream.WriteFloat(i->OutTan.x);
							DataStream.WriteFloat(i->OutTan.y);
							DataStream.WriteFloat(i->OutTan.z);
						}
						break;
					}

					case INTERPOLATOR_TYPE_VECTOR4:
					{
						DataStream.WriteFloat(i->InTan.x);
						DataStream.WriteFloat(i->InTan.y);
						DataStream.WriteFloat(i->InTan.z);
						DataStream.WriteFloat(i->InTan.w);
						DataStream.WriteFloat(i->OutTan.x);
						DataStream.WriteFloat(i->OutTan.y);
						DataStream.WriteFloat(i->OutTan.z);
						DataStream.WriteFloat(i->OutTan.w);
						break;
					}
				}

				break;
			}
		}

		i++;
	}

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Loads an interpolator
//+-----------------------------------------------------------------------------
BOOL INTERPOLATOR::Load(DATA_IN_STREAM& DataStream, BOOL ReverseXZ)
{
	INT i;
	INT NodeListSize;
	INTERPOLATOR_NODE Node;

	NodeList.clear();

	NodeListSize = DataStream.ReadDWord();

	switch(DataStream.ReadDWord())
	{
		case 0:
		{
			InterpolationType = INTERPOLATION_TYPE_NONE;
			break;
		}

		case 1:
		{
			InterpolationType = INTERPOLATION_TYPE_LINEAR;
			break;
		}

		case 2:
		{
			InterpolationType = INTERPOLATION_TYPE_HERMITE;
			break;
		}

		case 3:
		{
			InterpolationType = INTERPOLATION_TYPE_BEZIER;
			break;
		}

		default:
		{
			Error.SetMessage("Unknown interpolation type!");
			return FALSE;
		}
	}

	GlobalSequenceId = DataStream.ReadDWord();

	for(i = 0; i < NodeListSize; i++)