Fix line endings. WHAMMY.

1 files changed, 334 insertions, 334 deletions

diff --git a/mp/src/public/tier1/utlsoacontainer.h b/mp/src/public/tier1/utlsoacontainer.h
index 55073259..b9440c5f 100644
--- a/mp/src/public/tier1/utlsoacontainer.h
+++ b/mp/src/public/tier1/utlsoacontainer.h
@@ -1,334 +1,334 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//

-//

-// Purpose: 

-//

-// $NoKeywords: $

-//

-// A Fixed-allocation class for maintaining a 1d or 2d or 3d array of data in a structure-of-arrays

-// (SOA) sse-friendly manner.

-// =============================================================================//

-

-#ifndef UTLSOACONTAINER_H

-#define UTLSOACONTAINER_H

-

-#ifdef _WIN32

-#pragma once

-#endif

-

-

-#include "tier0/platform.h"

-#include "tier0/dbg.h"

-#include "tier0/threadtools.h"

-#include "tier1/utlmemory.h"

-#include "tier1/utlblockmemory.h"

-#include "mathlib/ssemath.h"

-

-

-// strided pointers. gives you a class that acts like a pointer, but the ++ and += operators do the

-// right thing

-template<class T> class CStridedPtr

-{

-protected:

-	T *m_pData;

-	size_t m_nStride;

-	

-public:

-	FORCEINLINE CStridedPtr<T>( void *pData, size_t nByteStride )

-	{

-		m_pData = reinterpret_cast<T *>( pData );

-		m_nStride = nByteStride / sizeof( T );

-	}

-

-	FORCEINLINE CStridedPtr<T>( void ) {}

-	T *operator->(void) const

-	{

-		return m_pData;

-	}

-	

-	T & operator*(void) const

-	{

-		return *m_pData;

-	}

-	

-	FORCEINLINE operator T *(void)

-	{

-		return m_pData;

-	}

-

-	FORCEINLINE CStridedPtr<T> & operator++(void)

-	{

-		m_pData += m_nStride;

-		return *this;

-	}

-

-	FORCEINLINE void operator+=( size_t nNumElements )

-	{

-		m_pData += nNumElements * m_nStride;

-	}

-

-};

-

-template<class T> class CStridedConstPtr

-{

-protected:

-	const T *m_pData;

-	size_t m_nStride;

-

-public:

-	FORCEINLINE CStridedConstPtr<T>( void const *pData, size_t nByteStride )

-	{

-		m_pData = reinterpret_cast<T const *>( pData );

-		m_nStride = nByteStride / sizeof( T );

-	}

-

-	FORCEINLINE CStridedConstPtr<T>( void ) {}

-

-	const T *operator->(void) const

-	{

-		return m_pData;

-	}

-

-	const T & operator*(void) const

-	{

-		return *m_pData;

-	}

-

-	FORCEINLINE operator const T *(void) const

-	{

-		return m_pData;

-	}

-

-	FORCEINLINE CStridedConstPtr<T> &operator++(void)

-	{

-		m_pData += m_nStride;

-		return *this;

-	}

-	FORCEINLINE void operator+=( size_t nNumElements )

-	{

-		m_pData += nNumElements*m_nStride;

-	}

-};

-

-// allowed field data types. if you change these values, you need to change the tables in the .cpp file

-enum EAttributeDataType

-{

-	ATTRDATATYPE_FLOAT = 0,									// a float attribute

-	ATTRDATATYPE_4V = 1,									// vector data type, stored as class FourVectors

-	ATTRDATATYPE_INT = 2,									// integer. not especially sse-able on

-															// all architectures.

-	ATTRDATATYPE_POINTER = 3,								// a pointer.

-	ATTRDATATYPE_NONE = -1,									// pad and varargs ender

-};

-

-#define MAX_SOA_FIELDS 32

-

-class CSOAContainer

