First version of the SOurce SDK 2013

1 files changed, 292 insertions, 0 deletions

diff --git a/mp/src/game/client/splinepatch.cpp b/mp/src/game/client/splinepatch.cpp
new file mode 100644
index 00000000..1e76b4e1
--- /dev/null
+++ b/mp/src/game/client/splinepatch.cpp
@@ -0,0 +1,292 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//

+//

+// Purpose: A little helper class that computes a spline patch

+//

+// $Workfile:     $

+// $Date:         $

+//

+//-----------------------------------------------------------------------------

+// $Log: $

+//

+// $NoKeywords: $

+//=============================================================================//

+#include "cbase.h"

+#include "splinepatch.h"

+

+#include "mathlib/vmatrix.h"

+

+// memdbgon must be the last include file in a .cpp file!!!

+#include "tier0/memdbgon.h"

+

+//-----------------------------------------------------------------------------

+// Catmull rom blend weights

+//-----------------------------------------------------------------------------

+

+static VMatrix s_CatmullRom( -0.5,  1.5, -1.5,  0.5,

+							    1, -2.5,    2, -0.5,

+							 -0.5,    0,  0.5,    0,

+							    0,    1,    0,    0 );

+

+//-----------------------------------------------------------------------------

+// The last argument represents the number of float channels in addition to position

+//-----------------------------------------------------------------------------

+

+CSplinePatch::CSplinePatch( ) : m_ChannelCount(0),

+	m_Width(0), m_Height(0), m_ppPositions(0), m_LinearFactor(1.0f)

+{

+}

+

+CSplinePatch::~CSplinePatch()

+{

+}

+

+//-----------------------------------------------------------------------------

+// Initialize the spline patch

+//-----------------------------------------------------------------------------

+

+void CSplinePatch::Init( int w, int h, int extraChannels )

+{

+	assert( extraChannels < MAX_CHANNELS );

+	m_ChannelCount = extraChannels;

+	m_Width = w;

+	m_Height = h;

+	m_LinearFactor = 1.0f;

+}

+

+

+//-----------------------------------------------------------------------------

+// 0 = linear, 1 = spliney!

+//-----------------------------------------------------------------------------

+

+void CSplinePatch::SetLinearBlend( float factor )

+{

+	m_LinearFactor = factor;

+}

+

+

+//-----------------------------------------------------------------------------

+// Hooks the patch up to externally controlled data...

+//-----------------------------------------------------------------------------

+

+void CSplinePatch::SetControlPositions( Vector const** pPositions )

+{

+	m_ppPositions = pPositions;

+}

+

+void CSplinePatch::SetChannelData( int channel, float* pChannel )

+{

+	m_pChannel[channel] = pChannel;

+}

+

+static inline void ComputeIndex( int i, int maxval, int* idx )

