/*
===========================================================================

Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company. 

This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).  

Doom 3 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 3 of the License, or
(at your option) any later version.

Doom 3 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 Doom 3 Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/




#include "splines.h"

idCameraDef splineList;
idCameraDef *g_splineList = &splineList;

/*
================
glLabeledPoint
================
*/
void glLabeledPoint(idVec4 &color, idVec3 &point, float size, const char *label) {
	qglColor3fv( color.ToFloatPtr() );
	qglPointSize( size );
	qglBegin( GL_POINTS );
	qglVertex3fv( point.ToFloatPtr() );
	qglEnd();
	idVec3 v = point;
	v.x += 1;
	v.y += 1;
	v.z += 1;
	qglRasterPos3fv( v.ToFloatPtr() );
	qglCallLists( strlen(label), GL_UNSIGNED_BYTE, label );
}

/*
================
glBox
================
*/
void glBox(idVec4 &color, idVec3 &point, float size) {
	idVec3 mins(point);
	idVec3 maxs(point);
	mins[0] -= size;
	mins[1] += size;
	mins[2] -= size;
	maxs[0] += size;
	maxs[1] -= size;
	maxs[2] += size;
	idVec4	saveColor;
	qglGetFloatv(GL_CURRENT_COLOR, saveColor.ToFloatPtr());
	qglColor3fv( color.ToFloatPtr() );
	qglBegin(GL_LINE_LOOP);
	qglVertex3f(mins[0],mins[1],mins[2]);
	qglVertex3f(maxs[0],mins[1],mins[2]);
	qglVertex3f(maxs[0],maxs[1],mins[2]);
	qglVertex3f(mins[0],maxs[1],mins[2]);
	qglEnd();
	qglBegin(GL_LINE_LOOP);
	qglVertex3f(mins[0],mins[1],maxs[2]);
	qglVertex3f(maxs[0],mins[1],maxs[2]);
	qglVertex3f(maxs[0],maxs[1],maxs[2]);
	qglVertex3f(mins[0],maxs[1],maxs[2]);
	qglEnd();

	qglBegin(GL_LINES);
  	qglVertex3f(mins[0],mins[1],mins[2]);
	qglVertex3f(mins[0],mins[1],maxs[2]);
	qglVertex3f(mins[0],maxs[1],maxs[2]);
	qglVertex3f(mins[0],maxs[1],mins[2]);
	qglVertex3f(maxs[0],mins[1],mins[2]);
	qglVertex3f(maxs[0],mins[1],maxs[2]);
	qglVertex3f(maxs[0],maxs[1],maxs[2]);
	qglVertex3f(maxs[0],maxs[1],mins[2]);
	qglEnd();
	qglColor4fv(saveColor.ToFloatPtr());

}

/*
================
splineTest
================
*/
void splineTest() {
	//g_splineList->load("p:/doom/base/maps/test_base1.camera");
}

/*
================
splineDraw
================
*/
void splineDraw() {
	//g_splineList->addToRenderer();
}

/*
================
debugLine
================
*/
void debugLine(idVec4 &color, float x, float y, float z, float x2, float y2, float z2) {
	idVec3 from(x, y, z);
	idVec3 to(x2, y2, z2);
	session->rw->DebugLine(color, from, to);
}


/*
=================================================================================

idPointListInterface

=================================================================================
*/

/*
================
idPointListInterface::selectPointByRay
================
*/
int idPointListInterface::selectPointByRay(const idVec3 &origin, const idVec3 &direction, bool single) {
	int		i, besti, count;
	float	d, bestd;
	idVec3	temp, temp2;

	// find the point closest to the ray
	besti = -1;
	bestd = 8;
	count = numPoints();

	for (i=0; i < count; i++) {
		temp = *getPoint(i);
		temp2 = temp;
		temp -= origin;
		d = DotProduct(temp, direction);
		VectorMA (origin, d, direction, temp);
		temp2 -= temp;
		d = temp2.Length();
		if (d <= bestd) {
			bestd = d;
			besti = i;
		}
	}

	if (besti >= 0) {
		selectPoint(besti, single);
	}

	return besti;
}

/*
================
idPointListInterface::isPointSelected
================
*/
int idPointListInterface::isPointSelected(int index) {
	int count = selectedPoints.Num();
	for (int i = 0; i < count; i++) {
		if (selectedPoints[i] == index) {
			return i;
		}
	}
	return -1;
}

/*
================
idPointListInterface::selectPoint
================
*/
int idPointListInterface::selectPoint(int index, bool single) {
	if (index >= 0 && index < numPoints()) {
		if (single) {
			deselectAll();
		} else {
			if (isPointSelected(index) >= 0) {
				selectedPoints.Remove(index);
			}
		}
		return selectedPoints.Append(index);
	}
	return -1;
}

/*
================
idPointListInterface::selectAll
================
*/
void idPointListInterface::selectAll() {
	selectedPoints.Clear();
	for (int i = 0; i < numPoints(); i++) {
		selectedPoints.Append(i);
	}
}

/*
================
idPointListInterface::deselectAll
================
*/
void idPointListInterface::deselectAll() {
	selectedPoints.Clear();
}

/*
================
idPointListInterface::getSelectedPoint
================
*/
idVec3 *idPointListInterface::getSelectedPoint( int index ) {
	assert(index >= 0 && index < numSelectedPoints());
	return getPoint(selectedPoints[index]);
}

/*
================
idPointListInterface::updateSelection
================
*/
void idPointListInterface::updateSelection(const idVec3 &move) {
	int count = selectedPoints.Num();
	for (int i = 0; i < count; i++) {
		*getPoint(selectedPoints[i]) += move;
	}
}

/*
================
idPointListInterface::drawSelection
================
*/
void idPointListInterface::drawSelection() {
	int count = selectedPoints.Num();
	for (int i = 0; i < count; i++) {
		glBox(colorRed, *getPoint(selectedPoints[i]), 4);
	}
}

/*
=================================================================================

idSplineList

=================================================================================
*/

/*
================
idSplineList::clearControl
================
*/
void idSplineList::clearControl() {
	for (int i = 0; i < controlPoints.Num(); i++) {
		delete controlPoints[i];
	}
	controlPoints.Clear();
}

/*
================
idSplineList::clearSpline
================
*/
void idSplineList::clearSpline() {
	for (int i = 0; i < splinePoints.Num(); i++) {
		delete splinePoints[i];
	}
	splinePoints.Clear();
}

