Backups/hl2sdk
1
0
Fork 0
mirror of https://github.com/alliedmodders/hl2sdk.git synced 2024-12-23 01:59:43 +08:00
Code

Fix std::swap conflicts.

Browse Source
This commit is contained in:
David Anderson 2020-06-02 10:15:38 -07:00
parent 7d9dbf1cc1
commit f152e66ac8
7 changed files with 28 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
mathlib/mathlib_base.cpp
View File

@ -382,9 +382,9 @@ void MatrixInvert( const matrix3x4_t& in, matrix3x4_t& out )
Assert( s_bMathlibInitialized ); Assert( s_bMathlibInitialized );
if ( &in == &out ) if ( &in == &out )
{ {
swap(out[0][1],out[1][0]); V_swap(out[0][1],out[1][0]);
swap(out[0][2],out[2][0]); V_swap(out[0][2],out[2][0]);
swap(out[1][2],out[2][1]); V_swap(out[1][2],out[2][1]);
} }
else else
{ {
@ -1266,18 +1266,18 @@ bool SolveInverseQuadraticMonotonic( float x1, float y1, float x2, float y2, flo
// first, sort parameters // first, sort parameters
if (x1>x2) if (x1>x2)
{ {
swap(x1,x2); V_swap(x1,x2);
swap(y1,y2); V_swap(y1,y2);
} }
if (x2>x3) if (x2>x3)
{ {
swap(x2,x3); V_swap(x2,x3);
swap(y2,y3); V_swap(y2,y3);
} }
if (x1>x2) if (x1>x2)
{ {
swap(x1,x2); V_swap(x1,x2);
swap(y1,y2); V_swap(y1,y2);
} }
// this code is not fast. what it does is when the curve would be non-monotonic, slowly shifts // this code is not fast. what it does is when the curve would be non-monotonic, slowly shifts
// the center point closer to the linear line between the endpoints. Should anyone need htis // the center point closer to the linear line between the endpoints. Should anyone need htis

2
public/mathlib/mathlib.h
View File

@ -608,7 +608,7 @@ template<> FORCEINLINE QAngleByValue Lerp<QAngleByValue>( float flPercent, const
// Swap two of anything. // Swap two of anything.
template <class T> template <class T>
FORCEINLINE void swap( T& x, T& y ) FORCEINLINE void V_swap( T& x, T& y )
{ {
T temp = x; T temp = x;
x = y; x = y;

2
public/particles/particles.h
View File

@ -1452,7 +1452,7 @@ inline void CParticleCollection::SwapPosAndPrevPos( void )
{ {
// strides better be the same! // strides better be the same!
Assert( m_nParticleFloatStrides[PARTICLE_ATTRIBUTE_XYZ] == m_nParticleFloatStrides[ PARTICLE_ATTRIBUTE_PREV_XYZ ] ); Assert( m_nParticleFloatStrides[PARTICLE_ATTRIBUTE_XYZ] == m_nParticleFloatStrides[ PARTICLE_ATTRIBUTE_PREV_XYZ ] );
swap( m_pParticleAttributes[ PARTICLE_ATTRIBUTE_XYZ ], m_pParticleAttributes[ PARTICLE_ATTRIBUTE_PREV_XYZ ] ); V_swap( m_pParticleAttributes[ PARTICLE_ATTRIBUTE_XYZ ], m_pParticleAttributes[ PARTICLE_ATTRIBUTE_PREV_XYZ ] );
} }
inline void CParticleCollection::LoanKillListTo( CParticleCollection *pBorrower ) const inline void CParticleCollection::LoanKillListTo( CParticleCollection *pBorrower ) const

8
public/tier1/utlblockmemory.h
View File

@ -137,10 +137,10 @@ CUtlBlockMemory<T,I>::~CUtlBlockMemory()
template< class T, class I > template< class T, class I >
void CUtlBlockMemory<T,I>::Swap( CUtlBlockMemory< T, I > &mem ) void CUtlBlockMemory<T,I>::Swap( CUtlBlockMemory< T, I > &mem )
{ {
swap( m_pMemory, mem.m_pMemory ); V_swap( m_pMemory, mem.m_pMemory );
swap( m_nBlocks, mem.m_nBlocks ); V_swap( m_nBlocks, mem.m_nBlocks );
swap( m_nIndexMask, mem.m_nIndexMask ); V_swap( m_nIndexMask, mem.m_nIndexMask );
swap( m_nIndexShift, mem.m_nIndexShift ); V_swap( m_nIndexShift, mem.m_nIndexShift );
} }

8
public/tier1/utlfixedmemory.h
View File

@ -133,7 +133,7 @@ public:
void Purge(); void Purge();
protected: protected:
// Fast swap - WARNING: Swap invalidates all ptr-based indices!!! // Fast V_swap - WARNING: Swap invalidates all ptr-based indices!!!
void Swap( CUtlFixedMemory< T > &mem ); void Swap( CUtlFixedMemory< T > &mem );
bool IsInBlock( int i, BlockHeader_t *pBlockHeader ) const bool IsInBlock( int i, BlockHeader_t *pBlockHeader ) const
@ -181,9 +181,9 @@ CUtlFixedMemory<T>::~CUtlFixedMemory()
template< class T > template< class T >
void CUtlFixedMemory<T>::Swap( CUtlFixedMemory< T > &mem ) void CUtlFixedMemory<T>::Swap( CUtlFixedMemory< T > &mem )
{ {
swap( m_pBlocks, mem.m_pBlocks ); V_swap( m_pBlocks, mem.m_pBlocks );
swap( m_nAllocationCount, mem.m_nAllocationCount ); V_swap( m_nAllocationCount, mem.m_nAllocationCount );
swap( m_nGrowSize, mem.m_nGrowSize ); V_swap( m_nGrowSize, mem.m_nGrowSize );
} }

12
public/tier1/utlrbtree.h
View File

@ -1547,12 +1547,12 @@ template < class T, class I, typename L, class M >
void CUtlRBTree<T, I, L, M>::Swap( CUtlRBTree< T, I, L > &that ) void CUtlRBTree<T, I, L, M>::Swap( CUtlRBTree< T, I, L > &that )
{ {
m_Elements.Swap( that.m_Elements ); m_Elements.Swap( that.m_Elements );
swap( m_LessFunc, that.m_LessFunc ); V_swap( m_LessFunc, that.m_LessFunc );
swap( m_Root, that.m_Root ); V_swap( m_Root, that.m_Root );
swap( m_NumElements, that.m_NumElements ); V_swap( m_NumElements, that.m_NumElements );
swap( m_FirstFree, that.m_FirstFree ); V_swap( m_FirstFree, that.m_FirstFree );
swap( m_pElements, that.m_pElements ); V_swap( m_pElements, that.m_pElements );
swap( m_LastAlloc, that.m_LastAlloc ); V_swap( m_LastAlloc, that.m_LastAlloc );
Assert( IsValid() ); Assert( IsValid() );
Assert( m_Elements.IsValidIterator( m_LastAlloc ) || ( m_NumElements == 0 && m_FirstFree == InvalidIndex() ) ); Assert( m_Elements.IsValidIterator( m_LastAlloc ) || ( m_NumElements == 0 && m_FirstFree == InvalidIndex() ) );
} }

6
public/tier1/utlvector.h
View File

@ -415,7 +415,7 @@ void CUtlVector<T, A>::Sort( int (__cdecl *pfnCompare)(const T *, const T *) )
{ {
if ( pfnCompare( &Element( j - 1 ), &Element( j ) ) < 0 ) if ( pfnCompare( &Element( j - 1 ), &Element( j ) ) < 0 )
{ {
swap( Element( j - 1 ), Element( j ) ); V_swap( Element( j - 1 ), Element( j ) );
} }
} }
} }
@ -605,8 +605,8 @@ template< typename T, class A >
void CUtlVector<T, A>::Swap( CUtlVector< T, A > &vec ) void CUtlVector<T, A>::Swap( CUtlVector< T, A > &vec )
{ {
m_Memory.Swap( vec.m_Memory ); m_Memory.Swap( vec.m_Memory );
swap( m_Size, vec.m_Size ); V_swap( m_Size, vec.m_Size );
swap( m_pElements, vec.m_pElements ); V_swap( m_pElements, vec.m_pElements );
} }
template< typename T, class A > template< typename T, class A >