/**********************************************************************

 *<

	FILE:  control.h



	DESCRIPTION:  Control definitions



	CREATED BY:  Dan Silva and Rolf Berteig



	HISTORY: created 9 September 1994



 *>	Copyright (c) 1994, All Rights Reserved.

 **********************************************************************/



#ifndef __CONTROL__



#define __CONTROL__



#include "plugapi.h"



extern CoreExport void ApplyScaling(Matrix3 &m, const ScaleValue &v);

extern CoreExport void InitControlLists();





class ScaleValue;

class ViewExp;

class INode;

class XFormModes;

class INodeTab;



CoreExport ScaleValue operator+(const ScaleValue& s0, const ScaleValue& s1);

CoreExport ScaleValue operator-(const ScaleValue& s0, const ScaleValue& s1);

CoreExport ScaleValue operator*(const ScaleValue& s, float f);

CoreExport ScaleValue operator*(float f, const ScaleValue& s);

CoreExport ScaleValue operator+(const ScaleValue& s, float f);

CoreExport ScaleValue operator+(float f, const ScaleValue& s);



class ScaleValue {

	public:

	Point3 s;

	Quat q;

	ScaleValue() {}

	ScaleValue(const Point3& as) { s = as; q = IdentQuat(); }

	ScaleValue(const Point3& as, const Quat& aq) {s = as; q = aq;}

	ScaleValue& operator+=(const ScaleValue& s) {(*this)=(*this)+s;return (*this);}

	ScaleValue& operator*=(const float s) {(*this)=(*this)*s;return (*this);}

	ScaleValue& operator=(const ScaleValue &v) {s=v.s;q=v.q;return (*this);}

	float& operator[](int el) {return s[el];}

	};



// Types of ORTs

#define ORT_BEFORE	1

#define ORT_AFTER	2



// ORTs

#define ORT_CONSTANT			1

#define ORT_CYCLE				2

#define ORT_LOOP				3	// This is cycle with continuity.

#define ORT_OSCILLATE			4

#define ORT_LINEAR				5

#define ORT_IDENTITY			6

#define ORT_RELATIVE_REPEAT		7



/*---------------------------------------------------------------------*/



// A list of ease curves.

class EaseCurveList : public ReferenceTarget {

		friend class AddEaseRestore;

		friend class DeleteEaseRestore;



	private:

		Tab<Control*> eases;

		

	public:

	 	EaseCurveList() {OpenTreeEntry(1);}

	  	CoreExport ~EaseCurveList();



		CoreExport TimeValue ApplyEase(TimeValue t,Interval &valid);

		CoreExport void AppendEaseCurve(Control *cont);

		CoreExport void DeleteEaseCurve(int i);

		CoreExport void DisableEaseCurve(int i);

		CoreExport void EnableEaseCurve(int i);

		CoreExport BOOL IsEaseEnabled(int i);

		int NumEaseCurves() {return eases.Count();}



		// Animatable

		void GetClassName(TSTR& s) { s= TSTR(_T("EaseCurve")); }  

		Class_ID ClassID() { return Class_ID(EASE_LIST_CLASS_ID,0); }

		SClass_ID SuperClassID() { return EASE_LIST_CLASS_ID; }		

		CoreExport int NumSubs();

		CoreExport Animatable* SubAnim(int i);

		CoreExport TSTR SubAnimName(int i);

		BOOL BypassTreeView() { return TRUE; }

		void DeleteThis() { delete this; }

		ParamDimension* GetParamDimension(int i) {return stdTimeDim;}

		CoreExport BOOL AssignController(Animatable *control,int subAnim);

		CoreExport void* GetInterface(ULONG id);



		CoreExport IOResult Save(ISave *isave);

		CoreExport IOResult Load(ILoad *iload);

		

		// Reference

		CoreExport int NumRefs();

		CoreExport RefTargetHandle GetReference(int i);

		CoreExport void SetReference(int i, RefTargetHandle rtarg);

		CoreExport RefTargetHandle Clone(RemapDir &remap = NoRemap());

		CoreExport RefResult NotifyRefChanged(Interval changeInt, RefTargetHandle hTarget, 

	         PartID& partID,  RefMessage message);		

	};



class EaseCurveAnimProp : public AnimProperty {

	public:

		EaseCurveList *el;

		EaseCurveAnimProp() { el=NULL; }

		DWORD ID() {return PROPID_EASELIST;}

	};