/*
================
idSplineList::clear
================
*/
void idSplineList::clear() {
	clearControl();
	clearSpline();
	splineTime.Clear();
	selected = NULL;
	dirty = true;
	activeSegment = 0;
	granularity = 0.025f;
	pathColor = idVec4(1.0f, 0.5f, 0.0f, 1.0f);
	controlColor = idVec4(0.7f, 0.0f, 1.0f, 1.0f);
	segmentColor = idVec4(0.0f, 0.0f, 1.0f, 1.0);
	activeColor = idVec4(1.0f, 0.0f, 0.0f, 1.0f);
}

/*
================
idSplineList::setColors
================
*/
void idSplineList::setColors(idVec4 &path, idVec4 &segment, idVec4 &control, idVec4 &active) {
	pathColor = path;
	segmentColor = segment;
	controlColor = control;
	activeColor = active;
}

/*
================
idSplineList::validTime
================
*/
bool idSplineList::validTime() {
	if (dirty) {
		buildSpline();
	}
	// gcc doesn't allow static casting away from bools
	// why?  I've no idea...
	return (bool)(splineTime.Num() > 0 && splineTime.Num() == splinePoints.Num());
}

/*
================
idSplineList::addToRenderer
================
*/
void idSplineList::addToRenderer() {
	int i;
	idVec3 mins, maxs;

	if (controlPoints.Num() == 0) {
		return;
	}
        
	for(i = 0; i < controlPoints.Num(); i++) {
		VectorCopy(*controlPoints[i], mins);
		VectorCopy(mins, maxs);
		mins[0] -= 8;
		mins[1] += 8;
		mins[2] -= 8;
		maxs[0] += 8;
		maxs[1] -= 8;
		maxs[2] += 8;
		debugLine( colorYellow, mins[0], mins[1], mins[2], maxs[0], mins[1], mins[2]);
		debugLine( colorYellow, maxs[0], mins[1], mins[2], maxs[0], maxs[1], mins[2]);
		debugLine( colorYellow, maxs[0], maxs[1], mins[2], mins[0], maxs[1], mins[2]);
		debugLine( colorYellow, mins[0], maxs[1], mins[2], mins[0], mins[1], mins[2]);
		
		debugLine( colorYellow, mins[0], mins[1], maxs[2], maxs[0], mins[1], maxs[2]);
		debugLine( colorYellow, maxs[0], mins[1], maxs[2], maxs[0], maxs[1], maxs[2]);
		debugLine( colorYellow, maxs[0], maxs[1], maxs[2], mins[0], maxs[1], maxs[2]);
		debugLine( colorYellow, mins[0], maxs[1], maxs[2], mins[0], mins[1], maxs[2]);
	    
	}

	int step = 0;
	idVec3 step1;
	for(i = 3; i < controlPoints.Num(); i++) {
		for (float tension = 0.0f; tension < 1.001f; tension += 0.1f) {
			float x = 0;
			float y = 0;
			float z = 0;
			for (int j = 0; j < 4; j++) {
				x += controlPoints[i - (3 - j)]->x * calcSpline(j, tension);
				y += controlPoints[i - (3 - j)]->y * calcSpline(j, tension);
				z += controlPoints[i - (3 - j)]->z * calcSpline(j, tension);
			}
			if (step == 0) {
				step1[0] = x;
				step1[1] = y;
				step1[2] = z;
				step = 1;
			} else {
				debugLine( colorWhite, step1[0], step1[1], step1[2], x, y, z);
				step = 0;
			}

		}
	}
}

/*
================
idSplineList::buildSpline
================
*/
void idSplineList::buildSpline() {
	int start = Sys_Milliseconds();
	clearSpline();
	for(int i = 3; i < controlPoints.Num(); i++) {
		for (float tension = 0.0f; tension < 1.001f; tension += granularity) {
			float x = 0;
			float y = 0;
			float z = 0;
			for (int j = 0; j < 4; j++) {
				x += controlPoints[i - (3 - j)]->x * calcSpline(j, tension);
				y += controlPoints[i - (3 - j)]->y * calcSpline(j, tension);
				z += controlPoints[i - (3 - j)]->z * calcSpline(j, tension);
			}
			splinePoints.Append(new idVec3(x, y, z));
		}
	}
	dirty = false;
	//common->Printf("Spline build took %f seconds\n", (float)(Sys_Milliseconds() - start) / 1000);
}

/*
================
idSplineList::draw
================
*/
void idSplineList::draw(bool editMode) {
        int i;
        
	if (controlPoints.Num() == 0) {
		return;
	}

	if (dirty) {
		buildSpline();
	}


	qglColor3fv( controlColor.ToFloatPtr() );
	qglPointSize( 5 );
	
	qglBegin(GL_POINTS);
	for (i = 0; i < controlPoints.Num(); i++) {
		qglVertex3fv( (*controlPoints[i]).ToFloatPtr() );
	}
	qglEnd();
	
	if (editMode) {
		for(i = 0; i < controlPoints.Num(); i++) {
			glBox(activeColor, *controlPoints[i], 4);
		}
	}

	//Draw the curve
	qglColor3fv( pathColor.ToFloatPtr() );
	qglBegin(GL_LINE_STRIP);
	int count = splinePoints.Num();
	for (i = 0; i < count; i++) {
		qglVertex3fv( (*splinePoints[i]).ToFloatPtr() );
	}
	qglEnd();

	if (editMode) {
		qglColor3fv( segmentColor.ToFloatPtr() );
		qglPointSize(3);
		qglBegin(GL_POINTS);
		for (i = 0; i < count; i++) {
			qglVertex3fv( (*splinePoints[i]).ToFloatPtr() );
		}
		qglEnd();
	}
	if (count > 0) {
		//assert(activeSegment >=0 && activeSegment < count);
		if (activeSegment >=0 && activeSegment < count) {
			glBox(activeColor, *splinePoints[activeSegment], 6);
			glBox(colorYellow, *splinePoints[activeSegment], 8);
		}
	}

}

/*
================
idSplineList::totalDistance
================
*/
float idSplineList::totalDistance() {

	// FIXME: save dist and return
	// 
	if (controlPoints.Num() == 0) {
		return 0.0f;
	}

	if (dirty) {
		buildSpline();
	}

	float dist = 0.0f;
	idVec3 temp;
	int count = splinePoints.Num();
	for(int i = 1; i < count; i++) {
		temp = *splinePoints[i-1];
		temp -= *splinePoints[i];
		dist += temp.Length();
	}
	return dist;
}

