Fix line endings. WHAMMY.

1 files changed, 559 insertions, 559 deletions

diff --git a/sp/src/tier1/utlbufferutil.cpp b/sp/src/tier1/utlbufferutil.cpp
index f628587c..b911206d 100644
--- a/sp/src/tier1/utlbufferutil.cpp
+++ b/sp/src/tier1/utlbufferutil.cpp
@@ -1,559 +1,559 @@
-//========= Copyright Valve Corporation, All rights reserved. ============//

-//

-// $Header: $

-// $NoKeywords: $

-//

-// Serialization buffer

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

-

-#pragma warning (disable : 4514)

-

-#include "tier1/utlbufferutil.h"

-#include "tier1/utlbuffer.h"

-#include "mathlib/vector.h"

-#include "mathlib/vector2d.h"

-#include "mathlib/vector4d.h"

-#include "mathlib/vmatrix.h"

-#include "Color.h"

-#include <stdio.h>

-#include <stdarg.h>

-#include <ctype.h>

-#include <stdlib.h>

-#include <limits.h>

-#include "tier1/utlstring.h"

-#include "tier1/strtools.h"

-#include "tier1/characterset.h"

-

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

-#include "tier0/memdbgon.h"

-			    

-

-//-----------------------------------------------------------------------------

-// For serialization, set the delimiter rules

-//-----------------------------------------------------------------------------

-CUtlCharConversion *s_pConv = NULL;

-const char *s_pUtlBufferUtilArrayDelim = NULL;

-void SetSerializationDelimiter( CUtlCharConversion *pConv )

-{

-	s_pConv = pConv;

-}

-

-void SetSerializationArrayDelimiter( const char *pDelimiter )

-{

-	s_pUtlBufferUtilArrayDelim = pDelimiter;

-}

-

-

-//-----------------------------------------------------------------------------

-// Serialize a floating point number in text mode in a readably friendly fashion

-//-----------------------------------------------------------------------------

-static void SerializeFloat( CUtlBuffer &buf, float f )

-{

-	Assert( buf.IsText() );

-

-	// FIXME: Print this in a way that we never lose precision

-	char pTemp[256];

-	int nLen = Q_snprintf( pTemp, sizeof(pTemp), "%.10f", f );

-	while ( nLen > 0 && pTemp[nLen-1] == '0' )

-	{

-		--nLen;

-		pTemp[nLen] = 0;

-	}

-	if ( nLen > 0 && pTemp[nLen-1] == '.' )

-	{

-		--nLen;

-		pTemp[nLen] = 0;

-	}

-	buf.PutString( pTemp );

-}

-

-static void SerializeFloats( CUtlBuffer &buf, int nCount, const float *pFloats )

-{

-	for ( int i = 0; i < nCount; ++i )

-	{

-		SerializeFloat( buf, pFloats[i] );

-		if ( i != nCount-1 )

-		{

-			buf.PutChar( ' ' );

-		}

-	}

-}

-

-

-//-----------------------------------------------------------------------------

-// Serialization methods for basic types

-//-----------------------------------------------------------------------------

-bool Serialize( CUtlBuffer &buf, const bool &src )

-{

-	if ( buf.IsText() )

-	{

-		buf.Printf( "%d", src );

-	}

-	else

-	{

-		buf.PutChar( src );

-	}

-	return buf.IsValid();

-}

-

-bool Unserialize( CUtlBuffer &buf, bool &dest )

-{

-	if ( buf.IsText() )

-	{

-		int nValue = 0;

-		int nRetVal = buf.Scanf( "%d", &nValue );

-		dest = ( nValue != 0 );

-		return (nRetVal == 1) && buf.IsValid();

-	}

-

-	dest = ( buf.GetChar( ) != 0 );

-	return buf.IsValid();

-}

-

-

-bool Serialize( CUtlBuffer &buf, const int &src )

-{

-	if ( buf.IsText() )

-	{

-		buf.Printf( "%d", src );

-	}

-	else

-	{

-		buf.PutInt( src );

-	}

-	return buf.IsValid();

-}

-

-bool Unserialize( CUtlBuffer &buf, int &dest )

-{

-	if ( buf.IsText() )

-	{

-		int nRetVal = buf.Scanf( "%d", &dest );

-		return (nRetVal == 1) && buf.IsValid();

-	}

-

-	dest = buf.GetInt( );

-	return buf.IsValid();

-}

-

-bool Serialize( CUtlBuffer &buf, const float &src )