#define GetEaseListInterface(anim)	((EaseCurveList*)anim->GetInterface(I_EASELIST))



/*---------------------------------------------------------------------*/

// A list of multiplier curves.

class MultCurveList : public ReferenceTarget {

		friend class AddMultRestore;

		friend class DeleteMultRestore;

	private:

		Tab<Control*> mults;

		

	public:

	 	MultCurveList() {OpenTreeEntry(1);}

	  	CoreExport ~MultCurveList();



		CoreExport float GetMultVal(TimeValue t,Interval &valid);

		CoreExport void AppendMultCurve(Control *cont);

		CoreExport void DeleteMultCurve(int i);

		CoreExport void DisableMultCurve(int i);

		CoreExport void EnableMultCurve(int i);

		CoreExport BOOL IsMultEnabled(int i);

		int NumMultCurves() {return mults.Count();}



		// Animatable

		void GetClassName(TSTR& s) { s= TSTR(_T("MultCurve")); }  

		Class_ID ClassID() { return Class_ID(MULT_LIST_CLASS_ID,0); }

		SClass_ID SuperClassID() { return MULT_LIST_CLASS_ID; }		

		CoreExport int NumSubs();

		CoreExport Animatable* SubAnim(int i);

		CoreExport TSTR SubAnimName(int i);

		BOOL BypassTreeView() { return TRUE; }

		void DeleteThis() { delete this; }

		ParamDimension* GetParamDimension(int i) {return stdNormalizedDim;}

		CoreExport BOOL AssignController(Animatable *control,int subAnim);

		CoreExport void* GetInterface(ULONG id);



		CoreExport IOResult Save(ISave *isave);

		CoreExport IOResult Load(ILoad *iload);

		

		// Reference

		CoreExport int NumRefs();

		CoreExport RefTargetHandle GetReference(int i);

		CoreExport void SetReference(int i, RefTargetHandle rtarg);

		CoreExport RefTargetHandle Clone(RemapDir &remap = NoRemap());

		CoreExport RefResult NotifyRefChanged(Interval changeInt, RefTargetHandle hTarget, 

	         PartID& partID,  RefMessage message);		

	};



class MultCurveAnimProp : public AnimProperty {

	public:

		MultCurveList *ml;

		MultCurveAnimProp() { ml=NULL; }

		DWORD ID() {return PROPID_MULTLIST;}

	};



#define GetMultListInterface(anim)	((MultCurveList*)anim->GetInterface(I_MULTLIST))



/*---------------------------------------------------------------------*/





//

// For hit testing controller apparatus 

//



class CtrlHitRecord {

	friend class CtrlHitLog;

	CtrlHitRecord *next;

	public:

		INode *nodeRef;

		DWORD distance;

		ulong hitInfo;

		DWORD infoExtra;		

		CtrlHitRecord() {next=NULL; distance=0; hitInfo=0; nodeRef=NULL;}

		CtrlHitRecord(CtrlHitRecord *nxt,INode *nr, DWORD d, ulong inf, DWORD extra) {

			next=nxt;nodeRef=nr;distance=d;hitInfo=inf;infoExtra=extra;}

		CtrlHitRecord *Next() {return next;}		

	};				   	



class CtrlHitLog {

	CtrlHitRecord *first;

	public:

		CtrlHitLog()  { first = NULL; }

		~CtrlHitLog() { Clear(); }

		CoreExport void Clear();

		CtrlHitRecord* First() { return first; }

		CoreExport CtrlHitRecord* ClosestHit();

		void LogHit(INode *nr,DWORD dist,ulong info,DWORD infoExtra)

			{first = new CtrlHitRecord(first,nr,dist,info,infoExtra);}

	};





// For enumerating IK paramaters

class IKEnumCallback {

	public:

		virtual void proc(Control *c, int index)=0;

	};



class IKDeriv {

	public:

		virtual int NumEndEffectors()=0;

		virtual Point3 EndEffectorPos(int index)=0;

		virtual void DP(Point3 dp,int index)=0;

		virtual void DR(Point3 dr,int index)=0;

		virtual void NextDOF()=0;

	};



// Flags passed to CompDerivs

#define POSITION_DERIV	(1<<0)

#define ROTATION_DERIV	(1<<1)





// This class is used to store IK parameters that have been

// copied to a clipboard.

class IKClipObject {

	public:

		// Identifies the creator of the clip object