/*
================
idSplineList::initPosition
================
*/
void idSplineList::initPosition(long bt, long totalTime) {

	if (dirty) {
		buildSpline();
	}

	if (splinePoints.Num() == 0) {
		return;
	}

	baseTime = bt;
	time = totalTime;

	// calc distance to travel ( this will soon be broken into time segments )
	splineTime.Clear();
	splineTime.Append(bt);
	double dist = totalDistance();
	double distSoFar = 0.0;
	idVec3 temp;
	int count = splinePoints.Num();
	//for(int i = 2; i < count - 1; i++) {
	for(int i = 1; i < count; i++) {
		temp = *splinePoints[i-1];
		temp -= *splinePoints[i];
		distSoFar += temp.Length();
		double percent = distSoFar / dist;
		percent *= totalTime;
		splineTime.Append(percent + bt);
	}
	assert(splineTime.Num() == splinePoints.Num());
	activeSegment = 0;
}

/*
================
idSplineList::calcSpline
================
*/
float idSplineList::calcSpline(int step, float tension) {
	switch(step) {
		case 0:	return (pow(1 - tension, 3)) / 6;
		case 1:	return (3 * pow(tension, 3) - 6 * pow(tension, 2) + 4) / 6;
		case 2:	return (-3 * pow(tension, 3) + 3 * pow(tension, 2) + 3 * tension + 1) / 6;
		case 3:	return pow(tension, 3) / 6;
	}
	return 0.0f;
}

/*
================
idSplineList::updateSelection
================
*/
void idSplineList::updateSelection(const idVec3 &move) {
	if (selected) {
		dirty = true;
		VectorAdd(*selected, move, *selected);
	}
}

/*
================
idSplineList::setSelectedPoint
================
*/
void idSplineList::setSelectedPoint(idVec3 *p) {
	if (p) {
		p->SnapInt();
		for(int i = 0; i < controlPoints.Num(); i++) {
			if ( (*p).Compare( *controlPoints[i], VECTOR_EPSILON ) ) {
				selected = controlPoints[i];
			}
		}
	} else {
		selected = NULL;
	}
}

/*
================
idSplineList::getPosition
================
*/
const idVec3 *idSplineList::getPosition(long t) {
	static idVec3 interpolatedPos;

	int count = splineTime.Num();
	if (count == 0) {
		return &vec3_zero;
	}

	assert(splineTime.Num() == splinePoints.Num());

#if 0
	float velocity = getVelocity(t);
	float timePassed = t - lastTime;
	lastTime = t;

	// convert to seconds	
	timePassed /= 1000;

	float distToTravel = timePassed * velocity;

	distSoFar += distToTravel;
	float tempDistance = 0;

	idVec3 temp;
	int count = splinePoints.Num();
	//for(int i = 2; i < count - 1; i++) {
	for(int i = 1; i < count; i++) {
		temp = *splinePoints[i-1];
		temp -= *splinePoints[i];
		tempDistance += temp.Length();
		if (tempDistance >= distSoFar) {
			break;
		}
	}

	if (i == count) {
		interpolatedPos = splinePoints[i-1];
	} else {
		double timeHi = splineTime[i + 1];
		double timeLo = splineTime[i - 1];
		double percent = (timeHi - t) / (timeHi - timeLo); 
		idVec3 v1 = *splinePoints[i - 1];
		idVec3 v2 = *splinePoints[i + 1];
		v2 *= (1.0f - percent);
		v1 *= percent;
		v2 += v1;
		interpolatedPos = v2;
	}
	return &interpolatedPos;

#else
	while (activeSegment < count) {
		if (splineTime[activeSegment] >= t) {
			if (activeSegment > 0 && activeSegment < count - 1) {
				double timeHi = splineTime[activeSegment + 1];
				double timeLo = splineTime[activeSegment - 1];
				//float percent = (float)(baseTime + time - t) / time;
				double percent = (timeHi - t) / (timeHi - timeLo); 
				// pick two bounding points
				idVec3 v1 = *splinePoints[activeSegment-1];
				idVec3 v2 = *splinePoints[activeSegment+1];
				v2 *= (1.0f - percent);
				v1 *= percent;
				v2 += v1;
				interpolatedPos = v2;
				return &interpolatedPos;
			}
			return splinePoints[activeSegment];
		} else {
			activeSegment++;
		}
	}
	return splinePoints[count-1];
#endif
}

/*
================
idSplineList::parse
================
*/
void idSplineList::parse( idParser *src ) {
	idToken token;
	idStr key;

	src->ExpectTokenString( "{" );

	while ( 1 ) {
		if ( !src->ExpectAnyToken( &token ) ) {
			break;
		}
		if ( token == "}" ) {
			break;
		}
		// if token is not a brace, it is a key for a key/value pair
		if ( token == "(" ) {
			src->UnreadToken( &token );
			// read the control point
			idVec3 point;
			src->Parse1DMatrix( 3, point.ToFloatPtr() );
			addPoint(point.x, point.y, point.z);
		}
		else {
			key = token;
			src->ReadTokenOnLine( &token );
			if ( !key.Icmp( "granularity" ) ) {
				granularity = atof(token.c_str());
			}
			else if ( !key.Icmp( "name" ) ) {
				name = token;
			}
			else {
				src->Error( "unknown spline list key: %s", key.c_str() );
				break;
			}
		}
	}
	dirty = true;
}

/*
================
idSplineList::write
================
*/
void idSplineList::write( idFile *f, const char *p) {
	f->Printf( "\t\t%s {\n", p );

	//f->Printf( "\t\tname %s\n", name.c_str() );
	f->Printf( "\t\t\tgranularity %f\n", granularity );
	int count = controlPoints.Num();
	for (int i = 0; i < count; i++) {
		f->Printf( "\t\t\t( %f %f %f )\n", controlPoints[i]->x, controlPoints[i]->y, controlPoints[i]->z );
	}
	f->Printf( "\t\t}\n" );
}

/*
=================================================================================

idCamaraDef

=================================================================================
*/

/*
================
idCameraDef::clear
================
*/
void idCameraDef::clear() {
	currentCameraPosition = 0;
	cameraRunning = false;
	lastDirection.Zero();
	baseTime = 30;
	activeTarget = 0;
	name = "camera01";
	fov.SetFOV(90);
	int i;
	for (i = 0; i < targetPositions.Num(); i++) {
		delete targetPositions[i];
	}
	for (i = 0; i < events.Num(); i++) {
		delete events[i];
	}
	delete cameraPosition;
	cameraPosition = NULL;
	events.Clear();
	targetPositions.Clear();
}

