/*
**	Command & Conquer Renegade(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	This program is free software: you can redistribute it and/or modify
**	it under the terms of the GNU General Public License as published by
**	the Free Software Foundation, either version 3 of the License, or
**	(at your option) any later version.
**
**	This program is distributed in the hope that it will be useful,
**	but WITHOUT ANY WARRANTY; without even the implied warranty of
**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**	GNU General Public License for more details.
**
**	You should have received a copy of the GNU General Public License
**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/***********************************************************************************************
 ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
 ***********************************************************************************************
 *                                                                                             *
 *                 Project Name : WWMath                                                       *
 *                                                                                             *
 *                     $Archive:: /VSS_Sync/wwmath/hermitespline.cpp                          $*
 *                                                                                             *
 *                       Author:: Greg Hjelstrom                                               *
 *                                                                                             *
 *                     $Modtime:: 6/13/01 2:18p                                               $*
 *                                                                                             *
 *                    $Revision:: 11                                                          $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */


#include "hermitespline.h"
#include "wwmathids.h"
#include "persistfactory.h"
#include "wwhack.h"


/*
** Force-Link this module because the linker can't detect that we actually need it...
*/
DECLARE_FORCE_LINK(hermitespline);

/*
** Save-Load stuff
*/
SimplePersistFactoryClass<HermiteSpline3DClass,WWMATH_CHUNKID_HERMITESPLINE3D>	_HermiteSpline3DFactory;
SimplePersistFactoryClass<HermiteSpline1DClass,WWMATH_CHUNKID_HERMITESPLINE1D>	_HermiteSpline1DFactory;

enum 
{
	// ID's used by HermiteSpline3D
	HERMITE3D_CHUNK_CURVE3D					= 0x00020727,	
	HERMITE3D_CHUNK_TANGENTS,			

	// ID's used by HermiteSpline1D
	HERMITE1D_CHUNK_CURVE1D					= 0x00020729,	
	HERMITE1D_CHUNK_TANGENTS,			
};


/*
** Hermite Spline
*/
const HermiteSpline3DClass &HermiteSpline3DClass::operator= (const HermiteSpline3DClass &that)
{
	//
	//	This is included for completeness only, it basically
	// implements the default bitwise copy operator.
	//
	TangentsDirty	= that.TangentsDirty;
	Tangents			= that.Tangents;
	Curve3DClass::operator= (that);
	return (*this);
}

void HermiteSpline3DClass::Set_Looping(bool onoff)
{
	if (onoff != IsLooping) {
		Curve3DClass::Set_Looping(onoff);
		TangentsDirty = true;
	}
}

void HermiteSpline3DClass::Evaluate(float time,Vector3 * set_val)
{
	// if we're outside the range, return the start or end...
	if (time < Keys[0].Time) { 
		*set_val = Keys[0].Point;
		return;
	}

	if (time > Keys[Keys.Count() - 1].Time) {
		*set_val = Keys[Keys.Count() - 1].Point;
		return;
	}

	// if the tangents are marked dirty, give derived classes a chance to recompute them
	if (TangentsDirty) {
		Update_Tangents();
	}
	
	// ok find the segment
	int i0,i1;
	float t;
	Find_Interval(time,&i0,&i1,&t);

	float t2 = t*t;
	float t3 = t2*t;

	// hermite basis functions:
	float h0 = 2*t3 - 3*t2 + 1;
	float h1 = -2*t3 + 3*t2;
	float h2 = t3 - 2*t2 + t;
	float h3 = t3 - t2;

	set_val->X =	h0*Keys[i0].Point.X + h1*Keys[i1].Point.X + 
						h2*Tangents[i0].OutTangent.X + h3*Tangents[i1].InTangent.X;

	set_val->Y =	h0*Keys[i0].Point.Y + h1*Keys[i1].Point.Y + 
						h2*Tangents[i0].OutTangent.Y + h3*Tangents[i1].InTangent.Y;

	set_val->Z =	h0*Keys[i0].Point.Z + h1*Keys[i1].Point.Z + 
						h2*Tangents[i0].OutTangent.Z + h3*Tangents[i1].InTangent.Z;
}