		virtual SClass_ID 	SuperClassID()=0;

		virtual Class_ID	ClassID()=0;

		

		virtual void DeleteThis()=0;

	};



// Values for 'which' pasted to Copy/PasteIKParams

#define COPYPASTE_IKPOS		1

#define COPYPASTE_IKROT		2



// Passed to InitIKJoints() which is called when importing

// R4 3DS files that have IK joint data.

class InitJointData {

	public:

		BOOL active[3];

		BOOL limit[3];

		BOOL ease[3];

		Point3 min, max, damping;

	};





// These two ways values can be retreived or set.

// For get:

//		RELATIVE = Apply

//		ABSOLUTE = Just get the value

// For set:

//		RELATIVE = Add the value to the existing value (i.e Move/Rotate/Scale)

//		ABSOLUTE = Just set the value

enum GetSetMethod {CTRL_RELATIVE,CTRL_ABSOLUTE};





// Control class provides default implementations for load and save which save the ORT type in these chunks:

#define CONTROLBASE_CHUNK 		0x8499

#define INORT_CHUNK				0x3000

#define OUTORT_CHUNK			0x3001

#define CONT_DISABLED_CHUNK		0x3002



// Inheritance flags.

#define INHERIT_POS_X	(1<<0)

#define INHERIT_POS_Y	(1<<1)

#define INHERIT_POS_Z	(1<<2)

#define INHERIT_ROT_X	(1<<3)

#define INHERIT_ROT_Y	(1<<4)

#define INHERIT_ROT_Z	(1<<5)

#define INHERIT_SCL_X	(1<<6)

#define INHERIT_SCL_Y	(1<<7)

#define INHERIT_SCL_Z	(1<<8)

#define INHERIT_ALL		511



class Control : public ReferenceTarget {

	public:

		Control() {SetORT(ORT_CONSTANT,ORT_BEFORE);SetORT(ORT_CONSTANT,ORT_AFTER);};

		virtual ~Control() {};



		virtual void Copy(Control *from)=0;

		virtual void CommitValue(TimeValue t) {}

		virtual void RestoreValue(TimeValue t) {}

		virtual INode* GetTarget() { return NULL; } 

		virtual RefResult SetTarget(INode *targ) {return REF_SUCCEED;}



		// Implemented by transform controllers that have position controller

		// that can be edited in the trajectory branch

		virtual Control *GetPositionController() {return NULL;}

		virtual Control *GetRotationController() {return NULL;}

		virtual Control *GetScaleController() {return NULL;}

		virtual BOOL SetPositionController(Control *c) {return FALSE;}

		virtual BOOL SetRotationController(Control *c) {return FALSE;}

		virtual BOOL SetScaleController(Control *c) {return FALSE;}



		// Implemented by look at controllers that have a float valued roll

		// controller so that the roll can be edited via the transform type-in

		virtual Control *GetRollController() {return NULL;}

		virtual BOOL SetRollController(Control *c) {return FALSE;}



		// Implemented by any Point3 controller that wishes to indicate that it is intended

		// to control floating point RGB color values

		virtual BOOL IsColorController() {return FALSE;}



		// Implemented by TM controllers that support 

		// filtering out inheritance

		virtual DWORD GetInheritanceFlags() {return INHERIT_ALL;}

		virtual BOOL SetInheritanceFlags(DWORD f,BOOL keepPos) {return FALSE;} // return TRUE if TM controller supports inheritance



		virtual BOOL IsLeaf() {return TRUE;}

		virtual int IsKeyable() {return 1;}



		// If a controller does not want to allow another controller

		// to be assigned on top of it, it can return FALSE to this method.

		virtual BOOL IsReplaceable() {return TRUE;}		



		// This is called on TM, pos, rot, and scale controllers when their

		// input matrix is about to change. If they return FALSE, the node will

		// call SetValue() to make the necessary adjustments.

		virtual BOOL ChangeParents(TimeValue t,const Matrix3& oldP,const Matrix3& newP,const Matrix3& tm) {return FALSE;}



		// val points to an instance of a data type that corresponds with the controller

		// type. float for float controllers, etc.

		// Note that for SetValue on Rotation controllers, if the SetValue is

		// relative, val points to an AngAxis while if it is absolute it points

		// to a Quat.

		virtual void GetValue(TimeValue t, void *val, Interval &valid, GetSetMethod method=CTRL_ABSOLUTE)=0;	