/*
================
idCameraDef::startNewCamera
================
*/
idCameraPosition *idCameraDef::startNewCamera( idCameraPosition::positionType type ) {
	clear();
	if (type == idCameraPosition::SPLINE) {
		cameraPosition = new idSplinePosition();
	} else if (type == idCameraPosition::INTERPOLATED) {
		cameraPosition = new idInterpolatedPosition();
	} else {
		cameraPosition = new idFixedPosition();
	}
	return cameraPosition;
}

/*
================
idCameraDef::addTarget
================
*/
void idCameraDef::addTarget(const char *name, idCameraPosition::positionType type) {
	const char *text = (name == NULL) ? va("target0%d", numTargets()+1) : name;
	idCameraPosition *pos = newFromType(type);
	if (pos) {
		pos->setName(name);
		targetPositions.Append(pos);
		activeTarget = numTargets()-1;
		if (activeTarget == 0) {
			// first one
			addEvent(idCameraEvent::EVENT_TARGET, name, 0);
		}
	}
}

/*
================
idCameraDef::getActiveTarget
================
*/
idCameraPosition *idCameraDef::getActiveTarget() {
	if (targetPositions.Num() == 0) {
		addTarget(NULL, idCameraPosition::FIXED);
	}
	return targetPositions[activeTarget];
}

/*
================
idCameraDef::getActiveTarget
================
*/
idCameraPosition *idCameraDef::getActiveTarget(int index) {
	if (targetPositions.Num() == 0) {
		addTarget(NULL, idCameraPosition::FIXED);
		return targetPositions[0];
	}
	return targetPositions[index];
}

/*
================
idCameraDef::setActiveTargetByName
================
*/
void idCameraDef::setActiveTargetByName( const char *name ) {
	for (int i = 0; i < targetPositions.Num(); i++) {
		if (idStr::Icmp(name, targetPositions[i]->getName()) == 0) {
			setActiveTarget(i);
			return;
		}
	}
}

/*
================
idCameraDef::setActiveTarget
================
*/
void idCameraDef::setActiveTarget( int index ) {
	assert(index >= 0 && index < targetPositions.Num());
	activeTarget = index;
}

/*
================
idCameraDef::draw
================
*/
void idCameraDef::draw( bool editMode ) {
            // gcc doesn't allow casting away from bools
            // why?  I've no idea...
	if (cameraPosition) {
		cameraPosition->draw((bool)((editMode || cameraRunning) && cameraEdit));
		int count = targetPositions.Num();
		for (int i = 0; i < count; i++) {
			targetPositions[i]->draw((bool)((editMode || cameraRunning) && i == activeTarget && !cameraEdit));
		}
	}
}

/*
================
idCameraDef::numPoints
================
*/
int idCameraDef::numPoints() {
	if (cameraEdit) {
		return cameraPosition->numPoints();
	}
	return getActiveTarget()->numPoints();
}

/*
================
idCameraDef::getPoint
================
*/
const idVec3 *idCameraDef::getPoint(int index) {
	if (cameraEdit) {
		return cameraPosition->getPoint(index);
	}
	return getActiveTarget()->getPoint(index);
}

/*
================
idCameraDef::stopEdit
================
*/
void idCameraDef::stopEdit() {
	editMode = false;
	if (cameraEdit) {
		cameraPosition->stopEdit();
	} else {
		getActiveTarget()->stopEdit();
	}
}

/*
================
idCameraDef::startEdit
================
*/
void idCameraDef::startEdit(bool camera) {
	cameraEdit = camera;
	if (camera) {
		cameraPosition->startEdit();
		for (int i = 0; i < targetPositions.Num(); i++) {
			targetPositions[i]->stopEdit();
		}
	} else {
		getActiveTarget()->startEdit();
		cameraPosition->stopEdit();
	}
	editMode = true;
}

/*
================
idCameraDef::getPositionObj
================
*/
idCameraPosition *idCameraDef::getPositionObj() {
	if (cameraPosition == NULL) {
		cameraPosition = new idFixedPosition();
	}
	return cameraPosition;
}

/*
================
idCameraDef::getActiveSegmentInfo
================
*/
void idCameraDef::getActiveSegmentInfo(int segment, idVec3 &origin, idVec3 &direction, float *fov) {
#if 0
	if (!cameraSpline.validTime()) {
		buildCamera();
	}
	double d = (double)segment / numSegments();
	getCameraInfo(d * totalTime * 1000, origin, direction, fov);
#endif
/*
	if (!cameraSpline.validTime()) {
		buildCamera();
	}
	origin = *cameraSpline.getSegmentPoint(segment);
	

	idVec3 temp;

	int numTargets = getTargetSpline()->controlPoints.Num();
	int count = cameraSpline.splineTime.Num();
	if (numTargets == 0) {
		// follow the path
		if (cameraSpline.getActiveSegment() < count - 1) {
			temp = *cameraSpline.splinePoints[cameraSpline.getActiveSegment()+1];
		}
	} else if (numTargets == 1) {
		temp = *getTargetSpline()->controlPoints[0];
	} else {
		temp = *getTargetSpline()->getSegmentPoint(segment);
	}

	temp -= origin;
	temp.Normalize();
	direction = temp;
*/
}