-{

-

-protected:

-	int m_nColumns;											// # of rows and columns created with

-	int m_nRows;

-	int m_nSlices;

-

-	int m_nPaddedColumns;									// # of columns rounded up for sse

-	int m_nNumQuadsPerRow;									// # of groups of 4 elements per row

-

-	uint8 *m_pDataMemory;									// the actual data memory

-	uint8 *m_pAttributePtrs[MAX_SOA_FIELDS];

-

-	EAttributeDataType m_nDataType[MAX_SOA_FIELDS];

-

-	size_t m_nStrideInBytes[MAX_SOA_FIELDS];			  // stride from one field datum to another

-	size_t m_nRowStrideInBytes[MAX_SOA_FIELDS];			  // stride from one row datum to another per field

-	size_t m_nSliceStrideInBytes[MAX_SOA_FIELDS];         // stride from one slice datum to another per field

-

-

-

-	uint32 m_nFieldPresentMask;

-

-	FORCEINLINE void Init( void )

-	{

-		memset( m_nDataType, 0xff, sizeof( m_nDataType ) );

-		m_pDataMemory = 0;

-		m_nColumns = m_nPaddedColumns = m_nRows = m_nSlices = 0;

-		m_nFieldPresentMask = 0;

-	}

-public:

-

-

-	CSOAContainer( void )									// an empoty one with no attributes

-	{

-		Init();

-	}

-

-	void Purge( void );										// set back to un-initted state, freeing memory

-

-	~CSOAContainer( void );

-

-	// easy constructor for 2d using varargs. call like

-	// #define ATTR_RED 0

-	// #define ATTR_GREEN 1

-	// #define ATTR_BLUE 2

-	// CSOAContainer myimage( 256, 256, ATTR_RED, ATTRDATATYPE_FLOAT, ATTR_GREEN, ATTRDATATYPE_FLOAT,

-	//                        ATTR_BLUE, ATTRDATATYPE_FLOAT, -1 );

-

-	CSOAContainer( int nCols, int nRows, ... );

-

-	size_t ElementSize( void ) const;					// total bytes per element. not super fast.

-

-	// set the data type for an attribute. If you set the data type, but tell it not to allocate,

-	// the data type will be set but writes will assert, and reads will give you back zeros.

-	FORCEINLINE void SetAttributeType( int nAttrIdx, EAttributeDataType nDataType, bool bAllocateMemory = true )

-	{

-		Assert( !m_pDataMemory );							// can't change after memory allocated

-		Assert( nAttrIdx < MAX_SOA_FIELDS );

-		m_nDataType[nAttrIdx] = nDataType;

-		if ( ( m_nDataType[nAttrIdx] != ATTRDATATYPE_NONE ) && bAllocateMemory )

-			m_nFieldPresentMask |= ( 1 << nAttrIdx );

-		else

-			m_nFieldPresentMask &= ~( 1 << nAttrIdx );

-	}

-

-	FORCEINLINE int NumRows( void ) const

-	{

-		return m_nRows;

-	}

-

-	FORCEINLINE int NumCols( void ) const

-	{

-		return m_nColumns;

-	}

-	FORCEINLINE int NumSlices( void ) const

-	{

-		return m_nSlices;

-	}

-

-

-	FORCEINLINE void AssertDataType( int nAttrIdx, EAttributeDataType nDataType ) const

-	{

-		Assert( nAttrIdx >= 0 );

-		Assert( nAttrIdx < MAX_SOA_FIELDS );

-		Assert( m_nStrideInBytes[nAttrIdx] );

-	}

-	

-

-	// # of groups of 4 elements per row

-	FORCEINLINE int NumQuadsPerRow( void ) const

-	{

-		return m_nNumQuadsPerRow;

-	}

-

-	FORCEINLINE int Count( void ) const						// for 1d data

-	{

-		return NumCols();

-	}

-

-	FORCEINLINE int NumElements( void ) const

-	{

-		return NumCols() * NumRows() * NumSlices();

-	}

-

-

-	// how much to step to go from the end of one row to the start of the next one. Basically, how

-	// many bytes to add at the end of a row when iterating over the whole 2d array with ++

-	FORCEINLINE size_t RowToRowStep( int nAttrIdx ) const

-	{

-		return 0;

-	}

-	

-	FORCEINLINE void *RowPtr( int nAttributeIdx, int nRowNumber, int nSliceNumber = 0 ) const

-	{

-		Assert( nRowNumber < m_nRows );

-		Assert( nAttributeIdx < MAX_SOA_FIELDS );

-		Assert( m_nDataType[nAttributeIdx] != ATTRDATATYPE_NONE );

-		Assert( m_nFieldPresentMask & ( 1 << nAttributeIdx ) );

-		return m_pAttributePtrs[nAttributeIdx] + 

-			+ nRowNumber * m_nRowStrideInBytes[nAttributeIdx]

-			+ nSliceNumber * m_nSliceStrideInBytes[nAttributeIdx];

-	}

-

-	FORCEINLINE void const *ConstRowPtr( int nAttributeIdx, int nRowNumber, int nSliceNumber = 0 ) const

-	{

-		Assert( nRowNumber < m_nRows );

-		Assert( nAttributeIdx < MAX_SOA_FIELDS );

-		Assert( m_nDataType[nAttributeIdx] != ATTRDATATYPE_NONE );

-		return m_pAttributePtrs[nAttributeIdx] 

-			+ nRowNumber * m_nRowStrideInBytes[nAttributeIdx]

-			+ nSliceNumber * m_nSliceStrideInBytes[nAttributeIdx];

-	}

-

-

-	template<class T> FORCEINLINE T *ElementPointer( int nAttributeIdx, 

-													   int nX = 0, int nY = 0, int nZ = 0 ) const

-	{

-		Assert( nAttributeIdx < MAX_SOA_FIELDS );

-		Assert( nX < m_nColumns );

-		Assert( nY < m_nRows );

-		Assert( nZ < m_nSlices );

-		Assert( m_nDataType[nAttributeIdx] != ATTRDATATYPE_NONE );

-		Assert( m_nDataType[nAttributeIdx] != ATTRDATATYPE_4V );

-		return reinterpret_cast<T *>( m_pAttributePtrs[nAttributeIdx] 

-									  + nX * sizeof( float )

-									  + nY * m_nRowStrideInBytes[nAttributeIdx]

-									  + nZ * m_nSliceStrideInBytes[nAttributeIdx]

-			);

-	}

-		

-	FORCEINLINE size_t ItemByteStride( int nAttributeIdx ) const

-	{

-		Assert( nAttributeIdx < MAX_SOA_FIELDS );

-		Assert( m_nDataType[nAttributeIdx] != ATTRDATATYPE_NONE );

-		return m_nStrideInBytes[ nAttributeIdx ];

-	}

-

-	// copy the attribute data from another soacontainer. must be compatible geometry

-	void CopyAttrFrom( CSOAContainer const &other, int nAttributeIdx );

-

-	// copy the attribute data from another attribute. must be compatible data format

-	void CopyAttrToAttr( int nSrcAttributeIndex, int nDestAttributeIndex);

-

-	// move all the data from one csoacontainer to another, leaving the source empty.

-	// this is just a pointer copy.

-	FORCEINLINE void MoveDataFrom( CSOAContainer other )

-	{

-		(*this) = other;

-		other.Init();

-	}

-

-

-

-	void AllocateData( int nNCols, int nNRows, int nSlices = 1 ); // actually allocate the memory and set the pointers up

-

-	// arithmetic and data filling functions. All SIMD and hopefully fast

-

-	// set all elements of a float attribute to random #s

-	void RandomizeAttribute( int nAttr, float flMin, float flMax ) const ;

-

-	// fill 2d a rectangle with values interpolated from 4 corner values. 

-	void FillAttrWithInterpolatedValues( int nAttr, float flValue00, float flValue10, float flValue01, float flValue11 ) const;

-	void FillAttrWithInterpolatedValues( int nAttr, Vector flValue00, Vector flValue10,

-										 Vector const &flValue01, Vector const &flValue11 ) const;

-

-};