		virtual	void SetValue(TimeValue t, void *val, int commit=1, GetSetMethod method=CTRL_ABSOLUTE)=0;



		// Transform controllers that do not inherit their parent's  transform 

		// should override this method. Returning FALSE will cause SetValue 

		// to be called even in the case when the parent is also being transformed.

		virtual BOOL InheritsParentTransform() { return TRUE; }



		virtual int GetORT(int type) {return (aflag>>(type==ORT_BEFORE?A_ORT_BEFORESHIFT:A_ORT_AFTERSHIFT))&A_ORT_MASK;}

		CoreExport virtual void SetORT(int ort,int type);

		

		// Sets the enabled/disabled state for ORTs

		CoreExport virtual void EnableORTs(BOOL enable);



		// Default implementations of load and save handle loading and saving of out of range type.

		// Call these from derived class load and save.

		// NOTE: Must call these before any of the derived class chunks are loaded or saved.

		CoreExport IOResult Save(ISave *isave);

		CoreExport IOResult Load(ILoad *iload);



		// For IK

		// Note: IK params must be given in the order they are applied to

		// the parent matrix. When derivatives are computed for a parameter

		// that parameter will apply itself to the parent matrix so the next

		// parameter has the appropriate reference frame. If a controller isn't

		// participating in IK then it should return FALSE and the client (usually PRS)

		// will apply the controller's value to the parent TM.

		virtual void EnumIKParams(IKEnumCallback &callback) {}

		virtual BOOL CompDeriv(TimeValue t,Matrix3& ptm,IKDeriv& derivs,DWORD flags) {return FALSE;}

		virtual float IncIKParam(TimeValue t,int index,float delta) {return 0.0f;}

		virtual void ClearIKParam(Interval iv,int index) {return;}

		virtual BOOL CanCopyIKParams(int which) {return FALSE;}

		virtual IKClipObject *CopyIKParams(int which) {return NULL;}

		virtual BOOL CanPasteIKParams(IKClipObject *co,int which) {return FALSE;}

		virtual void PasteIKParams(IKClipObject *co,int which) {}

		virtual void InitIKJoints(InitJointData *posData,InitJointData *rotData) {}



		// Ease curves

		virtual BOOL CanApplyEaseMultCurves() {return TRUE;}

		CoreExport TimeValue ApplyEase(TimeValue t,Interval &valid);

		CoreExport void AppendEaseCurve(Control *cont);

		CoreExport void DeleteEaseCurve(int i);

		CoreExport int NumEaseCurves();



		// Multiplier curves		

		CoreExport float GetMultVal(TimeValue t,Interval &valid);

		CoreExport void AppendMultCurve(Control *cont);

		CoreExport void DeleteMultCurve(int i);

		CoreExport int NumMultCurves();



		// These are implemented to handle ease curves. If a controller

		// is a leaf controller, then it MUST NOT BY DEFINITION have any

		// sub controllers or references. If it is a leaf controller, then

		// these are implemented to handle the ease curve list.

		// If it is NOT a leaf controller, then these can be overridden.

		CoreExport int NumRefs();

		CoreExport RefTargetHandle GetReference(int i);

		CoreExport void SetReference(int i, RefTargetHandle rtarg);

		CoreExport int NumSubs();

		CoreExport Animatable* SubAnim(int i);

		CoreExport TSTR SubAnimName(int i);



		// Default implementations of some Animatable methods

		CoreExport void* GetInterface(ULONG id);

		CoreExport int PaintFCurves(			

			ParamDimensionBase *dim,

			HDC hdc,

			Rect& rcGraph,

			Rect& rcPaint,

			float tzoom,

			int tscroll,

			float vzoom,

			int vscroll,

			DWORD flags );

		CoreExport int GetFCurveExtents(

			ParamDimensionBase *dim,

			float &min, float &max, DWORD flags);





		//-------------------------------------------------------

		// Controllers that wish to have an apparatus available in

		// the scene will implement these methods:

		// NOTE: Most of these methods are duplicated in BaseObject or Object

		// (see object.h for descriptions).

		virtual int Display(TimeValue t, INode* inode, ViewExp *vpt, int flags) { return 0; };

		virtual int HitTest(TimeValue t, INode* inode, int type, int crossing, int flags, IPoint2 *p, ViewExp *vpt) { return 0; }