-{

-	if ( buf.IsText() )

-	{

-		SerializeFloat( buf, src );

-	}

-	else

-	{

-		buf.PutFloat( src );

-	}

-	return buf.IsValid();

-}

-

-bool Unserialize( CUtlBuffer &buf, float &dest )

-{

-	if ( buf.IsText() )

-	{

-		// FIXME: Print this in a way that we never lose precision

-		int nRetVal = buf.Scanf( "%f", &dest );

-		return (nRetVal == 1) && buf.IsValid();

-	}

-

-	dest = buf.GetFloat( );

-	return buf.IsValid();

-}

-

-

-//-----------------------------------------------------------------------------

-// Attribute types related to vector math

-//-----------------------------------------------------------------------------

-bool Serialize( CUtlBuffer &buf, const Vector2D &src )

-{

-	if ( buf.IsText() )

-	{

-		SerializeFloats( buf, 2, src.Base() );

-	}

-	else

-	{

-		buf.PutFloat( src.x );

-		buf.PutFloat( src.y );

-	}

-	return buf.IsValid();

-}

-

-bool Unserialize( CUtlBuffer &buf, Vector2D &dest )

-{

-	if ( buf.IsText() )

-	{

-		// FIXME: Print this in a way that we never lose precision

-		int nRetVal = buf.Scanf( "%f %f", &dest.x, &dest.y );

-		return (nRetVal == 2) && buf.IsValid();

-	}

-

-	dest.x = buf.GetFloat( );

-	dest.y = buf.GetFloat( );

-	return buf.IsValid();

-}

-

-bool Serialize( CUtlBuffer &buf, const Vector &src )

-{

-	if ( buf.IsText() )

-	{

-		SerializeFloats( buf, 3, src.Base() );

-	}

-	else

-	{

-		buf.PutFloat( src.x );

-		buf.PutFloat( src.y );

-		buf.PutFloat( src.z );

-	}

-	return buf.IsValid();

-}

-

-bool Unserialize( CUtlBuffer &buf, Vector &dest )

-{

-	if ( buf.IsText() )

-	{

-		// FIXME: Print this in a way that we never lose precision

-		int nRetVal = buf.Scanf( "%f %f %f", &dest.x, &dest.y, &dest.z );

-		return (nRetVal == 3) && buf.IsValid();

-	}

-

-	dest.x = buf.GetFloat( );

-	dest.y = buf.GetFloat( );

-	dest.z = buf.GetFloat( );

-	return buf.IsValid();

-}

-

-bool Serialize( CUtlBuffer &buf, const Vector4D &src )

-{

-	if ( buf.IsText() )

-	{

-		SerializeFloats( buf, 4, src.Base() );

-	}

-	else

-	{

-		buf.PutFloat( src.x );

-		buf.PutFloat( src.y );

-		buf.PutFloat( src.z );

-		buf.PutFloat( src.w );

-	}

-	return buf.IsValid();

-}

-

-bool Unserialize( CUtlBuffer &buf, Vector4D &dest )

-{

-	if ( buf.IsText() )

-	{

-		// FIXME: Print this in a way that we never lose precision

-		int nRetVal = buf.Scanf( "%f %f %f %f", &dest.x, &dest.y, &dest.z, &dest.w );

-		return (nRetVal == 4) && buf.IsValid();

-	}

-

-	dest.x = buf.GetFloat( );

-	dest.y = buf.GetFloat( );

-	dest.z = buf.GetFloat( );

-	dest.w = buf.GetFloat( );

-	return buf.IsValid();

-}

-

-bool Serialize( CUtlBuffer &buf, const QAngle &src )

-{

-	if ( buf.IsText() )

-	{

-		SerializeFloats( buf, 3, src.Base() );

-	}

-	else

-	{

-		buf.PutFloat( src.x );

-		buf.PutFloat( src.y );

-		buf.PutFloat( src.z );

-	}

-	return buf.IsValid();

-}

-

-bool Unserialize( CUtlBuffer &buf, QAngle &dest )

-{

-	if ( buf.IsText() )

-	{

-		// FIXME: Print this in a way that we never lose precision

-		int nRetVal = buf.Scanf( "%f %f %f", &dest.x, &dest.y, &dest.z );

-		return (nRetVal == 3) && buf.IsValid();

-	}

-

-	dest.x = buf.GetFloat( );

-	dest.y = buf.GetFloat( );

-	dest.z = buf.GetFloat( );

-	return buf.IsValid();

-}

-

-bool Serialize( CUtlBuffer &buf, const Quaternion &src )