/*
================
idCameraDef::getCameraInfo
================
*/
bool idCameraDef::getCameraInfo(long time, idVec3 &origin, idVec3 &direction, float *fv) {
	char	buff[ 1024 ];
	int		i;

	if ((time - startTime) / 1000 <= totalTime) {

		for( i = 0; i < events.Num(); i++ ) {
			if (time >= startTime + events[i]->getTime() && !events[i]->getTriggered()) {
				events[i]->setTriggered(true);
				if (events[i]->getType() == idCameraEvent::EVENT_TARGET) {
					setActiveTargetByName(events[i]->getParam());
					getActiveTarget()->start(startTime + events[i]->getTime());
					//common->Printf("Triggered event switch to target: %s\n",events[i]->getParam());
				} else if (events[i]->getType() == idCameraEvent::EVENT_TRIGGER) {
#if 0
//FIXME: seperate game and editor spline code
					idEntity *ent;
					ent = gameLocal.FindEntity( events[i]->getParam() );
					if (ent) {
						ent->Signal( SIG_TRIGGER );
						ent->ProcessEvent( &EV_Activate, gameLocal.world );
					}
#endif
				} else if (events[i]->getType() == idCameraEvent::EVENT_FOV) {
					memset(buff, 0, sizeof(buff));
					strcpy(buff, events[i]->getParam());
					const char *param1 = strtok(buff, " \t,\0");
					const char *param2 = strtok(NULL, " \t,\0");
					fov.reset(fov.GetFOV(time), atof(param1), time, atoi(param2)); 
					//*fv = fov = atof(events[i]->getParam());
				} else if (events[i]->getType() == idCameraEvent::EVENT_CAMERA) {
				} else if (events[i]->getType() == idCameraEvent::EVENT_STOP) {
					return false;
				}
			}
		}
	} else {
	}

	origin = *cameraPosition->getPosition(time);
	
	*fv = fov.GetFOV(time);

	idVec3 temp = origin;

	int numTargets = targetPositions.Num();
	if (numTargets == 0) {
/*
		// follow the path
		if (cameraSpline.getActiveSegment() < count - 1) {
			temp = *cameraSpline.splinePoints[cameraSpline.getActiveSegment()+1];
			if (temp == origin) {
				int index = cameraSpline.getActiveSegment() + 2;
				while (temp == origin && index < count - 1) {
					temp = *cameraSpline.splinePoints[index++];
				}
			}
		}
*/
	} else {
		temp = *getActiveTarget()->getPosition(time);
	}
	
	temp -= origin;
	temp.Normalize();
	direction = temp;

	return true;
}

/*
================
idCameraDef::waitEvent
================
*/
bool idCameraDef::waitEvent(int index) {
	//for (int i = 0; i < events.Num(); i++) {
	//	if (events[i]->getSegment() == index && events[i]->getType() == idCameraEvent::EVENT_WAIT) {
	//		return true;
	//	}
    //}
	return false;
}

/*
================
idCameraDef::buildCamera
================
*/
#define NUM_CCELERATION_SEGS 10
#define CELL_AMT 5

void idCameraDef::buildCamera() {
	int i;
	int lastSwitch = 0;
	idList<float> waits;
	idList<int> targets;

	totalTime = baseTime;
	cameraPosition->setTime(totalTime * 1000);
	// we have a base time layout for the path and the target path
	// now we need to layer on any wait or speed changes
	for (i = 0; i < events.Num(); i++) {
		idCameraEvent *ev = events[i];
		events[i]->setTriggered(false);
		switch (events[i]->getType()) {
			case idCameraEvent::EVENT_TARGET : {
				targets.Append(i);
				break;
			}
			case idCameraEvent::EVENT_FEATHER : {
				long startTime = 0;
				float speed = 0;
				long loopTime = 10;
				float stepGoal = cameraPosition->getBaseVelocity() / (1000 / loopTime);
				while (startTime <= 1000) {
					cameraPosition->addVelocity(startTime, loopTime, speed);
					speed += stepGoal;
					if (speed > cameraPosition->getBaseVelocity()) {
						speed = cameraPosition->getBaseVelocity();
					}
					startTime += loopTime;
				}

				startTime = totalTime * 1000 - 1000;
				long endTime = startTime + 1000;
				speed = cameraPosition->getBaseVelocity();
				while (startTime < endTime) {
					speed -= stepGoal;
					if (speed < 0) {
						speed = 0;
					}
					cameraPosition->addVelocity(startTime, loopTime, speed);
					startTime += loopTime;
				}
				break;

			}
			case idCameraEvent::EVENT_WAIT : {
				waits.Append(atof(events[i]->getParam()));

				//FIXME: this is quite hacky for Wolf E3, accel and decel needs
				// do be parameter based etc.. 
				long startTime = events[i]->getTime() - 1000;
				if (startTime < 0) {
					startTime = 0;
				}
				float speed = cameraPosition->getBaseVelocity();
				long loopTime = 10;
				float steps = speed / ((events[i]->getTime() - startTime) / loopTime);
				while (startTime <= events[i]->getTime() - loopTime) {
					cameraPosition->addVelocity(startTime, loopTime, speed);
					speed -= steps;
					startTime += loopTime;
				}
				cameraPosition->addVelocity(events[i]->getTime(), atof(events[i]->getParam()) * 1000, 0);

				startTime = events[i]->getTime() + atof(events[i]->getParam()) * 1000;
				long endTime = startTime + 1000;
				speed = 0;
				while (startTime <= endTime) {
					cameraPosition->addVelocity(startTime, loopTime, speed);
					speed += steps;
					startTime += loopTime;
				}
				break;
			}
			case idCameraEvent::EVENT_TARGETWAIT : {
				//targetWaits.Append(i);
				break;
			}
			case idCameraEvent::EVENT_SPEED : {
/*
				// take the average delay between up to the next five segments
				float adjust = atof(events[i]->getParam());
				int index = events[i]->getSegment();
				total = 0;
				count = 0;

				// get total amount of time over the remainder of the segment
				for (j = index; j < cameraSpline.numSegments() - 1; j++) {
					total += cameraSpline.getSegmentTime(j + 1) - cameraSpline.getSegmentTime(j);
					count++;
				}

				// multiply that by the adjustment
				double newTotal = total * adjust;
				// what is the difference.. 
				newTotal -= total;
				totalTime += newTotal / 1000;

				// per segment difference
				newTotal /= count;
				int additive = newTotal;

				// now propogate that difference out to each segment
				for (j = index; j < cameraSpline.numSegments(); j++) {
					cameraSpline.addSegmentTime(j, additive);
					additive += newTotal;
				}
				break;
*/
			}
		}
	}


	for (i = 0; i < waits.Num(); i++) {
		totalTime += waits[i];
	}

	// on a new target switch, we need to take time to this point ( since last target switch ) 
	// and allocate it across the active target, then reset time to this point
	long timeSoFar = 0;
	long total = totalTime * 1000;
	for (i = 0; i < targets.Num(); i++) {
		long t;
		if (i < targets.Num() - 1) {
			t = events[targets[i+1]]->getTime();
		} else {
			t = total - timeSoFar;
		}
		// t is how much time to use for this target
		setActiveTargetByName(events[targets[i]]->getParam());
		getActiveTarget()->setTime(t);
		timeSoFar += t;
	}
}

/*
================
idCameraDef::startCamera
================
*/
void idCameraDef::startCamera(long t) {
	cameraPosition->clearVelocities();
	cameraPosition->start(t);
	buildCamera();
	//for (int i = 0; i < targetPositions.Num(); i++) {
	//	targetPositions[i]->
	//}
	startTime = t;
	cameraRunning = true;
}