		virtual	void GetWorldBoundBox(TimeValue t,INode* inode, ViewExp *vpt, Box3& box) {}



		virtual void ActivateSubobjSel(int level, XFormModes& modes ) {}



		virtual void SelectSubComponent(CtrlHitRecord *hitRec, BOOL selected, BOOL all, BOOL invert=FALSE) {}

		virtual void ClearSelection(int selLevel) {}

		virtual int SubObjectIndex(CtrlHitRecord *hitRec) {return 0;}

		

		virtual void GetSubObjectCenters(SubObjAxisCallback *cb,TimeValue t,INode *node) {}

		virtual void GetSubObjectTMs(SubObjAxisCallback *cb,TimeValue t,INode *node) {}



		// Modify sub object apparatuses

		virtual void SubMove( TimeValue t, Matrix3& partm, Matrix3& tmAxis, Point3& val, BOOL localOrigin=FALSE ){}

		virtual void SubRotate( TimeValue t, Matrix3& partm, Matrix3& tmAxis, Quat& val, BOOL localOrigin=FALSE ){}

		virtual void SubScale( TimeValue t, Matrix3& partm, Matrix3& tmAxis, Point3& val, BOOL localOrigin=FALSE ){}

		virtual void MouseCycleCompleted(TimeValue t) {}

		

	};





// Any controller that does not evaluate itself as a function of it's

// input can subclass off this class.

// GetValueLocalTime() will never ask the controller to apply the value,

// it will always ask for it absolute.

class StdControl : public Control {

	public:		

		virtual void GetValueLocalTime(TimeValue t, void *val, Interval &valid, GetSetMethod method=CTRL_ABSOLUTE)=0;

		virtual	void SetValueLocalTime(TimeValue t, void *val, int commit=1, GetSetMethod method=CTRL_ABSOLUTE)=0;

		CoreExport void GetValue(TimeValue t, void *val, Interval &valid, GetSetMethod method=CTRL_ABSOLUTE);

		CoreExport void SetValue(TimeValue t, void *val, int commit=1, GetSetMethod method=CTRL_ABSOLUTE);



		virtual void Extrapolate(Interval range,TimeValue t,void *val,Interval &valid,int type)=0;

		

		virtual void *CreateTempValue()=0;

		virtual void DeleteTempValue(void *val)=0;

		virtual void ApplyValue(void *val, void *delta)=0;

		virtual void MultiplyValue(void *val, float m)=0;

	};





// Each super class of controller may have a specific packet defined that

// the 'val' pointer will point to instead of a literal value.

// In reality, probably only the Transform controller will do this.

enum SetXFormCommand { XFORM_MOVE, XFORM_ROTATE, XFORM_SCALE, XFORM_SET };

class SetXFormPacket {

	public:

		SetXFormCommand command;

		Matrix3 tmParent;

		Matrix3 tmAxis;		// if command is XFORM_SET, this will contain the new value for the XFORM.		

		Point3 p;

		Quat q;

		AngAxis aa;

		BOOL localOrigin;		

		

		// XFORM_SET

		SetXFormPacket(const Matrix3& mat,const Matrix3& par=Matrix3(1))

			{command=XFORM_SET,tmParent=par,tmAxis=mat;}



		// XFORM_MOVE

		SetXFormPacket(Point3 pt, const Matrix3& par=Matrix3(1), 

						const Matrix3& a=Matrix3(1))

			{command=XFORM_MOVE;tmParent=par;tmAxis=a;p=pt;localOrigin=FALSE;}



		// XFORM_ROTATE

		SetXFormPacket(Quat qt, BOOL l, const Matrix3& par=Matrix3(1),

						const Matrix3& a=Matrix3(1))

			{command=XFORM_ROTATE;tmParent=par;tmAxis=a;q=qt;aa=AngAxis(q);localOrigin=l;}

		SetXFormPacket(AngAxis aA, BOOL l, const Matrix3& par=Matrix3(1),

						const Matrix3& a=Matrix3(1))

			{command=XFORM_ROTATE;tmParent=par;tmAxis=a;q=Quat(aA);aa=aA;localOrigin=l;}



		// XFORM_SCALE

		SetXFormPacket(Point3 pt, BOOL l, const Matrix3& par=Matrix3(1),

						const Matrix3& a=Matrix3(1))

			{command=XFORM_SCALE;tmParent=par;tmAxis=a;p=pt;localOrigin=l;}



