From f56bb35301836e56582a575a75864392a0177875 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B8rgen=20P=2E=20Tjern=C3=B8?= Date: Mon, 2 Dec 2013 19:31:46 -0800 Subject: Fix line endings. WHAMMY. --- mp/src/game/client/splinepatch.cpp | 584 ++++++++++++++++++------------------- 1 file changed, 292 insertions(+), 292 deletions(-) (limited to 'mp/src/game/client/splinepatch.cpp') diff --git a/mp/src/game/client/splinepatch.cpp b/mp/src/game/client/splinepatch.cpp index 1e76b4e1..db9a0403 100644 --- a/mp/src/game/client/splinepatch.cpp +++ b/mp/src/game/client/splinepatch.cpp @@ -1,292 +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 ); -} +//========= 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 ); +} -- cgit v1.2.3