/*
================
idCameraDef::parse
================
*/
void idCameraDef::parse( idParser *src  ) {
	idToken token;

	src->ReadToken(&token);
	src->ExpectTokenString( "{" );
	while ( 1 ) {

		src->ExpectAnyToken( &token );

		if ( token == "}" ) {
			break;
		}
		else if ( !token.Icmp( "time" ) ) {
			baseTime = src->ParseFloat();
		}
		else if ( !token.Icmp( "camera_fixed") ) {
			cameraPosition = new idFixedPosition();
			cameraPosition->parse( src );
		}
		else if ( !token.Icmp( "camera_interpolated") ) {
			cameraPosition = new idInterpolatedPosition();
			cameraPosition->parse( src );
		}
		else if ( !token.Icmp( "camera_spline") ) {
			cameraPosition = new idSplinePosition();
			cameraPosition->parse( src );
		}
		else if ( !token.Icmp( "target_fixed") ) {
			idFixedPosition *pos = new idFixedPosition();
			pos->parse( src );
			targetPositions.Append(pos);
		}
		else if ( !token.Icmp( "target_interpolated") ) {
			idInterpolatedPosition *pos = new idInterpolatedPosition();
			pos->parse( src );
			targetPositions.Append(pos);
		}
		else if ( !token.Icmp( "target_spline") ) {
			idSplinePosition *pos = new idSplinePosition();
			pos->parse( src );
			targetPositions.Append(pos);
		}
		else if ( !token.Icmp( "fov") ) {
			fov.parse( src );
		}
		else if ( !token.Icmp( "event") ) {
			idCameraEvent *event = new idCameraEvent();
			event->parse( src );
			addEvent(event);
		}
		else {
			src->Error( "unknown camera def: %s", token.c_str() );
			break;
		}
	}

	if ( !cameraPosition ) {
		common->Printf( "no camera position specified\n" );
		// prevent a crash later on
		cameraPosition = new idFixedPosition();
	}
}

/*
================
idCameraDef::load
================
*/
bool idCameraDef::load( const char *filename ) {
	idParser *src;

	src = new idParser( filename, LEXFL_NOSTRINGCONCAT | LEXFL_NOSTRINGESCAPECHARS | LEXFL_ALLOWPATHNAMES );
	if ( !src->IsLoaded() ) {
		common->Printf( "couldn't load %s\n", filename );
		delete src;
		return false;
	}

	clear();
	parse( src );

	delete src;

	return true;
}

/*
================
idCameraDef::save
================
*/
void idCameraDef::save(const char *filename) {
	idFile *f = fileSystem->OpenFileWrite( filename, "fs_cdpath" );
	if ( f ) {
		int i;
		f->Printf( "cameraPathDef { \n" );
		f->Printf( "\ttime %f\n", baseTime );

		cameraPosition->write( f, va("camera_%s",cameraPosition->typeStr()) );

		for (i = 0; i < numTargets(); i++) {
			targetPositions[i]->write( f, va("target_%s", targetPositions[i]->typeStr()) );
		}

		for (i = 0; i < events.Num(); i++) {
			events[i]->write( f, "event" );
		}

		fov.write( f, "fov" );

		f->Printf( "}\n" );
	}
	fileSystem->CloseFile( f );
}

/*
================
idCameraDef::sortEvents
================
*/
int idCameraDef::sortEvents(const void *p1, const void *p2) {
	idCameraEvent *ev1 = (idCameraEvent*)(p1);
	idCameraEvent *ev2 = (idCameraEvent*)(p2);

	if (ev1->getTime() > ev2->getTime()) {
		return -1;
	}
	if (ev1->getTime() < ev2->getTime()) {
		return 1;
	}
	return 0; 
}

/*
================
idCameraDef::addEvent
================
*/
void idCameraDef::addEvent(idCameraEvent *event) {
	events.Append(event);
	//events.Sort(&sortEvents);

}

/*
================
idCameraDef::addEvent
================
*/
void idCameraDef::addEvent(idCameraEvent::eventType t, const char *param, long time) {
	addEvent(new idCameraEvent(t, param, time));
	buildCamera();
}

/*
================
idCameraDef::newFromType
================
*/
idCameraPosition *idCameraDef::newFromType( idCameraPosition::positionType t ) {
	switch (t) {
		case idCameraPosition::FIXED : return new idFixedPosition();
		case idCameraPosition::INTERPOLATED : return new idInterpolatedPosition();
		case idCameraPosition::SPLINE : return new idSplinePosition();
	};
	return NULL;
}


/*
=================================================================================

idCamaraEvent

=================================================================================
*/

/*
================
idCameraEvent::eventStr
================
*/
const char *idCameraEvent::eventStr[] = {
	"NA",
	"WAIT",
	"TARGETWAIT",
	"SPEED",
	"TARGET",
	"SNAPTARGET",
	"FOV",
	"CMD",
	"TRIGGER",
	"STOP",
	"CAMERA",
	"FADEOUT",
	"FADEIN",
	"FEATHER"
};

/*
================
idCameraEvent::parse
================
*/
void idCameraEvent::parse( idParser *src ) {
	idToken token;
	idStr key;

	src->ExpectTokenString( "{" );

	while ( 1 ) {

		if ( !src->ExpectAnyToken( &token ) ) {
			break;
		}
		if ( token == "}" ) {
			break;
		}

		key = token;
		src->ReadTokenOnLine( &token );
		if ( !key.Icmp( "type" ) ) {
			type = static_cast<idCameraEvent::eventType>(atoi(token.c_str()));
		}
		else if ( !key.Icmp( "param" ) ) {
			paramStr = token;
		}
		else if ( !key.Icmp( "time" ) ) {
			time = atoi(token.c_str());
		}
		else {
			src->Error( "unknown camera event key: %s", key.c_str() );
			break;
		}
	}
}

/*
================
idCameraEvent::write
================
*/
void idCameraEvent::write( idFile *f, const char *name) {
	f->Printf( "\t%s {\n", name );
	f->Printf( "\t\ttype %d\n", static_cast<int>(type) );
	f->Printf( "\t\tparam \"%s\"\n", paramStr.c_str() );
	f->Printf( "\t\ttime %d\n", time );
	f->Printf( "\t}\n" );
}

/*
=================================================================================

idCamaraPosition

=================================================================================
*/