		// Just in case you want to do it by hand...

		SetXFormPacket() {};

	};







// This is a special control base class for controllers that control

// morphing of geomoetry.

//

// The 'val' pointer used with GetValue will point to an object state.

// This would be the result of evaluating a combination of targets and

// producing a new object that is some combination of the targets.

//

// The 'val' pointer used with SetValue will point to a 

// SetMorphTargetPacket data structure. This has a pointer to

// an object (entire pipeline) and the name of the target.



// A pointer to one of these is passed to SetValue

class SetMorphTargetPacket {

	public:

		Matrix3 tm;

		Object *obj;

		TSTR name;

		BOOL forceCreate; // Make sure the key is created even if it is at frame 0

		SetMorphTargetPacket(Object *o,TSTR n,Matrix3 &m,BOOL fc=FALSE) {obj = o;name = n;tm = m;forceCreate=fc;}

		SetMorphTargetPacket(Object *o,TSTR n,BOOL fc=FALSE) {obj = o;name = n;tm = Matrix3(1);forceCreate=fc;}

	};



class MorphControl : public Control {

	public:

		

		// Access the object pipelines of the controller's targets. Note

		// that these are pointers to the pipelines, not the result of

		// evaluating the pipelines.

		virtual int NumMorphTargs() {return 0;}

		virtual Object *GetMorphTarg(int i) {return NULL;}

		virtual void GetMorphTargName(int i,TSTR &name) {name.printf(_T("Target #%d"),i);}

		virtual Matrix3 GetMorphTargTM(int i) {return Matrix3(1);}



		// Checks an object to see if it is an acceptable target.

		virtual BOOL ValidTarget(TimeValue t,Object *obj) {return FALSE;}

	};



//----------------------------------------------------------------//

//

// Some stuff to help with ORTs - these could actually be Interval methods



inline TimeValue CycleTime(Interval i,TimeValue t)

	{

	int res, dur = i.Duration()-1;

	if (dur<=0) return t;		

	res	= (t-i.Start())%dur;

	if (res<0) {

		return i.End()+res;

	} else {

		return i.Start()+res;

		}

	}



inline int NumCycles(Interval i,TimeValue t)

	{

	int dur = i.Duration()-1;

	if (dur<=0) return 1;

	if (t<i.Start()) {

		return (abs(t-i.Start())/dur)+1;

	} else 

	if (t>i.End()) {

		return (abs(t-i.End())/dur)+1;

	} else {

		return 0;

		}

	}







// Types that use this template must support:

//  T + T, T - T, T * float, T + float 



template <class T> T 

LinearExtrapolate(TimeValue t0, TimeValue t1, T &val0, T &val1, T &endVal)

	{

	return (T)(endVal + (val1-val0) * float(t1-t0));

	}



template <class T> T 

RepeatExtrapolate(Interval range, TimeValue t, 

		T &startVal, T &endVal, T &cycleVal)

	{

	int cycles = NumCycles(range,t);

	T delta;

	if (t<range.Start()) {

		delta = startVal - endVal;

	} else {

		delta = endVal - startVal;

		}

	return (T)(cycleVal + delta * float(cycles));

	}



template <class T> T 

IdentityExtrapolate(TimeValue endPoint, TimeValue t, T &endVal )

	{

	return (T)(endVal + float(t-endPoint));

	}



CoreExport Quat LinearExtrapolate(TimeValue t0, TimeValue t1, Quat &val0, Quat &val1, Quat &endVal);

CoreExport Quat RepeatExtrapolate(Interval range, TimeValue t, 

					Quat &startVal, Quat &endVal, Quat &cycleVal);

CoreExport Quat IdentityExtrapolate(TimeValue endPoint, TimeValue t, Quat &endVal );





template <class T> T

LinearInterpolate(const T &v0,const T &v1,float u)

	{

	return (T)((1.0f-u)*v0 + u*v1);

	}



inline Quat 

LinearInterpolate(const Quat &v0,const Quat &v1,float u)

	{

	return Slerp(v0,v1,u);

	}



inline ScaleValue 

LinearInterpolate(const ScaleValue &v0,const ScaleValue &v1,float u)

	{

	ScaleValue res;

	res.s = ((float)1.0-u)*v0.s + u*v1.s;

	res.q = Slerp(v0.q,v1.q,u);

	return res;

	}