void HermiteSpline3DClass::Evaluate_Derivative(float time,Vector3 * set_val)
{
	// if we're outside the range, return the value for the start or end...
	float min_time = Keys[0].Time;
	float max_time = Keys[Keys.Count() - 1].Time;
	time = MAX(time, min_time);
	time = MIN(time, max_time);

	// if the tangents are marked dirty, give derived classes a chance to recompute them
	if (TangentsDirty) {
		Update_Tangents();
	}
	
	// ok find the segment
	int i0,i1;
	float t;
	Find_Interval(time,&i0,&i1,&t);

	float t2 = t*t;

	// derivatives of hermite basis functions:
	float dh0 = 6*t2 - 6*t;
	float dh1 = -6*t2 + 6*t;
	float dh2 = 3*t2 - 4*t + 1;
	float dh3 = 3*t2 - 2*t;

	set_val->X =	dh0*Keys[i0].Point.X + dh1*Keys[i1].Point.X + 
						dh2*Tangents[i0].OutTangent.X + dh3*Tangents[i1].InTangent.X;

	set_val->Y =	dh0*Keys[i0].Point.Y + dh1*Keys[i1].Point.Y + 
						dh2*Tangents[i0].OutTangent.Y + dh3*Tangents[i1].InTangent.Y;

	set_val->Z =	dh0*Keys[i0].Point.Z + dh1*Keys[i1].Point.Z + 
						dh2*Tangents[i0].OutTangent.Z + dh3*Tangents[i1].InTangent.Z;
}

void HermiteSpline3DClass::Set_Key(int i,const Vector3 & point)
{
	Curve3DClass::Set_Key(i,point);
	TangentsDirty = true;
}

int HermiteSpline3DClass::Add_Key(const Vector3 & point,float t)
{
	int index = Curve3DClass::Add_Key(point,t);
	TangentsDirty = true;
	TangentsClass tan;
	tan.InTangent.Set(0,0,0);
	tan.OutTangent.Set(0,0,0);
	Tangents.Insert(index,tan);
	return index;
}

void HermiteSpline3DClass::Remove_Key(int i)
{
	Tangents.Delete(i);
	Curve3DClass::Remove_Key(i);
	TangentsDirty = true;
}

void HermiteSpline3DClass::Clear_Keys(void)
{
	Tangents.Clear();
	Curve3DClass::Clear_Keys();
	TangentsDirty = true;
}

void HermiteSpline3DClass::Set_Tangents(int i,const Vector3 & in_tan,const Vector3 & out_tan)
{
	assert(i>=0);
	assert(i<Keys.Count());
	Tangents[i].InTangent = in_tan;
	Tangents[i].OutTangent = out_tan;
}

void HermiteSpline3DClass::Get_Tangents(int i,Vector3 * set_in,Vector3 * set_out)
{
	assert(i>=0);
	assert(i<Keys.Count());
	*set_in = Tangents[i].InTangent;
	*set_out = Tangents[i].OutTangent;
}

const PersistFactoryClass & HermiteSpline3DClass::Get_Factory(void) const
{
	return _HermiteSpline3DFactory;
}

bool HermiteSpline3DClass::Save(ChunkSaveClass &csave)
{
	csave.Begin_Chunk(HERMITE3D_CHUNK_CURVE3D);
	Curve3DClass::Save(csave);
	csave.End_Chunk();
	
	csave.Begin_Chunk(HERMITE3D_CHUNK_TANGENTS);
	for (int i=0; i<Tangents.Count(); i++) {
		csave.Write(&(Tangents[i].InTangent),sizeof(Tangents[i].InTangent));
		csave.Write(&(Tangents[i].OutTangent),sizeof(Tangents[i].OutTangent));
	}
	csave.End_Chunk();
	return true;
}

bool HermiteSpline3DClass::Load(ChunkLoadClass &cload)
{
	int i;
	TangentsClass newtangent;

	// reset the array of tangents
	Tangents.Delete_All();

	// read in the chunks
	while (cload.Open_Chunk()) {
		
		switch(cload.Cur_Chunk_ID()) 
		{
			case HERMITE3D_CHUNK_CURVE3D:
				Curve3DClass::Load(cload);
				break;

			case HERMITE3D_CHUNK_TANGENTS:
				for (i=0; i<Keys.Count(); i++) {
					cload.Read(&(newtangent.InTangent),sizeof(newtangent.InTangent));
					cload.Read(&(newtangent.OutTangent),sizeof(newtangent.OutTangent));
					Tangents.Add(newtangent);
				}
				break;

			default:
				WWDEBUG_SAY(("Unhandled Chunk: 0x%X File: %s Line: %d\r\n",__FILE__,__LINE__));
				break;
		}
		cload.Close_Chunk();
	}

	WWASSERT(Keys.Count() == Tangents.Count());
	return true;
}




/*
** 1-Dimensional Hermite Spline
*/
void HermiteSpline1DClass::Set_Looping(bool onoff)
{
	if (onoff != IsLooping) {
		Curve1DClass::Set_Looping(onoff);
		TangentsDirty = true;
	}
}