-{

-	if ( buf.IsText() )

-	{

-		SerializeFloats( buf, 4, &src.x );

-	}

-	else

-	{

-		buf.PutFloat( src.x );

-		buf.PutFloat( src.y );

-		buf.PutFloat( src.z );

-		buf.PutFloat( src.w );

-	}

-	return buf.IsValid();

-}

-

-bool Unserialize( CUtlBuffer &buf, Quaternion &dest )

-{

-	if ( buf.IsText() )

-	{

-		// FIXME: Print this in a way that we never lose precision

-		int nRetVal = buf.Scanf( "%f %f %f %f", &dest.x, &dest.y, &dest.z, &dest.w );

-		return (nRetVal == 4) && buf.IsValid();

-	}

-

-	dest.x = buf.GetFloat( );

-	dest.y = buf.GetFloat( );

-	dest.z = buf.GetFloat( );

-	dest.w = buf.GetFloat( );

-	return buf.IsValid();

-}

-

-bool Serialize( CUtlBuffer &buf, const VMatrix &src )

-{

-	if ( buf.IsText() )

-	{

-		buf.Printf( "\n" );

-		SerializeFloats( buf, 4, src[0] );

-		buf.Printf( "\n" );

-		SerializeFloats( buf, 4, src[1] );

-		buf.Printf( "\n" );

-		SerializeFloats( buf, 4, src[2] );

-		buf.Printf( "\n" );

-		SerializeFloats( buf, 4, src[3] );

-		buf.Printf( "\n" );

-	}

-	else

-	{

-		buf.Put( &src, sizeof(VMatrix) );

-	}

-	return buf.IsValid();

-}

-

-bool Unserialize( CUtlBuffer &buf, VMatrix &dest )

-{

-	if ( !buf.IsValid() )

-		return false;

-

-	if ( buf.IsText() )

-	{

-		int nRetVal = buf.Scanf( "%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f",

-			&dest[ 0 ][ 0 ], &dest[ 0 ][ 1 ], &dest[ 0 ][ 2 ], &dest[ 0 ][ 3 ],

-			&dest[ 1 ][ 0 ], &dest[ 1 ][ 1 ], &dest[ 1 ][ 2 ], &dest[ 1 ][ 3 ],

-			&dest[ 2 ][ 0 ], &dest[ 2 ][ 1 ], &dest[ 2 ][ 2 ], &dest[ 2 ][ 3 ],

-			&dest[ 3 ][ 0 ], &dest[ 3 ][ 1 ], &dest[ 3 ][ 2 ], &dest[ 3 ][ 3 ] );

-		return (nRetVal == 16);

-	}

-

-	buf.Get( &dest, sizeof(VMatrix) );

-	return true;

-}

-

-

-//-----------------------------------------------------------------------------

-// Color attribute

-//-----------------------------------------------------------------------------

-bool Serialize( CUtlBuffer &buf, const Color &src )

-{

-	if ( buf.IsText() )

-	{

-		buf.Printf( "%d %d %d %d", src[0], src[1], src[2], src[3] );

-	}

-	else

-	{

-		buf.PutUnsignedChar( src[0] );

-		buf.PutUnsignedChar( src[1] );

-		buf.PutUnsignedChar( src[2] );

-		buf.PutUnsignedChar( src[3] );

-	}

-	return buf.IsValid();

-}

-

-bool Unserialize( CUtlBuffer &buf, Color &dest )

-{

-	if ( buf.IsText() )

-	{

-		int r = 0, g = 0, b = 0, a = 255;

-		int nRetVal = buf.Scanf( "%d %d %d %d", &r, &g, &b, &a );

-		dest.SetColor( r, g, b, a );

-		return (nRetVal == 4) && buf.IsValid();

-	}

-

-	dest[0] = buf.GetUnsignedChar( );

-	dest[1] = buf.GetUnsignedChar( );

-	dest[2] = buf.GetUnsignedChar( );

-	dest[3] = buf.GetUnsignedChar( );

-	return buf.IsValid();

-}

-

-/*

-//-----------------------------------------------------------------------------

-// Object ID attribute

-//-----------------------------------------------------------------------------

-bool Serialize( CUtlBuffer &buf, const DmObjectId_t &src )

-{

-	return g_pDataModel->Serialize( buf, src );

-}

-

-bool Unserialize( CUtlBuffer &buf, DmObjectId_t &dest )

-{

-	return g_pDataModel->Unserialize( buf, &dest );

-}

-*/

-

-//-----------------------------------------------------------------------------

-// Binary buffer attribute

-//-----------------------------------------------------------------------------