-

-class CFltX4AttributeIterator : public CStridedConstPtr<fltx4>

-{

-	FORCEINLINE CFltX4AttributeIterator( CSOAContainer const *pContainer, int nAttribute, int nRowNumber = 0 )

-		: CStridedConstPtr<fltx4>( pContainer->ConstRowPtr( nAttribute, nRowNumber), 

-								   pContainer->ItemByteStride( nAttribute ) )

-	{

-	}

-};

-

-class CFltX4AttributeWriteIterator : public CStridedPtr<fltx4>

-{

-	FORCEINLINE CFltX4AttributeWriteIterator( CSOAContainer const *pContainer, int nAttribute, int nRowNumber = 0 )

-		: CStridedPtr<fltx4>( pContainer->RowPtr( nAttribute, nRowNumber), 

-							  pContainer->ItemByteStride( nAttribute ) )

-	{

-	}

-	

-};

-

-

-#endif

+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+// A Fixed-allocation class for maintaining a 1d or 2d or 3d array of data in a structure-of-arrays
+// (SOA) sse-friendly manner.
+// =============================================================================//
+
+#ifndef UTLSOACONTAINER_H
+#define UTLSOACONTAINER_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "tier0/platform.h"
+#include "tier0/dbg.h"
+#include "tier0/threadtools.h"
+#include "tier1/utlmemory.h"
+#include "tier1/utlblockmemory.h"
+#include "mathlib/ssemath.h"
+
+
+// strided pointers. gives you a class that acts like a pointer, but the ++ and += operators do the
+// right thing
+template<class T> class CStridedPtr
+{
+protected:
+	T *m_pData;
+	size_t m_nStride;
+	
+public:
+	FORCEINLINE CStridedPtr<T>( void *pData, size_t nByteStride )
+	{
+		m_pData = reinterpret_cast<T *>( pData );
+		m_nStride = nByteStride / sizeof( T );
+	}
+
+	FORCEINLINE CStridedPtr<T>( void ) {}
+	T *operator->(void) const
+	{
+		return m_pData;
+	}
+	
+	T & operator*(void) const
+	{
+		return *m_pData;
+	}
+	
+	FORCEINLINE operator T *(void)
+	{
+		return m_pData;
+	}
+
+	FORCEINLINE CStridedPtr<T> & operator++(void)
+	{
+		m_pData += m_nStride;
+		return *this;
+	}
+
+	FORCEINLINE void operator+=( size_t nNumElements )
+	{
+		m_pData += nNumElements * m_nStride;
+	}
+
+};
+
+template<class T> class CStridedConstPtr
+{
+protected:
+	const T *m_pData;
+	size_t m_nStride;
+
+public:
+	FORCEINLINE CStridedConstPtr<T>( void const *pData, size_t nByteStride )
+	{
+		m_pData = reinterpret_cast<T const *>( pData );
+		m_nStride = nByteStride / sizeof( T );
+	}
+
+	FORCEINLINE CStridedConstPtr<T>( void ) {}
+
+	const T *operator->(void) const
+	{
+		return m_pData;
+	}
+
+	const T & operator*(void) const
+	{
+		return *m_pData;
+	}
+
+	FORCEINLINE operator const T *(void) const
+	{
+		return m_pData;
+	}
+
+	FORCEINLINE CStridedConstPtr<T> &operator++(void)
+	{
+		m_pData += m_nStride;
+		return *this;
+	}
+	FORCEINLINE void operator+=( size_t nNumElements )
+	{
+		m_pData += nNumElements*m_nStride;
+	}
+};
+
+// allowed field data types. if you change these values, you need to change the tables in the .cpp file
+enum EAttributeDataType
+{
+	ATTRDATATYPE_FLOAT = 0,									// a float attribute
+	ATTRDATATYPE_4V = 1,									// vector data type, stored as class FourVectors
+	ATTRDATATYPE_INT = 2,									// integer. not especially sse-able on
+															// all architectures.
+	ATTRDATATYPE_POINTER = 3,								// a pointer.
+	ATTRDATATYPE_NONE = -1,									// pad and varargs ender
+};
+
+#define MAX_SOA_FIELDS 32
+
+class CSOAContainer
+{
+
+protected:
+	int m_nColumns;											// # of rows and columns created with
+	int m_nRows;
+	int m_nSlices;
+
+	int m_nPaddedColumns;									// # of columns rounded up for sse
+	int m_nNumQuadsPerRow;									// # of groups of 4 elements per row
+
+	uint8 *m_pDataMemory;									// the actual data memory
+	uint8 *m_pAttributePtrs[MAX_SOA_FIELDS];
+
+	EAttributeDataType m_nDataType[MAX_SOA_FIELDS];
+
+	size_t m_nStrideInBytes[MAX_SOA_FIELDS];			  // stride from one field datum to another
+	size_t m_nRowStrideInBytes[MAX_SOA_FIELDS];			  // stride from one row datum to another per field
+	size_t m_nSliceStrideInBytes[MAX_SOA_FIELDS];         // stride from one slice datum to another per field
+
+
+
+	uint32 m_nFieldPresentMask;
+
+	FORCEINLINE void Init( void )
+	{
+		memset( m_nDataType, 0xff, sizeof( m_nDataType ) );
+		m_pDataMemory = 0;
+		m_nColumns = m_nPaddedColumns = m_nRows = m_nSlices = 0;
+		m_nFieldPresentMask = 0;
+	}
+public:
+
+
+	CSOAContainer( void )									// an empoty one with no attributes
+	{
+		Init();
+	}
+
+	void Purge( void );										// set back to un-initted state, freeing memory
+
+	~CSOAContainer( void );
+
+	// easy constructor for 2d using varargs. call like
+	// #define ATTR_RED 0
+	// #define ATTR_GREEN 1
+	// #define ATTR_BLUE 2
+	// CSOAContainer myimage( 256, 256, ATTR_RED, ATTRDATATYPE_FLOAT, ATTR_GREEN, ATTRDATATYPE_FLOAT,
+	//                        ATTR_BLUE, ATTRDATATYPE_FLOAT, -1 );
+
+	CSOAContainer( int nCols, int nRows, ... );
+
+	size_t ElementSize( void ) const;					// total bytes per element. not super fast.
+
+	// set the data type for an attribute. If you set the data type, but tell it not to allocate,
+	// the data type will be set but writes will assert, and reads will give you back zeros.
+	FORCEINLINE void SetAttributeType( int nAttrIdx, EAttributeDataType nDataType, bool bAllocateMemory = true )
+	{
+		Assert( !m_pDataMemory );							// can't change after memory allocated
+		Assert( nAttrIdx < MAX_SOA_FIELDS );
+		m_nDataType[nAttrIdx] = nDataType;
+		if ( ( m_nDataType[nAttrIdx] != ATTRDATATYPE_NONE ) && bAllocateMemory )
+			m_nFieldPresentMask |= ( 1 << nAttrIdx );
+		else
+			m_nFieldPresentMask &= ~( 1 << nAttrIdx );
+	}
+
+	FORCEINLINE int NumRows( void ) const
+	{
+		return m_nRows;
+	}
+
+	FORCEINLINE int NumCols( void ) const
+	{
+		return m_nColumns;
+	}
+	FORCEINLINE int NumSlices( void ) const
+	{
+		return m_nSlices;
+	}
+
+
+	FORCEINLINE void AssertDataType( int nAttrIdx, EAttributeDataType nDataType ) const
+	{
+		Assert( nAttrIdx >= 0 );
+		Assert( nAttrIdx < MAX_SOA_FIELDS );
+		Assert( m_nStrideInBytes[nAttrIdx] );
+	}
+	
+
+	// # of groups of 4 elements per row
+	FORCEINLINE int NumQuadsPerRow( void ) const
+	{
+		return m_nNumQuadsPerRow;
+	}
+
+	FORCEINLINE int Count( void ) const						// for 1d data
+	{
+		return NumCols();
+	}
+
+	FORCEINLINE int NumElements( void ) const
+	{
+		return NumCols() * NumRows() * NumSlices();
+	}
+
+
+	// how much to step to go from the end of one row to the start of the next one. Basically, how
+	// many bytes to add at the end of a row when iterating over the whole 2d array with ++
+	FORCEINLINE size_t RowToRowStep( int nAttrIdx ) const
+	{
+		return 0;
+	}
+	
+	FORCEINLINE void *RowPtr( int nAttributeIdx, int nRowNumber, int nSliceNumber = 0 ) const
+	{
+		Assert( nRowNumber < m_nRows );
+		Assert( nAttributeIdx < MAX_SOA_FIELDS );
+		Assert( m_nDataType[nAttributeIdx] != ATTRDATATYPE_NONE );
+		Assert( m_nFieldPresentMask & ( 1 << nAttributeIdx ) );
+		return m_pAttributePtrs[nAttributeIdx] + 
+			+ nRowNumber * m_nRowStrideInBytes[nAttributeIdx]
+			+ nSliceNumber * m_nSliceStrideInBytes[nAttributeIdx];
+	}
+
+	FORCEINLINE void const *ConstRowPtr( int nAttributeIdx, int nRowNumber, int nSliceNumber = 0 ) const
+	{
+		Assert( nRowNumber < m_nRows );
+		Assert( nAttributeIdx < MAX_SOA_FIELDS );
+		Assert( m_nDataType[nAttributeIdx] != ATTRDATATYPE_NONE );
+		return m_pAttributePtrs[nAttributeIdx] 
+			+ nRowNumber * m_nRowStrideInBytes[nAttributeIdx]
+			+ nSliceNumber * m_nSliceStrideInBytes[nAttributeIdx];
+	}
+
+
+	template<class T> FORCEINLINE T *ElementPointer( int nAttributeIdx, 
+													   int nX = 0, int nY = 0, int nZ = 0 ) const
+	{
+		Assert( nAttributeIdx < MAX_SOA_FIELDS );
+		Assert( nX < m_nColumns );
+		Assert( nY < m_nRows );
+		Assert( nZ < m_nSlices );
+		Assert( m_nDataType[nAttributeIdx] != ATTRDATATYPE_NONE );
+		Assert( m_nDataType[nAttributeIdx] != ATTRDATATYPE_4V );
+		return reinterpret_cast<T *>( m_pAttributePtrs[nAttributeIdx] 
+									  + nX * sizeof( float )
+									  + nY * m_nRowStrideInBytes[nAttributeIdx]
+									  + nZ * m_nSliceStrideInBytes[nAttributeIdx]
+			);
+	}
+		
+	FORCEINLINE size_t ItemByteStride( int nAttributeIdx ) const
+	{
+		Assert( nAttributeIdx < MAX_SOA_FIELDS );
+		Assert( m_nDataType[nAttributeIdx] != ATTRDATATYPE_NONE );
+		return m_nStrideInBytes[ nAttributeIdx ];
+	}
+
+	// copy the attribute data from another soacontainer. must be compatible geometry
+	void CopyAttrFrom( CSOAContainer const &other, int nAttributeIdx );
+
+	// copy the attribute data from another attribute. must be compatible data format
+	void CopyAttrToAttr( int nSrcAttributeIndex, int nDestAttributeIndex);
+
+	// move all the data from one csoacontainer to another, leaving the source empty.
+	// this is just a pointer copy.
+	FORCEINLINE void MoveDataFrom( CSOAContainer other )
+	{
+		(*this) = other;
+		other.Init();
+	}
+
+
+
+	void AllocateData( int nNCols, int nNRows, int nSlices = 1 ); // actually allocate the memory and set the pointers up
+
+	// arithmetic and data filling functions. All SIMD and hopefully fast
+
+	// set all elements of a float attribute to random #s
+	void RandomizeAttribute( int nAttr, float flMin, float flMax ) const ;
+
+	// fill 2d a rectangle with values interpolated from 4 corner values. 
+	void FillAttrWithInterpolatedValues( int nAttr, float flValue00, float flValue10, float flValue01, float flValue11 ) const;
+	void FillAttrWithInterpolatedValues( int nAttr, Vector flValue00, Vector flValue10,
+										 Vector const &flValue01, Vector const &flValue11 ) const;
+
+};
+
+class CFltX4AttributeIterator : public CStridedConstPtr<fltx4>
+{
+	FORCEINLINE CFltX4AttributeIterator( CSOAContainer const *pContainer, int nAttribute, int nRowNumber = 0 )
+		: CStridedConstPtr<fltx4>( pContainer->ConstRowPtr( nAttribute, nRowNumber), 
+								   pContainer->ItemByteStride( nAttribute ) )
+	{
+	}
+};
+
+class CFltX4AttributeWriteIterator : public CStridedPtr<fltx4>
+{
+	FORCEINLINE CFltX4AttributeWriteIterator( CSOAContainer const *pContainer, int nAttribute, int nRowNumber = 0 )
+		: CStridedPtr<fltx4>( pContainer->RowPtr( nAttribute, nRowNumber), 
+							  pContainer->ItemByteStride( nAttribute ) )
+	{
+	}
+	
+};
+
+
+#endif