/*
================
idCameraPosition::positionStr
================
*/
const char *idCameraPosition::positionStr[] = {
	"Fixed",
	"Interpolated",
	"Spline",
};

/*
================
idCameraPosition::positionStr
================
*/
void idCameraPosition::clearVelocities() {
	for (int i = 0; i < velocities.Num(); i++) {
		delete velocities[i];
		velocities[i] = NULL;
	}
	velocities.Clear();
}

/*
================
idCameraPosition::positionStr
================
*/
float idCameraPosition::getVelocity( long t ) {
	long check = t - startTime;
	for ( int i = 0; i < velocities.Num(); i++ ) {
		if (check >= velocities[i]->startTime && check <= velocities[i]->startTime + velocities[i]->time) {
			return velocities[i]->speed;
		}
	}
	return baseVelocity;
}

/*
================
idCameraPosition::parseToken
================
*/
bool idCameraPosition::parseToken( const idStr &key, idParser *src ) {
	idToken token;

	if ( !key.Icmp( "time" ) ) {
		time = src->ParseInt();
		return true;
	}
	else if ( !key.Icmp( "type" ) ) {
		type = static_cast<idCameraPosition::positionType> ( src->ParseInt() );
		return true;
	}
	else if ( !key.Icmp( "velocity" ) ) {
		long t = atol(token);
		long d = src->ParseInt();
		float s = src->ParseFloat();
		addVelocity(t, d, s);
		return true;
	}
	else if ( !key.Icmp( "baseVelocity" ) ) {
		baseVelocity = src->ParseFloat();
		return true;
	}
	else if ( !key.Icmp( "name" ) ) {
		src->ReadToken( &token );
		name = token;
		return true;
	}
	else if ( !key.Icmp( "time" ) ) {
		time = src->ParseInt();
		return true;
	}
	else {
		src->Error( "unknown camera position key: %s", key.c_str() );
		return false;
	}
}

/*
================
idCameraPosition::write
================
*/
void idCameraPosition::write( idFile *f, const char *p ) {
	f->Printf( "\t\ttime %i\n", time );
	f->Printf( "\t\ttype %i\n", static_cast<int>(type) );
	f->Printf( "\t\tname %s\n", name.c_str() );
	f->Printf( "\t\tbaseVelocity %f\n", baseVelocity );
	for (int i = 0; i < velocities.Num(); i++) {
		f->Printf( "\t\tvelocity %i %i %f\n", velocities[i]->startTime, velocities[i]->time, velocities[i]->speed );
	}
}

/*
=================================================================================

idInterpolatedPosition

=================================================================================
*/

/*
================
idInterpolatedPosition::getPoint
================
*/
idVec3 *idInterpolatedPosition::getPoint( int index ) {
	assert( index >= 0 && index < 2 );
	if ( index == 0 ) {
		return &startPos;
	}
	return &endPos;
}

/*
================
idInterpolatedPosition::addPoint
================
*/
void idInterpolatedPosition::addPoint( const float x, const float y, const float z ) {
	if (first) {
		startPos.Set(x, y, z);
		first = false;
	} else {
		endPos.Set(x, y, z);
		first = true;
	}
}

/*
================
idInterpolatedPosition::addPoint
================
*/
void idInterpolatedPosition::addPoint( const idVec3 &v ) {
	if (first) {
		startPos = v;
		first = false;
	}
	else {
		endPos = v;
		first = true;
	}
}

/*
================
idInterpolatedPosition::draw
================
*/
void idInterpolatedPosition::draw( bool editMode ) {
	glLabeledPoint(colorBlue, startPos, (editMode) ? 5 : 3, "Start interpolated");
	glLabeledPoint(colorBlue, endPos, (editMode) ? 5 : 3, "End interpolated");
	qglBegin(GL_LINES);
	qglVertex3fv( startPos.ToFloatPtr() );
	qglVertex3fv( endPos.ToFloatPtr() );
	qglEnd();
}

/*
================
idInterpolatedPosition::start
================
*/
void idInterpolatedPosition::start( long t ) {
	idCameraPosition::start(t);
	lastTime = startTime;
	distSoFar = 0.0f;
	idVec3 temp = startPos;
	temp -= endPos;
	calcVelocity(temp.Length());
}

/*
================
idInterpolatedPosition::getPosition
================
*/
const idVec3 *idInterpolatedPosition::getPosition( long t ) { 
	static idVec3 interpolatedPos;

	if (t - startTime > 6000) {
		int i = 0;
	}

	float velocity = getVelocity(t);
	float timePassed = t - lastTime;
	lastTime = t;

	// convert to seconds	
	timePassed /= 1000;

	if (velocity != getBaseVelocity()) {
		int i = 0;
	}

	float distToTravel = timePassed * velocity;

	idVec3 temp = startPos;
	temp -= endPos;
	float distance = temp.Length();

	distSoFar += distToTravel;
	float percent = (float)(distSoFar) / distance;

	if ( percent > 1.0f ) {
		percent = 1.0f;
	} else if ( percent < 0.0f ) {
		percent = 0.0f;
	}

	// the following line does a straigt calc on percentage of time
	// float percent = (float)(startTime + time - t) / time;

	idVec3 v1 = startPos;
	idVec3 v2 = endPos;
	v1 *= (1.0f - percent);
	v2 *= percent;
	v1 += v2;
	interpolatedPos = v1;
	return &interpolatedPos;
}

/*
================
idInterpolatedPosition::parse
================
*/
void idInterpolatedPosition::parse( idParser *src ) {
	idToken token;

	src->ExpectTokenString( "{" );
	while ( 1 ) {
		if ( !src->ExpectAnyToken( &token ) ) {
			break;
		}
		if ( token == "}" ) {
			break;
		}

		if ( !token.Icmp( "startPos" ) ) {
			src->Parse1DMatrix( 3, startPos.ToFloatPtr() );
		}
		else if ( !token.Icmp( "endPos" ) ) {
			src->Parse1DMatrix( 3, endPos.ToFloatPtr() );
		}
		else {
			idCameraPosition::parseToken( token, src);
		}
	}
}

/*
================
idInterpolatedPosition::write
================
*/
void idInterpolatedPosition::write( idFile *f, const char *p ) {
	f->Printf( "\t%s {\n", p );
	idCameraPosition::write( f, p );
	f->Printf( "\t\tstartPos ( %f %f %f )\n", startPos.x, startPos.y, startPos.z );
	f->Printf( "\t\tendPos ( %f %f %f )\n", endPos.x, endPos.y, endPos.z );
	f->Printf( "\t}\n" );
}