-bool Serialize( CUtlBuffer &buf, const CUtlBinaryBlock &src )

-{

-	int nLength = src.Length();

-	if ( !buf.IsText() )

-	{

-		buf.PutInt( nLength );

-		if ( nLength != 0 )

-		{

-			buf.Put( src.Get(), nLength );

-		}

-		return buf.IsValid();

-	}

-

-	// Writes out uuencoded binaries

-	for ( int i = 0; i < nLength; ++i )

-	{

-		if ( (i % 40) == 0 )

-		{

-			buf.PutChar( '\n' );

-		}

-

-		char b1 = src[i] & 0xF;

-		char b2 = src[i] >> 4;

-

-		char c1 = ( b1 <= 9 ) ? b1 + '0' : b1 - 10 + 'A';

-		char c2 = ( b2 <= 9 ) ? b2 + '0' : b2 - 10 + 'A';

-

-		buf.PutChar( c2 );

-		buf.PutChar( c1 );

-	}

-

-	buf.PutChar( '\n' );

-	return buf.IsValid();

-}

-

-static int CountBinaryBytes( CUtlBuffer &buf, int *pEndGet )

-{

-	// This counts the number of bytes in the uuencoded text

-	int nStartGet = buf.TellGet();

-	buf.EatWhiteSpace();

-	*pEndGet = buf.TellGet();

-	int nByteCount = 0;

-	while ( buf.IsValid() )

-	{

-		char c1 = buf.GetChar();

-		char c2 = buf.GetChar();

-

-		bool bIsNum1 = ( c1 >= '0' ) && ( c1 <= '9' );

-		bool bIsNum2 = ( c2 >= '0' ) && ( c2 <= '9' );

-

-		bool bIsAlpha1 = (( c1 >= 'A' ) && ( c1 <= 'F' )) || (( c1 >= 'a' ) && ( c1 <= 'f' ));

-		bool bIsAlpha2 = (( c2 >= 'A' ) && ( c2 <= 'F' )) || (( c2 >= 'a' ) && ( c2 <= 'f' ));

-

-		if ( !(bIsNum1 || bIsAlpha1) || !(bIsNum2 || bIsAlpha2) )

-			break;

-

-		buf.EatWhiteSpace();

-		*pEndGet = buf.TellGet();

-		++nByteCount;

-	}

-	buf.SeekGet( CUtlBuffer::SEEK_HEAD, nStartGet );

-	return nByteCount;

-}

-

-inline static unsigned char HexCharToInt( int c1 )

-{

-	if (( c1 >= '0' ) && ( c1 <= '9' ))

-		return c1 - '0';

-

-	if (( c1 >= 'A' ) && ( c1 <= 'F' ))

-		return 10 + c1 - 'A';

-

-	if (( c1 >= 'a' ) && ( c1 <= 'f' ))

-		return 10 + c1 - 'a';

-

-	return 0xFF;

-}

-

-bool Unserialize( CUtlBuffer &buf, CUtlBinaryBlock &dest )

-{

-	if ( !buf.IsText() )

-	{

-		int nLen = buf.GetInt( );

-		dest.SetLength( nLen );

-		if ( dest.Length() != 0 )

-		{

-			buf.Get( dest.Get(), dest.Length() );

-		}

-

-		if ( nLen != dest.Length() )

-		{

-			buf.SeekGet( CUtlBuffer::SEEK_CURRENT, nLen - dest.Length() );

-			return false;

-		}

-

-		return buf.IsValid();

-	}

-

-	int nEndGet;

-	int nByteCount = CountBinaryBytes( buf, &nEndGet );

-	if ( nByteCount < 0 )

-		return false;

-

-	buf.EatWhiteSpace();

-	int nDest = 0;

-	dest.SetLength( nByteCount );

-	while( buf.TellGet() < nEndGet )

-	{

-		char c1 = buf.GetChar();

-		char c2 = buf.GetChar();

-

-		unsigned char b1 = HexCharToInt( c1 );

-		unsigned char b2 = HexCharToInt( c2 );

-		if ( b1 == 0xFF || b2 == 0xFF )

-			return false;

-

-		dest[ nDest++ ] = b2 | ( b1 << 4 );

-		buf.EatWhiteSpace();

-	}

-

-	return true;

-}

-

-

-//-----------------------------------------------------------------------------

-// String attribute

-//-----------------------------------------------------------------------------

-bool Serialize( CUtlBuffer &buf, const CUtlString &src )

-{

-	buf.PutDelimitedString( s_pConv, src.Get() );

-	return buf.IsValid();

-}

