1HEADmaster

1 files changed, 165 insertions, 0 deletions

diff --git a/game/client/lerp_functions.h b/game/client/lerp_functions.h
new file mode 100644
index 0000000..198cb67
--- /dev/null
+++ b/game/client/lerp_functions.h
@@ -0,0 +1,165 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef LERP_FUNCTIONS_H
+#define LERP_FUNCTIONS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+template <class T>
+inline T LoopingLerp( float flPercent, T flFrom, T flTo )
+{
+	T s = flTo * flPercent + flFrom * (1.0f - flPercent);
+	return s;
+}
+
+template <>
+inline float LoopingLerp( float flPercent, float flFrom, float flTo )
+{
+	if ( fabs( flTo - flFrom ) >= 0.5f )
+	{
+		if (flFrom < flTo)
+			flFrom += 1.0f;
+		else
+			flTo += 1.0f;
+	}
+
+	float s = flTo * flPercent + flFrom * (1.0f - flPercent);
+
+	s = s - (int)(s);
+	if (s < 0.0f)
+		s = s + 1.0f;
+
+	return s;
+}
+
+template <class T>
+inline T Lerp_Hermite( float t, const T& p0, const T& p1, const T& p2 )
+{
+	T d1 = p1 - p0;
+	T d2 = p2 - p1;
+
+	T output;
+	float tSqr = t*t;
+	float tCube = t*tSqr;
+
+	output = p1 * (2*tCube-3*tSqr+1);
+	output += p2 * (-2*tCube+3*tSqr);
+	output += d1 * (tCube-2*tSqr+t);
+	output += d2 * (tCube-tSqr);
+
+	return output;
+}
+
+
+template <class T>
+inline T Derivative_Hermite( float t, const T& p0, const T& p1, const T& p2 )
+{
+	T d1 = p1 - p0;
+	T d2 = p2 - p1;
+
+	T output;
+	float tSqr = t*t;
+
+	output = p1 * (6*tSqr - 6*t);
+	output += p2 * (-6*tSqr + 6*t);
+	output += d1 * (3*tSqr - 4*t + 1);
+	output += d2 * (3*tSqr - 2*t);
+
+	return output;
+}
+
+
+inline void Lerp_Clamp( int val )
+{
+}
+
+inline void Lerp_Clamp( float val )
+{
+}
+
+inline void Lerp_Clamp( const Vector &val )
+{
+}
+
+inline void Lerp_Clamp( const QAngle &val )
+{
+}
+
+
+// If we have a range checked var, then we can clamp to its limits.
+template< class T, int minValue, int maxValue, int startValue >
+inline void Lerp_Clamp( CRangeCheckedVar<T,minValue,maxValue,startValue> &val )
+{
+	val.Clamp();
+}
+
+
+template<> 
+inline QAngle Lerp_Hermite<QAngle>( float t, const QAngle& p0, const QAngle& p1, const QAngle& p2 )
+{
+	// Can't do hermite with QAngles, get discontinuities, just do a regular interpolation
+	return Lerp( t, p1, p2 );
+}
+
+template <class T>
+inline T LoopingLerp_Hermite( float t, T p0, T p1, T p2  )
+{
+	return Lerp_Hermite( t, p0, p1, p2 );
+}
+
+template <>
+inline float LoopingLerp_Hermite( float t, float p0, float p1, float p2 )
+{
+	if ( fabs( p1 - p0 ) > 0.5f )
+	{
+		if ( p0 < p1 )
+			p0 += 1.0f;
+		else
+			p1 += 1.0f;
+	}
+
+	if ( fabs( p2 - p1 ) > 0.5f )
+	{
+		if ( p1 < p2 )
+		{
+			p1 += 1.0f;
+
+			// see if we need to fix up p0
+			// important for vars that are decreasing from p0->p1->p2 where
+			// p1 is fixed up relative to p2, eg p0 = 0.2, p1 = 0.1, p2 = 0.9
+			if ( abs( p1 - p0 ) > 0.5 )
+			{
+				if ( p0 < p1 )
+					p0 += 1.0f;
+				else
+					p1 += 1.0f;
+			}
+		}
+		else
+		{
+			p2 += 1.0f;
+		}
+	}
+		
+	float s = Lerp_Hermite( t, p0, p1, p2 );
+
+	s = s - (int)(s);
+	if (s < 0.0f)
+	{
+		s = s + 1.0f;
+	}
+
+	return s;
+}
+
+
+// NOTE: C_AnimationLayer has its own versions of these functions in animationlayer.h.
+
+
+#endif // LERP_FUNCTIONS_H