+{

+	if (i == 0)

+	{

+		idx[0] = 0; idx[1] = 0; idx[2] = 1; 

+		idx[3] = (maxval > 2) ? 2 : 1;

+	}

+	else

+	{

+		idx[0] = i-1; idx[1] = i;

+		if (i >= maxval - 1)

+		{

+			idx[2] = i; idx[3] = i;

+		}

+		else

+		{

+			idx[2] = i+1;

+			if (i >= maxval - 2)

+				idx[3] = i+1;

+			else

+				idx[3]=  i+2;

+		}

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Computes indices of the samples to read for this interpolation

+//-----------------------------------------------------------------------------

+

+void CSplinePatch::ComputeIndices( )

+{

+	int s[4];

+	int t[4];

+

+	ComputeIndex( m_is, m_Width, s );

+	ComputeIndex( m_it, m_Height, t );

+

+	int base = t[0] * m_Width;

+	m_SampleIndices[0][0] = base + s[0];

+	m_SampleIndices[1][0] = base + s[1];

+	m_SampleIndices[2][0] = base + s[2];

+	m_SampleIndices[3][0] = base + s[3];

+

+	base = t[1] * m_Width;

+	m_SampleIndices[0][1] = base + s[0];

+	m_SampleIndices[1][1] = base + s[1];

+	m_SampleIndices[2][1] = base + s[2];

+	m_SampleIndices[3][1] = base + s[3];

+

+	base = t[2] * m_Width;

+	m_SampleIndices[0][2] = base + s[0];

+	m_SampleIndices[1][2] = base + s[1];

+	m_SampleIndices[2][2] = base + s[2];

+	m_SampleIndices[3][2] = base + s[3];

+

+	base = t[3] * m_Width;

+	m_SampleIndices[0][3] = base + s[0];

+	m_SampleIndices[1][3] = base + s[1];

+	m_SampleIndices[2][3] = base + s[2];

+	m_SampleIndices[3][3] = base + s[3];

+}

+

+//-----------------------------------------------------------------------------

+// Call this before querying the patch for data at (s,t)

+//-----------------------------------------------------------------------------

+

+void CSplinePatch::SetupPatchQuery( float s, float t )

+{

+	m_is = (int)s;

+	m_it = (int)t;

+

+	if( m_is >= m_Width )

+	{

+		m_is = m_Width - 1;

+		m_fs = 1.0f;

+	}

+	else

+	{

+		m_fs = s - m_is;

+	}

+

+	if( m_it >= m_Height )

+	{

+		m_it = m_Height - 1;

+		m_ft = 1.0f;

+	}

+	else

+	{

+		m_ft = t - m_it;

+	}

+

+	ComputeIndices( );

+

+	// The patch equation is:

+	// px = S * M * Gx * M^T * T^T 

+	// py = S * M * Gy * M^T * T^T 

+	// pz = S * M * Gz * M^T * T^T 

+	// where S = [s^3 s^2 s 1], T = [t^3 t^2 t 1]

+	// M is the patch type matrix, in my case I'm using a catmull-rom

+	// G is the array of control points. rows have constant t

+

+	// We're gonna cache off S * M and M^T * T^T...

+	Vector4D svec, tvec;

+ 	float fs2 = m_fs * m_fs;

+	svec[0] = fs2 * m_fs; svec[1] = fs2; svec[2] = m_fs; svec[3] = 1.0f;

+	float ft2 = m_ft * m_ft;

+	tvec[0] = ft2 * m_ft; tvec[1] = ft2; tvec[2] = m_ft; tvec[3] = 1.0f;

+

+	// This sets up the catmull rom matrix based on the blend factor!!

+	// we can go from linear to curvy!

+	s_CatmullRom.Init(  -0.5 * m_LinearFactor,  1.5 * m_LinearFactor, -1.5 * m_LinearFactor,  0.5 * m_LinearFactor,

+						       m_LinearFactor, -2.5 * m_LinearFactor,    2 * m_LinearFactor, -0.5 * m_LinearFactor,

+						-0.5 * m_LinearFactor,   -1 + m_LinearFactor,    1 - 0.5 * m_LinearFactor,    0,

+											0,					   1,					  0,    0 );

+	Vector4DMultiplyTranspose( s_CatmullRom, svec, m_SVec );

+	Vector4DMultiplyTranspose( s_CatmullRom, tvec, m_TVec );

+}

+

+//-----------------------------------------------------------------------------

+// Gets the point and normal at (i,j) specified above

+//-----------------------------------------------------------------------------

+

+void CSplinePatch::GetPointAndNormal( Vector& position, Vector& normal ) const

+{

+	// The patch equation is:

+	// px = S * M * Gx * M^T * T^T 

+	// py = S * M * Gy * M^T * T^T 

+	// pz = S * M * Gz * M^T * T^T 

+	// where S = [s^3 s^2 s 1], T = [t^3 t^2 t 1]

+	// M is the patch type matrix, in my case I'm using a catmull-rom

+	// G is the array of control points. rows have constant t

+

+	VMatrix controlPointsX, controlPointsY, controlPointsZ;

+	for (int i = 0; i < 4; ++i)

+	{

+		for (int j = 0; j < 4; ++j)

+		{

+			int idx = m_SampleIndices[i][j];

+			controlPointsX[i][j] = m_ppPositions[ idx ]->x;

+			controlPointsY[i][j] = m_ppPositions[ idx ]->y;

+			controlPointsZ[i][j] = m_ppPositions[ idx ]->z;

+		}

+	}

+

+	Vector4D tmp;

+

+	Vector4DMultiply( controlPointsX, m_TVec, tmp );

+	position[0] = DotProduct4D( tmp, m_SVec );

+	Vector4DMultiply( controlPointsY, m_TVec, tmp );

+	position[1] = DotProduct4D( tmp, m_SVec );

+	Vector4DMultiply( controlPointsZ, m_TVec, tmp );

+	position[2] = DotProduct4D( tmp, m_SVec );

+

+	// Normal computation

+

+	float fs2 = m_fs * m_fs;

+	float ft2 = m_ft * m_ft;

+	Vector4D dsvec( 3.0f * fs2, 2.0f * m_fs, 1.0f, 0.0f );

+	Vector4D dtvec( 3.0f * ft2, 2.0f * m_ft, 1.0f, 0.0f );

+

+	Vector4DMultiplyTranspose( s_CatmullRom, dsvec, dsvec );

+	Vector4DMultiplyTranspose( s_CatmullRom, dtvec, dtvec );

+

+	Vector ds, dt;

+

+	Vector4DMultiply( controlPointsX, m_TVec, tmp );

+	ds[0] = DotProduct4D( tmp, dsvec );

+	Vector4DMultiply( controlPointsY, m_TVec, tmp );

+	ds[1] = DotProduct4D( tmp, dsvec );

+	Vector4DMultiply( controlPointsZ, m_TVec, tmp );

+	ds[2] = DotProduct4D( tmp, dsvec );

+

+	Vector4DMultiply( controlPointsX, dtvec, tmp );

+	dt[0] = DotProduct4D( tmp, m_SVec );

+	Vector4DMultiply( controlPointsY, dtvec, tmp );

+	dt[1] = DotProduct4D( tmp, m_SVec );

+	Vector4DMultiply( controlPointsZ, dtvec, tmp );

+	dt[2] = DotProduct4D( tmp, m_SVec );

+

+	CrossProduct( ds, dt, normal );

+	VectorNormalize( normal );

+}

+

+//-----------------------------------------------------------------------------

+// Gets at other channels

+//-----------------------------------------------------------------------------

+

+float CSplinePatch::GetChannel( int channel ) const

+{

+	// The patch equation is:

+	// px = S * M * Gx * M^T * T^T 

+	// py = S * M * Gy * M^T * T^T 

+	// pz = S * M * Gz * M^T * T^T 

+	// where S = [s^3 s^2 s 1], T = [t^3 t^2 t 1]

+	// M is the patch type matrix, in my case I'm using a catmull-rom

+	// G is the array of control points. rows have constant t

+

+	assert( m_pChannel[channel] );

+

+	VMatrix controlPoints;

+	for (int i = 0; i < 4; ++i)

+	{

+		for (int j = 0; j < 4; ++j)

+		{

+			controlPoints[i][j] = m_pChannel[channel][ m_SampleIndices[i][j] ];

+		}

+	}

+

+	Vector4D tmp;

+	Vector4DMultiply( controlPoints, m_TVec, tmp );

+	return DotProduct4D( tmp, m_SVec );

+}