-

-bool Unserialize( CUtlBuffer &buf, CUtlString &dest )

-{

-	int nLen = buf.PeekDelimitedStringLength( s_pConv );

-	dest.SetLength( nLen - 1 );	// -1 because the length returned includes space for \0

-	buf.GetDelimitedString( s_pConv, dest.Get(), nLen );

-	return buf.IsValid();

-}

-

-

-

-

+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// $Header: $
+// $NoKeywords: $
+//
+// Serialization buffer
+//===========================================================================//
+
+#pragma warning (disable : 4514)
+
+#include "tier1/utlbufferutil.h"
+#include "tier1/utlbuffer.h"
+#include "mathlib/vector.h"
+#include "mathlib/vector2d.h"
+#include "mathlib/vector4d.h"
+#include "mathlib/vmatrix.h"
+#include "Color.h"
+#include <stdio.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <limits.h>
+#include "tier1/utlstring.h"
+#include "tier1/strtools.h"
+#include "tier1/characterset.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+			    
+
+//-----------------------------------------------------------------------------
+// For serialization, set the delimiter rules
+//-----------------------------------------------------------------------------
+CUtlCharConversion *s_pConv = NULL;
+const char *s_pUtlBufferUtilArrayDelim = NULL;
+void SetSerializationDelimiter( CUtlCharConversion *pConv )
+{
+	s_pConv = pConv;
+}
+
+void SetSerializationArrayDelimiter( const char *pDelimiter )
+{
+	s_pUtlBufferUtilArrayDelim = pDelimiter;
+}
+
+
+//-----------------------------------------------------------------------------
+// Serialize a floating point number in text mode in a readably friendly fashion
+//-----------------------------------------------------------------------------
+static void SerializeFloat( CUtlBuffer &buf, float f )
+{
+	Assert( buf.IsText() );
+
+	// FIXME: Print this in a way that we never lose precision
+	char pTemp[256];
+	int nLen = Q_snprintf( pTemp, sizeof(pTemp), "%.10f", f );
+	while ( nLen > 0 && pTemp[nLen-1] == '0' )
+	{
+		--nLen;
+		pTemp[nLen] = 0;
+	}
+	if ( nLen > 0 && pTemp[nLen-1] == '.' )
+	{
+		--nLen;
+		pTemp[nLen] = 0;
+	}
+	buf.PutString( pTemp );
+}
+
+static void SerializeFloats( CUtlBuffer &buf, int nCount, const float *pFloats )
+{
+	for ( int i = 0; i < nCount; ++i )
+	{
+		SerializeFloat( buf, pFloats[i] );
+		if ( i != nCount-1 )
+		{
+			buf.PutChar( ' ' );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Serialization methods for basic types
+//-----------------------------------------------------------------------------
+bool Serialize( CUtlBuffer &buf, const bool &src )
+{
+	if ( buf.IsText() )
+	{
+		buf.Printf( "%d", src );
+	}
+	else
+	{
+		buf.PutChar( src );
+	}
+	return buf.IsValid();
+}
+
+bool Unserialize( CUtlBuffer &buf, bool &dest )
+{
+	if ( buf.IsText() )
+	{
+		int nValue = 0;
+		int nRetVal = buf.Scanf( "%d", &nValue );
+		dest = ( nValue != 0 );
+		return (nRetVal == 1) && buf.IsValid();
+	}
+
+	dest = ( buf.GetChar( ) != 0 );
+	return buf.IsValid();
+}
+
+
+bool Serialize( CUtlBuffer &buf, const int &src )
+{
+	if ( buf.IsText() )
+	{
+		buf.Printf( "%d", src );
+	}
+	else
+	{
+		buf.PutInt( src );
+	}
+	return buf.IsValid();
+}
+
+bool Unserialize( CUtlBuffer &buf, int &dest )
+{
+	if ( buf.IsText() )
+	{
+		int nRetVal = buf.Scanf( "%d", &dest );
+		return (nRetVal == 1) && buf.IsValid();
+	}
+
+	dest = buf.GetInt( );
+	return buf.IsValid();
+}
+
+bool Serialize( CUtlBuffer &buf, const float &src )
+{
+	if ( buf.IsText() )
+	{
+		SerializeFloat( buf, src );
+	}
+	else
+	{
+		buf.PutFloat( src );
+	}
+	return buf.IsValid();
+}
+
+bool Unserialize( CUtlBuffer &buf, float &dest )
+{
+	if ( buf.IsText() )
+	{
+		// FIXME: Print this in a way that we never lose precision
+		int nRetVal = buf.Scanf( "%f", &dest );
+		return (nRetVal == 1) && buf.IsValid();
+	}
+
+	dest = buf.GetFloat( );
+	return buf.IsValid();
+}
+
+
+//-----------------------------------------------------------------------------
+// Attribute types related to vector math
+//-----------------------------------------------------------------------------
+bool Serialize( CUtlBuffer &buf, const Vector2D &src )
+{
+	if ( buf.IsText() )
+	{
+		SerializeFloats( buf, 2, src.Base() );
+	}
+	else
+	{
+		buf.PutFloat( src.x );
+		buf.PutFloat( src.y );
+	}
+	return buf.IsValid();
+}
+
+bool Unserialize( CUtlBuffer &buf, Vector2D &dest )
+{
+	if ( buf.IsText() )
+	{
+		// FIXME: Print this in a way that we never lose precision
+		int nRetVal = buf.Scanf( "%f %f", &dest.x, &dest.y );
+		return (nRetVal == 2) && buf.IsValid();
+	}
+
+	dest.x = buf.GetFloat( );
+	dest.y = buf.GetFloat( );
+	return buf.IsValid();
+}
+
+bool Serialize( CUtlBuffer &buf, const Vector &src )
+{
+	if ( buf.IsText() )
+	{
+		SerializeFloats( buf, 3, src.Base() );
+	}
+	else
+	{
+		buf.PutFloat( src.x );
+		buf.PutFloat( src.y );
+		buf.PutFloat( src.z );
+	}
+	return buf.IsValid();
+}
+
+bool Unserialize( CUtlBuffer &buf, Vector &dest )
+{
+	if ( buf.IsText() )
+	{
+		// FIXME: Print this in a way that we never lose precision
+		int nRetVal = buf.Scanf( "%f %f %f", &dest.x, &dest.y, &dest.z );
+		return (nRetVal == 3) && buf.IsValid();
+	}
+
+	dest.x = buf.GetFloat( );
+	dest.y = buf.GetFloat( );
+	dest.z = buf.GetFloat( );
+	return buf.IsValid();
+}
+
+bool Serialize( CUtlBuffer &buf, const Vector4D &src )
+{
+	if ( buf.IsText() )
+	{
+		SerializeFloats( buf, 4, src.Base() );
+	}
+	else
+	{
+		buf.PutFloat( src.x );
+		buf.PutFloat( src.y );
+		buf.PutFloat( src.z );
+		buf.PutFloat( src.w );
+	}
+	return buf.IsValid();
+}
+
+bool Unserialize( CUtlBuffer &buf, Vector4D &dest )
+{
+	if ( buf.IsText() )
+	{
+		// FIXME: Print this in a way that we never lose precision
+		int nRetVal = buf.Scanf( "%f %f %f %f", &dest.x, &dest.y, &dest.z, &dest.w );
+		return (nRetVal == 4) && buf.IsValid();
+	}
+
+	dest.x = buf.GetFloat( );
+	dest.y = buf.GetFloat( );
+	dest.z = buf.GetFloat( );
+	dest.w = buf.GetFloat( );
+	return buf.IsValid();
+}
+
+bool Serialize( CUtlBuffer &buf, const QAngle &src )
+{
+	if ( buf.IsText() )
+	{
+		SerializeFloats( buf, 3, src.Base() );
+	}
+	else
+	{
+		buf.PutFloat( src.x );
+		buf.PutFloat( src.y );
+		buf.PutFloat( src.z );
+	}
+	return buf.IsValid();
+}
+
+bool Unserialize( CUtlBuffer &buf, QAngle &dest )
+{
+	if ( buf.IsText() )
+	{
+		// FIXME: Print this in a way that we never lose precision
+		int nRetVal = buf.Scanf( "%f %f %f", &dest.x, &dest.y, &dest.z );
+		return (nRetVal == 3) && buf.IsValid();
+	}
+
+	dest.x = buf.GetFloat( );
+	dest.y = buf.GetFloat( );
+	dest.z = buf.GetFloat( );
+	return buf.IsValid();
+}
+
+bool Serialize( CUtlBuffer &buf, const Quaternion &src )
+{
+	if ( buf.IsText() )
+	{
+		SerializeFloats( buf, 4, &src.x );
+	}
+	else
+	{
+		buf.PutFloat( src.x );
+		buf.PutFloat( src.y );
+		buf.PutFloat( src.z );
+		buf.PutFloat( src.w );
+	}
+	return buf.IsValid();
+}
+
+bool Unserialize( CUtlBuffer &buf, Quaternion &dest )
+{
+	if ( buf.IsText() )
+	{
+		// FIXME: Print this in a way that we never lose precision
+		int nRetVal = buf.Scanf( "%f %f %f %f", &dest.x, &dest.y, &dest.z, &dest.w );
+		return (nRetVal == 4) && buf.IsValid();
+	}
+
+	dest.x = buf.GetFloat( );
+	dest.y = buf.GetFloat( );
+	dest.z = buf.GetFloat( );
+	dest.w = buf.GetFloat( );
+	return buf.IsValid();
+}
+
+bool Serialize( CUtlBuffer &buf, const VMatrix &src )
+{
+	if ( buf.IsText() )
+	{
+		buf.Printf( "\n" );
+		SerializeFloats( buf, 4, src[0] );
+		buf.Printf( "\n" );
+		SerializeFloats( buf, 4, src[1] );
+		buf.Printf( "\n" );
+		SerializeFloats( buf, 4, src[2] );
+		buf.Printf( "\n" );
+		SerializeFloats( buf, 4, src[3] );
+		buf.Printf( "\n" );
+	}
+	else
+	{
+		buf.Put( &src, sizeof(VMatrix) );
+	}
+	return buf.IsValid();
+}
+
+bool Unserialize( CUtlBuffer &buf, VMatrix &dest )
+{
+	if ( !buf.IsValid() )
+		return false;
+
+	if ( buf.IsText() )
+	{
+		int nRetVal = buf.Scanf( "%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f",
+			&dest[ 0 ][ 0 ], &dest[ 0 ][ 1 ], &dest[ 0 ][ 2 ], &dest[ 0 ][ 3 ],
+			&dest[ 1 ][ 0 ], &dest[ 1 ][ 1 ], &dest[ 1 ][ 2 ], &dest[ 1 ][ 3 ],
+			&dest[ 2 ][ 0 ], &dest[ 2 ][ 1 ], &dest[ 2 ][ 2 ], &dest[ 2 ][ 3 ],
+			&dest[ 3 ][ 0 ], &dest[ 3 ][ 1 ], &dest[ 3 ][ 2 ], &dest[ 3 ][ 3 ] );
+		return (nRetVal == 16);
+	}
+
+	buf.Get( &dest, sizeof(VMatrix) );
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Color attribute
+//-----------------------------------------------------------------------------
+bool Serialize( CUtlBuffer &buf, const Color &src )
+{
+	if ( buf.IsText() )
+	{
+		buf.Printf( "%d %d %d %d", src[0], src[1], src[2], src[3] );
+	}
+	else
+	{
+		buf.PutUnsignedChar( src[0] );
+		buf.PutUnsignedChar( src[1] );
+		buf.PutUnsignedChar( src[2] );
+		buf.PutUnsignedChar( src[3] );
+	}
+	return buf.IsValid();
+}
+
+bool Unserialize( CUtlBuffer &buf, Color &dest )
+{
+	if ( buf.IsText() )
+	{
+		int r = 0, g = 0, b = 0, a = 255;
+		int nRetVal = buf.Scanf( "%d %d %d %d", &r, &g, &b, &a );
+		dest.SetColor( r, g, b, a );
+		return (nRetVal == 4) && buf.IsValid();
+	}
+
+	dest[0] = buf.GetUnsignedChar( );
+	dest[1] = buf.GetUnsignedChar( );
+	dest[2] = buf.GetUnsignedChar( );
+	dest[3] = buf.GetUnsignedChar( );
+	return buf.IsValid();
+}
+
+/*
+//-----------------------------------------------------------------------------
+// Object ID attribute
+//-----------------------------------------------------------------------------
+bool Serialize( CUtlBuffer &buf, const DmObjectId_t &src )
+{
+	return g_pDataModel->Serialize( buf, src );
+}
+
+bool Unserialize( CUtlBuffer &buf, DmObjectId_t &dest )
+{
+	return g_pDataModel->Unserialize( buf, &dest );
+}
+*/
+
+//-----------------------------------------------------------------------------
+// Binary buffer attribute
+//-----------------------------------------------------------------------------
+bool Serialize( CUtlBuffer &buf, const CUtlBinaryBlock &src )
+{
+	int nLength = src.Length();
+	if ( !buf.IsText() )
+	{
+		buf.PutInt( nLength );
+		if ( nLength != 0 )
+		{
+			buf.Put( src.Get(), nLength );
+		}
+		return buf.IsValid();
+	}
+
+	// Writes out uuencoded binaries
+	for ( int i = 0; i < nLength; ++i )
+	{
+		if ( (i % 40) == 0 )
+		{
+			buf.PutChar( '\n' );
+		}
+
+		char b1 = src[i] & 0xF;
+		char b2 = src[i] >> 4;
+
+		char c1 = ( b1 <= 9 ) ? b1 + '0' : b1 - 10 + 'A';
+		char c2 = ( b2 <= 9 ) ? b2 + '0' : b2 - 10 + 'A';
+
+		buf.PutChar( c2 );
+		buf.PutChar( c1 );
+	}
+
+	buf.PutChar( '\n' );
+	return buf.IsValid();
+}
+
+static int CountBinaryBytes( CUtlBuffer &buf, int *pEndGet )
+{
+	// This counts the number of bytes in the uuencoded text
+	int nStartGet = buf.TellGet();
+	buf.EatWhiteSpace();
+	*pEndGet = buf.TellGet();
+	int nByteCount = 0;
+	while ( buf.IsValid() )
+	{
+		char c1 = buf.GetChar();
+		char c2 = buf.GetChar();
+
+		bool bIsNum1 = ( c1 >= '0' ) && ( c1 <= '9' );
+		bool bIsNum2 = ( c2 >= '0' ) && ( c2 <= '9' );
+
+		bool bIsAlpha1 = (( c1 >= 'A' ) && ( c1 <= 'F' )) || (( c1 >= 'a' ) && ( c1 <= 'f' ));
+		bool bIsAlpha2 = (( c2 >= 'A' ) && ( c2 <= 'F' )) || (( c2 >= 'a' ) && ( c2 <= 'f' ));
+
+		if ( !(bIsNum1 || bIsAlpha1) || !(bIsNum2 || bIsAlpha2) )
+			break;
+
+		buf.EatWhiteSpace();
+		*pEndGet = buf.TellGet();
+		++nByteCount;
+	}
+	buf.SeekGet( CUtlBuffer::SEEK_HEAD, nStartGet );
+	return nByteCount;
+}
+
+inline static unsigned char HexCharToInt( int c1 )
+{
+	if (( c1 >= '0' ) && ( c1 <= '9' ))
+		return c1 - '0';
+
+	if (( c1 >= 'A' ) && ( c1 <= 'F' ))
+		return 10 + c1 - 'A';
+
+	if (( c1 >= 'a' ) && ( c1 <= 'f' ))
+		return 10 + c1 - 'a';
+
+	return 0xFF;
+}
+
+bool Unserialize( CUtlBuffer &buf, CUtlBinaryBlock &dest )
+{
+	if ( !buf.IsText() )
+	{
+		int nLen = buf.GetInt( );
+		dest.SetLength( nLen );
+		if ( dest.Length() != 0 )
+		{
+			buf.Get( dest.Get(), dest.Length() );
+		}
+
+		if ( nLen != dest.Length() )
+		{
+			buf.SeekGet( CUtlBuffer::SEEK_CURRENT, nLen - dest.Length() );
+			return false;
+		}
+
+		return buf.IsValid();
+	}
+
+	int nEndGet;
+	int nByteCount = CountBinaryBytes( buf, &nEndGet );
+	if ( nByteCount < 0 )
+		return false;
+
+	buf.EatWhiteSpace();
+	int nDest = 0;
+	dest.SetLength( nByteCount );
+	while( buf.TellGet() < nEndGet )
+	{
+		char c1 = buf.GetChar();
+		char c2 = buf.GetChar();
+
+		unsigned char b1 = HexCharToInt( c1 );
+		unsigned char b2 = HexCharToInt( c2 );
+		if ( b1 == 0xFF || b2 == 0xFF )
+			return false;
+
+		dest[ nDest++ ] = b2 | ( b1 << 4 );
+		buf.EatWhiteSpace();
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// String attribute
+//-----------------------------------------------------------------------------
+bool Serialize( CUtlBuffer &buf, const CUtlString &src )
+{
+	buf.PutDelimitedString( s_pConv, src.Get() );
+	return buf.IsValid();
+}
+
+bool Unserialize( CUtlBuffer &buf, CUtlString &dest )
+{
+	int nLen = buf.PeekDelimitedStringLength( s_pConv );
+	dest.SetLength( nLen - 1 );	// -1 because the length returned includes space for \0
+	buf.GetDelimitedString( s_pConv, dest.Get(), nLen );
+	return buf.IsValid();
+}
+
+
+
+