inline Interval TestInterval(Interval iv, DWORD flags)

	{

	TimeValue start = iv.Start();

	TimeValue end = iv.End();

	if (!(flags&TIME_INCLEFT)) {

		start++;

		}	

	if (!(flags&TIME_INCRIGHT)) {

		end--;

		}

	if (end<start) {

		iv.SetEmpty();

	} else {

		iv.Set(start,end);

		}

	return iv;	

	}



inline Quat ScaleQuat(Quat q, float s)

	{

	float angle;

	Point3 axis;

	AngAxisFromQ(q,&angle,axis);

	return QFromAngAxis(angle*s,axis);

	}



//-------------------------------------------------------------------

// A place to store values during Hold/Restore periods

//

//********************************************************

// TempStore:  This is a temporary implementation:

//  It uses a linear search-

//  A hash-coded dictionary would be faster.

//  (if there are ever a lot of entries)

//********************************************************



struct Slot {

	void *key;

	void *pdata;

	int nbytes;	

	Slot *next;

	public:

		Slot() { pdata = NULL; }

		~Slot() {

			 if (pdata) free(pdata); 

			 pdata = NULL;

			 }



	};



class TempStore {

	Slot *slotList;				

	Slot* Find(int n, void *data, void *ptr);

	public:

		TempStore() { 	slotList = NULL;	}

		~TempStore() {	ClearAll();	}

		CoreExport void ClearAll();   // empty out the store 

		CoreExport void PutBytes(int n, void *data, void *ptr);

		CoreExport void GetBytes(int n, void *data, void *ptr);

		CoreExport void Clear(void *ptr);  // Remove single entry

		void PutFloat(float  f, void *ptr) {

			 PutBytes(sizeof(float),(void *)&f,ptr);

			 }

		CoreExport void PutInt(int i, void *ptr) {

			 PutBytes(sizeof(int),(void *)&i,ptr);

			 }

		CoreExport void GetFloat(float *f, void *ptr) { 

			GetBytes(sizeof(float),(void *)f,ptr);

			}

		CoreExport void GetInt(int *i, void *ptr) { 

			GetBytes(sizeof(int),(void *)i,ptr);

			}

		CoreExport void PutPoint3(Point3  f, void *ptr) {

			 PutBytes(sizeof(Point3),(void *)&f,ptr);

			 }

		CoreExport void GetPoint3(Point3 *f, void *ptr) { 

			GetBytes(sizeof(Point3),(void *)f,ptr);

			}

		CoreExport void PutQuat( Quat  f, void *ptr) {

			 PutBytes(sizeof(Quat),(void *)&f,ptr);

			 }

		CoreExport void GetQuat( Quat *f, void *ptr) { 

			GetBytes(sizeof(Quat),(void *)f,ptr);

			}

		CoreExport void PutScaleValue( ScaleValue  f, void *ptr) {

			 PutBytes(sizeof(ScaleValue),(void *)&f,ptr);

			 }

		CoreExport void GetScaleValue( ScaleValue *f, void *ptr) { 

			GetBytes(sizeof(ScaleValue),(void *)f,ptr);

			}

	};





extern CoreExport TempStore tmpStore;   // this should be in the scene data struct.





CoreExport int Animating();	 // is the animate switch on??

CoreExport void AnimateOn();  // turn animate on

CoreExport void AnimateOff();  // turn animate off

CoreExport void SuspendAnimate(); // suspend animation (uses stack)

CoreExport void ResumeAnimate();   // resume animation ( " )



CoreExport TimeValue GetAnimStart();

CoreExport TimeValue GetAnimEnd();

CoreExport void SetAnimStart(TimeValue s);

CoreExport void SetAnimEnd(TimeValue e);



CoreExport Control *NewDefaultFloatController();

CoreExport Control *NewDefaultPoint3Controller();

CoreExport Control *NewDefaultMatrix3Controller();

CoreExport Control *NewDefaultPositionController();

CoreExport Control *NewDefaultRotationController();

CoreExport Control *NewDefaultScaleController();

CoreExport Control *NewDefaultBoolController();

CoreExport Control *NewDefaultColorController();



CoreExport void SetDefaultController(SClass_ID sid, ClassDesc *desc);

CoreExport ClassDesc *GetDefaultController(SClass_ID sid);



CoreExport void SetDefaultColorController(ClassDesc *desc);

CoreExport void SetDefaultBoolController(ClassDesc *desc);







#endif //__CONTROL__