void HermiteSpline1DClass::Evaluate(float time,float * set_val)
{
	if (Keys.Count() == 1)
	{
		*set_val = Keys[0].Point;
		return;
	}

	if (!IsLooping)
	{
		// if we're outside the range, return the start or end...
		if (time < Keys[0].Time) { 
			*set_val = Keys[0].Point;
			return;
		}

		if (time > Keys[Keys.Count() - 1].Time) {
			*set_val = Keys[Keys.Count() - 1].Point;
			return;
		}
	}

	// if the tangents are marked dirty, give derived classes a chance to recompute them
	if (TangentsDirty) {
		Update_Tangents();
	}
	
	// ok find the segment
	int i0,i1;
	float t;
	Find_Interval(time,&i0,&i1,&t);

	float t2 = t*t;
	float t3 = t2*t;

	// hermite basis functions:
	float h0 = 2*t3 - 3*t2 + 1;
	float h1 = -2*t3 + 3*t2;
	float h2 = t3 - 2*t2 + t;
	float h3 = t3 - t2;

	*set_val = h0*Keys[i0].Point + h1*Keys[i1].Point +
		h2*Tangents[i0].OutTangent + h3*Tangents[i1].InTangent;
}

void HermiteSpline1DClass::Set_Key(int i,float point,unsigned int extra)
{
	Curve1DClass::Set_Key(i,point,extra);
	TangentsDirty = true;
}

int HermiteSpline1DClass::Add_Key(float point,float t,unsigned int extra)
{
	int index = Curve1DClass::Add_Key(point,t,extra);
	TangentsDirty = true;
	TangentsClass tan;
	tan.InTangent = 0.0f;
	tan.OutTangent = 0.0f;
	Tangents.Insert(index,tan);
	return index;
}

void HermiteSpline1DClass::Remove_Key(int i)
{
	Tangents.Delete(i);
	Curve1DClass::Remove_Key(i);
	TangentsDirty = true;
}

void HermiteSpline1DClass::Clear_Keys(void)
{
	Tangents.Clear();
	Curve1DClass::Clear_Keys();
	TangentsDirty = true;
}

void HermiteSpline1DClass::Set_Tangents(int i,float in_tan,float out_tan)
{
	assert(i>=0);
	assert(i<Keys.Count());
	Tangents[i].InTangent = in_tan;
	Tangents[i].OutTangent = out_tan;
}

void HermiteSpline1DClass::Get_Tangents(int i,float * set_in,float * set_out)
{
	assert(i>=0);
	assert(i<Keys.Count());
	*set_in = Tangents[i].InTangent;
	*set_out = Tangents[i].OutTangent;
}

const PersistFactoryClass & HermiteSpline1DClass::Get_Factory(void) const
{
	return _HermiteSpline1DFactory;
}

bool HermiteSpline1DClass::Save(ChunkSaveClass &csave)
{
	if (TangentsDirty) {
		Update_Tangents();
	}

	csave.Begin_Chunk(HERMITE1D_CHUNK_CURVE1D);
	Curve1DClass::Save(csave);
	csave.End_Chunk();
	
	csave.Begin_Chunk(HERMITE1D_CHUNK_TANGENTS);
	for (int i=0; i<Tangents.Count(); i++) {
		csave.Write(&(Tangents[i].InTangent),sizeof(Tangents[i].InTangent));
		csave.Write(&(Tangents[i].OutTangent),sizeof(Tangents[i].OutTangent));
	}
	csave.End_Chunk();
	return true;
}

bool HermiteSpline1DClass::Load(ChunkLoadClass &cload)
{
	int i;
	TangentsClass newtangent;

	// reset the tangents array
	Tangents.Delete_All();

	// read in the chunks
	while (cload.Open_Chunk()) {
		
		switch(cload.Cur_Chunk_ID()) 
		{
			case HERMITE1D_CHUNK_CURVE1D:
				Curve1DClass::Load(cload);
				break;

			case HERMITE1D_CHUNK_TANGENTS:
				for (i=0; i<Keys.Count(); i++) {
					cload.Read(&(newtangent.InTangent),sizeof(newtangent.InTangent));
					cload.Read(&(newtangent.OutTangent),sizeof(newtangent.OutTangent));
					Tangents.Add(newtangent);
				}
				TangentsDirty = false;
				break;

			default:
				WWDEBUG_SAY(("Unhandled Chunk: 0x%X File: %s Line: %d\r\n",__FILE__,__LINE__));
				break;
		}
		cload.Close_Chunk();
	}

	WWASSERT(Keys.Count() == Tangents.Count());
	return true;
}