/*
===========================================================================
Copyright (C) 2015 the OpenMoHAA team

This file is part of OpenMoHAA source code.

OpenMoHAA source code 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 2 of the License,
or (at your option) any later version.

OpenMoHAA source code 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 OpenMoHAA source code; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/

// bspline.cpp: Uniform non-rational bspline class.
//

#include "g_local.h"
#include "bspline.h"
#include "game.h"
#include "debuglines.h"
#include "g_phys.h"
#include "scriptexception.h"

void BSpline::Set
	(
	Vector *control_points_,
	int num_control_points_,
	splinetype_t type
	)

	{
	int i;

	SetType( type );

   has_orientation = false;

	if ( control_points )
		{
		delete [] control_points;
		control_points = NULL;
		}

	num_control_points = num_control_points_;
	if ( num_control_points )
		{
		control_points = new BSplineControlPoint[ num_control_points ];
		assert( control_points );

		for( i = 0; i < num_control_points; i++ )
			{
			control_points[ i ].Set( control_points_[ i ] );
			}
		}
	}

void BSpline::Set
	(
	Vector *control_points_,
	Vector *control_orients_,
   float  *control_speeds_,
	int num_control_points_,
	splinetype_t type
	)

	{
	int i;

	SetType( type );

   has_orientation = true;

	if ( control_points )
		{
		delete [] control_points;
		control_points = NULL;
		}

	num_control_points = num_control_points_;
	if ( num_control_points )
		{
		control_points = new BSplineControlPoint[ num_control_points ];
		assert( control_points );

		for( i = 0; i < num_control_points; i++ )
			{
			control_points[ i ].Set( control_points_[ i ], control_orients_[ i ], control_speeds_[ i ] );
			}
		}
	}

void BSpline::Clear
	(
	void
	)

	{
	if( control_points )
		{
		delete [] control_points;
		control_points = NULL;
		}
	num_control_points = 0;
   has_orientation = false;
	}

inline float BSpline::EvalNormal
	(
	float u,
   Vector& pos,
   Vector& orient
	)

	{
	int		segment_id;
	float		B[ 4 ];
	float		tmp;
	float		u_2;
	float		u_3;
   Vector   ang;
   float    roll;
   float    speed;

	segment_id = ( int )u;
	if ( segment_id < 0 )
		{
		segment_id = 0;
		}
	if ( segment_id > num_control_points - 4 )
		{
		segment_id = num_control_points - 4;
		}
	u -= ( float )segment_id;

	u_2 = u * u;
	u_3 = u * u_2;

	tmp = 1 - u;
	B[ 0 ] = ( tmp * tmp * tmp ) * ( 1.0f / 6.0f );
	B[ 1 ] = ( 3.0f * u_3 - 6.0f * u_2 + 4.0f ) * ( 1.0f / 6.0f );
	B[ 2 ] = ( -3.0f * u_3 + 3.0f * u_2 + 3.0f * u + 1 ) * ( 1.0f / 6.0f );
	B[ 3 ] = u_3 * ( 1.0f / 6.0f );

	pos = 
		*control_points[ 0 + segment_id ].GetPosition() * B[ 0 ] +
		*control_points[ 1 + segment_id ].GetPosition() * B[ 1 ] +
		*control_points[ 2 + segment_id ].GetPosition() * B[ 2 ] +
		*control_points[ 3 + segment_id ].GetPosition() * B[ 3 ];

	ang = 
		*control_points[ 0 + segment_id ].GetOrientation() * B[ 0 ] +
		*control_points[ 1 + segment_id ].GetOrientation() * B[ 1 ] +
		*control_points[ 2 + segment_id ].GetOrientation() * B[ 2 ] +
		*control_points[ 3 + segment_id ].GetOrientation() * B[ 3 ];

	roll = 
		*control_points[ 0 + segment_id ].GetRoll() * B[ 0 ] +
		*control_points[ 1 + segment_id ].GetRoll() * B[ 1 ] +
		*control_points[ 2 + segment_id ].GetRoll() * B[ 2 ] +
		*control_points[ 3 + segment_id ].GetRoll() * B[ 3 ];

	speed = 
		*control_points[ 0 + segment_id ].GetSpeed() * B[ 0 ] +
		*control_points[ 1 + segment_id ].GetSpeed() * B[ 1 ] +
		*control_points[ 2 + segment_id ].GetSpeed() * B[ 2 ] +
		*control_points[ 3 + segment_id ].GetSpeed() * B[ 3 ];

   orient = ang.toAngles();
   orient[ ROLL ] = roll;

   return speed;
	}

inline float BSpline::EvalLoop
	(
	float t,
   Vector& pos,
   Vector& orient
	)

	{
	Vector	retval;
   Vector   ang;
   float    speed;
   float    roll;
	int		segment_id;
   int      next_id;
	float		B[ 4 ];
	float		tmp;
	float		u;
	float		u_2;
	float		u_3;
	int		i;
	int		j;

	segment_id = ( int )floor( t );
	u = t - floor( t );

	segment_id %= num_control_points;
	if ( segment_id < 0 )
		{
		segment_id += num_control_points;
		}

	u_2 = u * u;
	u_3 = u * u_2;

	tmp = 1 - u;
	B[ 0 ] = ( tmp * tmp * tmp ) * ( 1.0f / 6.0f );
	B[ 1 ] = ( 3.0f * u_3 - 6.0f * u_2 + 4.0f ) * ( 1.0f / 6.0f );
	B[ 2 ] = ( -3.0f * u_3 + 3.0f * u_2 + 3.0f * u + 1 ) * ( 1.0f / 6.0f );
	B[ 3 ] = u_3 * ( 1.0f / 6.0f );

   speed = 0;
   roll = 0;

	for( i = 0, j = segment_id; i < 4; i++, j++ )
		{
		if ( j >= num_control_points )
			{
			j -= ( num_control_points - loop_control_point );
			}

		retval += *control_points[ j ].GetPosition() * B[ i ];
		ang += *control_points[ j ].GetOrientation() * B[ i ];
	   speed += *control_points[ j ].GetSpeed() * B[ i ];
	   roll += *control_points[ j ].GetRoll() * B[ i ];
		}

   pos = retval;

   next_id = segment_id + 1;
	if ( next_id >= num_control_points )
		{
		next_id -= ( num_control_points - loop_control_point );
		}
   orient = ang.toAngles();
   orient[ ROLL ] = roll;

   return speed;
	}

inline float BSpline::EvalClamp
	(
	float t,
   Vector& pos,
   Vector& orient
	)

	{
	Vector	retval;
   Vector   ang;
	int		segment_id;
	int		next_id;
	float		B[ 4 ];
	float		tmp;
	float		u;
	float		u_2;
	float		u_3;
	int		i;
	int		j;
   float    speed;
   float    roll;

	segment_id = ( int )floor( t );
	u = t - floor( t );

	u_2 = u * u;
	u_3 = u * u_2;

	tmp = 1 - u;
	B[ 0 ] = ( tmp * tmp * tmp ) * ( 1.0f / 6.0f );
	B[ 1 ] = ( 3.0f * u_3 - 6.0f * u_2 + 4.0f ) * ( 1.0f / 6.0f );
	B[ 2 ] = ( -3.0f * u_3 + 3.0f * u_2 + 3.0f * u + 1 ) * ( 1.0f / 6.0f );
	B[ 3 ] = u_3 * ( 1.0f / 6.0f );

   speed = 0;
   roll = 0;
	for( i = 0; i < 4; i++, segment_id++ )
		{
		j = segment_id;
		if ( j < 0 )
			{
			j = 0;
			}
		else if ( j >= num_control_points )
			{
			j = num_control_points - 1;
			}

		retval += *control_points[ j ].GetPosition() * B[ i ];
		ang += *control_points[ j ].GetOrientation() * B[ i ];
	   speed += *control_points[ j ].GetSpeed() * B[ i ];
	   roll += *control_points[ j ].GetRoll() * B[ i ];
		}

   pos = retval;

   next_id = segment_id + 1;
   if ( segment_id < 0 )
      {
      segment_id = 0;
      }
	if ( segment_id >= num_control_points )
		{
	   segment_id = num_control_points - 1;
		}
   if ( next_id < 0 )
      {
      next_id = 0;
      }
	if ( next_id >= num_control_points )
		{
	   next_id = num_control_points - 1;
		}
   orient = ang.toAngles();
   orient[ ROLL ] = roll;

   return speed;
	}


Vector BSpline::Eval
	(
	float u
	)

	{
   Vector pos;
   Vector orient;

	switch( curvetype )
		{
		default:
		case SPLINE_NORMAL :
         EvalNormal( u, pos, orient );
			break;

		case SPLINE_CLAMP:
         EvalClamp( u, pos, orient );
			break;

		case SPLINE_LOOP:
         if ( u < 0 )
            {
            EvalClamp( u, pos, orient );
            }
         else
            {
            EvalLoop( u, pos, orient );
            }
			break;
		}
   return pos;
	}

float BSpline::Eval
	(
	float u,
   Vector &pos,
   Vector &orient
	)

	{
	switch( curvetype )
		{
		default:
		case SPLINE_NORMAL :
         return EvalNormal( u, pos, orient );
			break;

		case SPLINE_CLAMP:
         return EvalClamp( u, pos, orient );
			break;

		case SPLINE_LOOP:
         if ( u < 0 )
            {
            return EvalClamp( u, pos, orient );
            }
         else
            {
            return EvalLoop( u, pos, orient );
            }
			break;
		}
	}

void BSpline::DrawControlSegments
	(
	void
	)

	{
	int i;

	G_BeginLine();
	for( i = 0; i < num_control_points; i++ )
		{
		G_Vertex( *control_points[ i ].GetPosition() );
		}
	G_EndLine();
	}

void BSpline::DrawCurve
	(
	int num_subdivisions
	)

	{
	float u;
	float du;

   if ( !num_control_points )
      {
      return;
      }

	du = 1.0f / ( float )num_subdivisions; 

	G_BeginLine();
	for( u = -2.0f; u <= ( float )num_control_points; u += du )
		{
		G_Vertex( ( Vector )Eval( u ) );
		}
	G_EndLine();
	}

void BSpline::DrawCurve
	(
	Vector offset,
	int num_subdivisions
	)

	{
	float u;
	float du;

	du = 1.0f / ( float )num_subdivisions; 

	G_BeginLine();
	for( u = -2.0f; u <= ( float )num_control_points; u += du )
		{
		G_Vertex( offset + ( Vector )Eval( u ) );
		}
	G_EndLine();
	}

void BSpline::AppendControlPoint
	(
	const Vector& new_control_point
	)

	{
	BSplineControlPoint *old_control_points;
	int i;

	old_control_points = control_points;
	num_control_points++;

	control_points = new BSplineControlPoint[num_control_points];
	assert( control_points );

	if ( old_control_points )
		{
		for( i = 0; i < num_control_points - 1; i++ )
			{
			control_points[ i ] = old_control_points[ i ];
			}
		delete [] old_control_points;
		}

	control_points[ num_control_points - 1 ].Set( new_control_point );
	}

void BSpline::AppendControlPoint
	(
	const Vector& new_control_point,
   const float& speed
	)

	{
	BSplineControlPoint *old_control_points;
	int i;

	old_control_points = control_points;
	num_control_points++;

	control_points = new BSplineControlPoint[num_control_points];
	assert( control_points );

	if ( old_control_points )
		{
		for( i = 0; i < num_control_points - 1; i++ )
			{
			control_points[ i ] = old_control_points[ i ];
			}
		delete [] old_control_points;
		}

	control_points[ num_control_points - 1 ].Set( new_control_point, speed );
	}

void BSpline::AppendControlPoint
	(
	const Vector& new_control_point,
   const Vector& new_control_orient,
   const float& new_control_speed
	)

	{
	BSplineControlPoint *old_control_points;
	int i;

   has_orientation = true;

	old_control_points = control_points;
	num_control_points++;

	control_points = new BSplineControlPoint[num_control_points];
	assert( control_points );

	if ( old_control_points )
		{
		for( i = 0; i < num_control_points - 1; i++ )
			{
			control_points[ i ] = old_control_points[ i ];
			}
		delete [] old_control_points;
		}

	control_points[ num_control_points - 1 ].Set( new_control_point, new_control_orient, new_control_speed );
	}

void BSpline::SetLoopPoint
	(
   const Vector& pos
   )
   {
   int i;

	for( i = 0; i < num_control_points; i++ )
		{
		if ( pos == *control_points[ i ].GetPosition() )
         {
         loop_control_point = i;
         break;
         }
      }
   }

int BSpline::PickControlPoint
	(
	const Vector& window_point, 
	float pick_size
	)

	{
	int	i;
	float closest_dist_2;
	int	closest_index;
	float dist_2;
	Vector delta;

	closest_index = -1;
	closest_dist_2 = 1000000.0f;
	for( i = 0; i < num_control_points; i++ )
		{
		delta = window_point - *control_points[ i ].GetPosition();
      dist_2 = delta * delta;
      if ( dist_2 < closest_dist_2 )
			{
			closest_dist_2 = dist_2;
			closest_index = i;
			}
		}

	if ( pick_size * pick_size >= closest_dist_2 )
		{
		return closest_index;
		}
	else
		{
		return -1;
		}
	}

Event EV_SplinePath_Create
	( 
	"SplinePath_create",
	EV_DEFAULT,
   NULL,
   NULL,
   "Creates the spline path from the target list.",
   EV_NORMAL
	);
Event EV_SplinePath_Loop
	( 
	"loop", 
	EV_CONSOLE,
	"s",
   "loop_name",
   "Sets the loop name.",
   EV_NORMAL
	);
Event EV_SplinePath_Speed
	( 
	"speed",
	EV_DEFAULT,
   "f",
   "speed",
   "Sets the path speed.",
   EV_NORMAL
	);
Event EV_SplinePath_SetTriggerTarget
	( 
	"triggertarget",
	EV_DEFAULT,
   "s",
   "target",
   "Sets the trigger target.",
   EV_NORMAL
	);
Event EV_SplinePath_SetWatch
	( 
	"watch",
	EV_CONSOLE,
   "s",
   "watchEntity",
   "Sets the entity to watch at this node.",
   EV_NORMAL
	);

Event EV_SplinePath_SetFov
	( 
	"fov",
	EV_CONSOLE,
   "f",
   "cameraFOV",
   "Sets the fov at this node.",
   EV_NORMAL
	);

Event EV_SplinePath_SetFadeTime
	( 
	"fadetime",
	EV_DEFAULT,
   "f",
   "fadeTime",
   "Sets the fadetime at this node.",
   EV_NORMAL
	);

CLASS_DECLARATION( Entity, SplinePath, "info_splinepath" )
	{
      { &EV_SplinePath_Create,				&SplinePath::CreatePath },
      { &EV_SplinePath_Loop,				&SplinePath::SetLoop },
      { &EV_SplinePath_Speed,				&SplinePath::SetSpeed },
      { &EV_SplinePath_SetTriggerTarget,	&SplinePath::SetTriggerTarget },
      { &EV_SplinePath_SetWatch,			&SplinePath::SetWatch },
      { &EV_SplinePath_SetFov,				&SplinePath::SetFov },
      { &EV_SplinePath_SetFadeTime,			&SplinePath::SetFadeTime },
      { NULL, NULL }
   };

SplinePath::SplinePath()
{
	entflags |= EF_SPLINEPATH;

	AddWaitTill(STRING_REACH);


	owner = this;
	next = NULL;
	loop = NULL;
	speed = 1;
	doWatch = false;
	watchEnt = "";
	fov = 0;
	fadeTime = -1;

	setMoveType( MOVETYPE_NONE );
	setSolidType( SOLID_NOT );
	hideModel();

	if( !LoadingSavegame )
	{
		PostEvent( EV_SplinePath_Create, FRAMETIME );
	}
}

SplinePath::~SplinePath()
   {
   // disconnect from the chain
   if ( owner != this )
      {
      owner->SetNext( next );
      }
   else if ( next )
      {
      next->SetPrev( NULL );
      next = NULL;
      }

   assert( owner == this );
   assert( next == NULL );
   }

void SplinePath::SetLoop 
   (
   Event *ev
   )

   {
   loop_name = ev->GetString( 1 );
   }

void SplinePath::SetSpeed
   (
   Event *ev
   )

   {
   speed = ev->GetFloat( 1 );
   }

void SplinePath::SetTriggerTarget
   (
   Event *ev
   )

   {
   SetTriggerTarget( ev->GetString( 1 ) );
   }

void SplinePath::CreatePath
	(
	Event *ev
	)

   {
   const char  *target;
   Entity      *ent;

   // Make the path from the targetlist.
   target = Target();
   if ( target[ 0 ] )
      {
      ent = ( Entity * )G_FindTarget( NULL, target );
      if ( ent )
         {
         next = ( SplinePath * )ent;
			next->owner = this;
         }
      else
         {
         ScriptError( "SplinePath::CreatePath: target %s not found\n", target );
         }
      }
   if ( loop_name.length() )
      {
      ent = ( Entity * )G_FindTarget( NULL, loop_name.c_str() );
      if ( ent )
         {
         loop = ( SplinePath * )ent;
         }
      }
   } 

SplinePath *SplinePath::GetNext
	(
	void
	)
	
	{
	return next;
	}

SplinePath *SplinePath::GetPrev
	(
	void
	)
	
	{
   if ( owner == this )
      {
      return NULL;
      }

	return owner;
	}

void SplinePath::SetNext
	(
	SplinePath *node
	)
	
	{
   if ( next )
      {
      // remove ourselves from the chain
      next->owner = next;
      }

	next = node;
   if ( next )
      {
      // disconnect next from it's previous node
      if ( next->owner != next )
         {
         next->owner->next = NULL;
         }
      next->owner = this;
      }
	}

void SplinePath::SetPrev
	(
	SplinePath *node
	)
	
	{
   if ( owner != this )
      {
      owner->next = NULL;
      }

   if ( node && ( node != this ) )
      {
      // safely remove the node from its chain
      if ( node->next )
         {
         node->next->owner = node->next;
         }
      node->next = this;
      owner = node;
      }
   else
      {
      owner = this;
      }
	}

SplinePath *SplinePath::GetLoop
	(
	void
	)
	
	{
	return loop;
	}

void SplinePath::SetWatch
   (
   const char *name
   )

   {
   if ( watchEnt != name )
      {
      watchEnt = name;
      if ( watchEnt.length() )
         {
         doWatch = true;
         }
      else
         {
         doWatch = false;
         }
      }
   }

void SplinePath::SetWatch
   (
   Event *ev
   )

   {
   SetWatch( ev->GetString( 1 ) );
   }


void SplinePath::NoWatch
   (
   void
   )

   {
   doWatch = true;
   watchEnt = "none";
   }

str SplinePath::GetWatch
   ( 
   void
   )

   {
   return watchEnt;
   }

void SplinePath::SetFov
   (
   float newFov
   )

   {
   fov = newFov;
   }

void SplinePath::SetFov
   (
   Event *ev
   )

   {
   fov = ev->GetFloat( 1 );
   }

float SplinePath::GetFov
   (
   void
   )

   {
   return fov;
   }

void SplinePath::SetFadeTime
   (
   float newFadeTime
   )

   {
   fadeTime = newFadeTime;
   }

void SplinePath::SetFadeTime
   (
   Event *ev
   )

   {
   fadeTime = ev->GetFloat( 1 );
   }

float SplinePath::GetFadeTime
   (
   void
   )

   {
   return fadeTime;
   }