icelineardamper.h

使用stl技术,(还没看,是听说的)

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
 *	Contains a linear damper.
 *	\file		IceLinearDamper.h
 *	\author		Pierre Terdiman
 *	\date		February, 8, 2003
 */
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Include Guard
#ifndef __ICELINEARDAMPER_H__
#define __ICELINEARDAMPER_H__

	//! Linear frame-independent damper
	class ICECORE_API LinearDamper
	{
		public:
		// Constructor/Destructor
						LinearDamper() : mLinearCoeff(0.0f), mNormalizer(0.0f)	{}
						~LinearDamper()											{}

		inline_	void	Reset()
						{
							mLinearCoeff = mNormalizer = 0.0f;
						}

		// We want the coeff to reach 0 in a time T. We accumulate the time in "elapsed_time", so that
		// it ranges from 0 to T, remapped to 0-1. 

		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		/**
		 *	Resets for forward damping. Linear coeff ranges from 0 to 1 over a given delay.
		 *	\param		delay	[in] time interval in seconds
		 *	\see		ForwardUpdate(float elapsed_time)
		 */
		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		inline_	void	ForwardReset(float delay)
						{
							mLinearCoeff = 0.0f;
							mNormalizer = 1.0f / delay;
						}

		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		/**
		 *	Resets for backward damping. Linear coeff ranges from 1 to 0 over a given delay.
		 *	\param		delay	[in] time interval in seconds
		 *	\see		BackwardUpdate(float elapsed_time)
		 */
		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		inline_	void	BackwardReset(float delay)
						{
							mLinearCoeff = 1.0f;
							mNormalizer = 1.0f / delay;
						}

		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		/**
		 *	Updates damper for forward damping.
		 *	\param		elapsed_time	[in] elapsed time in seconds
		 *	\return		true if linear coeff has reached a limit
		 *	\see		ForwardReset(float delay)
		 */
		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		inline_	BOOL	ForwardUpdate(float elapsed_time)
						{
							mLinearCoeff += elapsed_time*mNormalizer;
							if(SIR(mLinearCoeff)>IEEE_1_0)	{ SIR(mLinearCoeff) = IEEE_1_0; return TRUE;	}
							return FALSE;
						}

		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		/**
		 *	Updates damper for backward damping.
		 *	\param		elapsed_time	[in] elapsed time in seconds
		 *	\return		true if linear coeff has reached a limit
		 *	\see		BackwardReset(float delay)
		 */
		///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		inline_	BOOL	BackwardUpdate(float elapsed_time)
						{
							mLinearCoeff -= elapsed_time*mNormalizer;
							if(SIR(mLinearCoeff)<0)	{ SIR(mLinearCoeff) = 0; return TRUE;	}
							return FALSE;
						}

		// Data access
		inline_			operator float()	const	{ return mLinearCoeff;	}
		inline_	float	GetLinearCoeff()	const	{ return mLinearCoeff;	}
		inline_	float	GetNormalizer()		const	{ return mNormalizer;	}

		private:
				float	mLinearCoeff;	//!< Linear coeff between 0 and 1
				float	mNormalizer;	//!< Coeff multiplier
	};

#endif // __ICELINEARDAMPER_H__