/*
=================================================================================

idCameraFOV

=================================================================================
*/

/*
================
idCameraFOV::GetFOV
================
*/
float idCameraFOV::GetFOV( long t ) {
	if (time) {
		assert(startTime);
		float percent = (t - startTime) / length;
		if ( percent < 0.0f ) {
			percent = 0.0f;
		} else if ( percent > 1.0f ) {
			percent = 1.0f;
		}
		float temp = endFOV - startFOV;
		temp *= percent;
		fov = startFOV + temp;
	}
	return fov;
}

/*
================
idCameraFOV::reset
================
*/
void idCameraFOV::reset( float startfov, float endfov, int start, int len ) {
	startFOV = startfov;
	endFOV = endfov;
	startTime = start;
	length = len;
}

/*
================
idCameraFOV::parse
================
*/
void idCameraFOV::parse( idParser *src ) {
	idToken token;

	src->ExpectTokenString( "{" );
	while ( 1 ) {
		if ( !src->ExpectAnyToken( &token ) ) {
			break;
		}
		if ( token == "}" ) {
			break;
		}

		if ( !token.Icmp( "fov" ) ) {
			fov = src->ParseFloat();
		}
		else if ( !token.Icmp( "startFOV" ) ) {
			startFOV = src->ParseFloat();
		}
		else if ( !token.Icmp( "endFOV" ) ) {
			endFOV = src->ParseFloat();
		}
		else if ( !token.Icmp( "time" ) ) {
			time = src->ParseInt();
		}
		else {
			src->Error( "unknown camera FOV key: %s", token.c_str() );
			break;
		}
	}
}

/*
================
idCameraFOV::write
================
*/
void idCameraFOV::write( idFile *f, const char *p ) {
	f->Printf( "\t%s {\n", p );
	f->Printf( "\t\tfov %f\n", fov );
	f->Printf( "\t\tstartFOV %f\n", startFOV );
	f->Printf( "\t\tendFOV %f\n", endFOV );
	f->Printf( "\t\ttime %i\n", time );
	f->Printf( "\t}\n" );
}

/*
=================================================================================

idFixedPosition

=================================================================================
*/

/*
================
idFixedPosition::parse
================
*/
void idFixedPosition::parse( idParser *src ) {
	idToken token;

	src->ExpectTokenString( "{" );
	while ( 1 ) {
		if ( !src->ExpectAnyToken( &token ) ) {
			break;
		}
		if ( token == "}" ) {
			break;
		}

		if ( !token.Icmp( "pos" ) ) {
			src->Parse1DMatrix( 3, pos.ToFloatPtr() );
		}
		else {
			idCameraPosition::parseToken( token, src );
		}
	}
}

/*
================
idFixedPosition::write
================
*/
void idFixedPosition::write( idFile *f, const char *p ) {
	f->Printf( "\t%s {\n", p );
	idCameraPosition::write( f, p );
	f->Printf( "\t\tpos ( %f %f %f )\n", pos.x, pos.y, pos.z );
	f->Printf( "\t}\n" );
}

/*
=================================================================================

idSplinePosition

=================================================================================
*/

/*
================
idSplinePosition::start
================
*/
void idSplinePosition::start( long t ) {
	idCameraPosition::start( t );
	target.initPosition(t, time);
	lastTime = startTime;
	distSoFar = 0.0f;
	calcVelocity(target.totalDistance());
}

/*
================
idSplinePosition::parse
================
*/
void idSplinePosition::parse( idParser *src ) {
	idToken token;

	src->ExpectTokenString( "{" );
	while ( 1 ) {
		if ( !src->ExpectAnyToken( &token ) ) {
			break;
		}
		if ( token == "}" ) {
			break;
		}
		if ( !token.Icmp( "target" ) ) {
			target.parse( src );
		}
		else {
			idCameraPosition::parseToken( token, src );	
		}
	}
}

/*
================
idSplinePosition::write
================
*/
void idSplinePosition::write( idFile *f, const char *p ) {
	f->Printf( "\t%s {\n", p );
	idCameraPosition::write( f, p );
	target.write( f, "target" );
	f->Printf( "\t}\n" );
}

/*
================
idSplinePosition::getPosition
================
*/
const idVec3 *idSplinePosition::getPosition(long t) {
	static idVec3 interpolatedPos;

	float velocity = getVelocity(t);
	float timePassed = t - lastTime;
	lastTime = t;

	// convert to seconds	
	timePassed /= 1000;

	float distToTravel = timePassed * velocity;

	distSoFar += distToTravel;
	double tempDistance = target.totalDistance();

	double percent = (double)(distSoFar) / tempDistance;

	double targetDistance = percent * tempDistance;
	tempDistance = 0;

	double lastDistance1,lastDistance2;
	lastDistance1 = lastDistance2 = 0;
	//FIXME: calc distances on spline build
	idVec3 temp;
	int count = target.numSegments();
	//for(int i = 2; i < count - 1; i++) {
	int i;
	for( i = 1; i < count; i++) {
		temp = *target.getSegmentPoint(i-1);
		temp -= *target.getSegmentPoint(i);
		tempDistance += temp.Length();
		if (i & 1) {
			lastDistance1 = tempDistance;
		} else {
			lastDistance2 = tempDistance;
		}
		if (tempDistance >= targetDistance) {
			break;
		}
	}

	if (i >= count - 1) {
		interpolatedPos = *target.getSegmentPoint(i-1);
	} else {
#if 0
		double timeHi = target.getSegmentTime(i + 1);
		double timeLo = target.getSegmentTime(i - 1);
		double percent = (timeHi - t) / (timeHi - timeLo); 
		idVec3 v1 = *target.getSegmentPoint(i - 1);
		idVec3 v2 = *target.getSegmentPoint(i + 1);
		v2 *= (1.0f - percent);
		v1 *= percent;
		v2 += v1;
		interpolatedPos = v2;
#else
		if (lastDistance1 > lastDistance2) {
			double d = lastDistance2;
			lastDistance2 = lastDistance1;
			lastDistance1 = d;
		}

		idVec3 v1 = *target.getSegmentPoint(i - 1);
		idVec3 v2 = *target.getSegmentPoint(i);
		double percent = (lastDistance2 - targetDistance) / (lastDistance2 - lastDistance1); 
		v2 *= (1.0f - percent);
		v1 *= percent;
		v2 += v1;
		interpolatedPos = v2;
#endif
	}
	return &interpolatedPos;

}
