You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

643 lines
22 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================
#include "dmxloader/dmxattribute.h"
#include "tier1/utlbufferutil.h"
#include "tier1/uniqueid.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
//-----------------------------------------------------------------------------
// globals
//-----------------------------------------------------------------------------
CUtlSymbolTableMT CDmxAttribute::s_AttributeNameSymbols;
//-----------------------------------------------------------------------------
// Attribute size
//-----------------------------------------------------------------------------
static size_t s_pAttributeSize[AT_TYPE_COUNT] =
{
0, // AT_UNKNOWN,
sizeof(CDmxElement*), // AT_ELEMENT,
sizeof(int), // AT_INT,
sizeof(float), // AT_FLOAT,
sizeof(bool), // AT_BOOL,
sizeof(CUtlString), // AT_STRING,
sizeof(CUtlBinaryBlock), // AT_VOID,
sizeof(DmObjectId_t), // AT_OBJECTID,
sizeof(Color), // AT_COLOR,
sizeof(Vector2D), // AT_VECTOR2,
sizeof(Vector), // AT_VECTOR3,
sizeof(Vector4D), // AT_VECTOR4,
sizeof(QAngle), // AT_QANGLE,
sizeof(Quaternion), // AT_QUATERNION,
sizeof(VMatrix), // AT_VMATRIX,
sizeof(CUtlVector<CDmxElement*>), // AT_ELEMENT_ARRAY,
sizeof(CUtlVector<int>), // AT_INT_ARRAY,
sizeof(CUtlVector<float>), // AT_FLOAT_ARRAY,
sizeof(CUtlVector<bool>), // AT_BOOL_ARRAY,
sizeof(CUtlVector<CUtlString>), // AT_STRING_ARRAY,
sizeof(CUtlVector<CUtlBinaryBlock>), // AT_VOID_ARRAY,
sizeof(CUtlVector<DmObjectId_t>), // AT_OBJECTID_ARRAY,
sizeof(CUtlVector<Color>), // AT_COLOR_ARRAY,
sizeof(CUtlVector<Vector2D>), // AT_VECTOR2_ARRAY,
sizeof(CUtlVector<Vector>), // AT_VECTOR3_ARRAY,
sizeof(CUtlVector<Vector4D>), // AT_VECTOR4_ARRAY,
sizeof(CUtlVector<QAngle>), // AT_QANGLE_ARRAY,
sizeof(CUtlVector<Quaternion>), // AT_QUATERNION_ARRAY,
sizeof(CUtlVector<VMatrix>), // AT_VMATRIX_ARRAY,
};
//-----------------------------------------------------------------------------
// make sure that the attribute data type sizes are what we think they are to choose the right allocator
//-----------------------------------------------------------------------------
struct CSizeTest
{
CSizeTest()
{
// test internal value attribute sizes
COMPILE_TIME_ASSERT( sizeof( int ) == 4 );
COMPILE_TIME_ASSERT( sizeof( float ) == 4 );
COMPILE_TIME_ASSERT( sizeof( bool ) <= 4 );
COMPILE_TIME_ASSERT( sizeof( Color ) == 4 );
COMPILE_TIME_ASSERT( sizeof( Vector2D ) == 8 );
COMPILE_TIME_ASSERT( sizeof( Vector ) == 12 );
COMPILE_TIME_ASSERT( sizeof( Vector4D ) == 16 );
COMPILE_TIME_ASSERT( sizeof( QAngle ) == 12 );
COMPILE_TIME_ASSERT( sizeof( Quaternion ) == 16 );
COMPILE_TIME_ASSERT( sizeof( VMatrix ) == 64 );
COMPILE_TIME_ASSERT( sizeof( CUtlString ) == 4 );
COMPILE_TIME_ASSERT( sizeof( CUtlBinaryBlock ) == 16 );
COMPILE_TIME_ASSERT( sizeof( DmObjectId_t ) == 16 );
};
};
static CSizeTest g_sizeTest;
//-----------------------------------------------------------------------------
// Returns attribute name for type
//-----------------------------------------------------------------------------
const char *g_pAttributeTypeName[AT_TYPE_COUNT] =
{
"unknown", // AT_UNKNOWN
CDmAttributeInfo<DmElementHandle_t>::AttributeTypeName(), // AT_ELEMENT,
CDmAttributeInfo<int>::AttributeTypeName(), // AT_INT,
CDmAttributeInfo<float>::AttributeTypeName(), // AT_FLOAT,
CDmAttributeInfo<bool>::AttributeTypeName(), // AT_BOOL,
CDmAttributeInfo<CUtlString>::AttributeTypeName(), // AT_STRING,
CDmAttributeInfo<CUtlBinaryBlock>::AttributeTypeName(), // AT_VOID,
CDmAttributeInfo<DmObjectId_t>::AttributeTypeName(), // AT_OBJECTID,
CDmAttributeInfo<Color>::AttributeTypeName(), // AT_COLOR,
CDmAttributeInfo<Vector2D>::AttributeTypeName(), // AT_VECTOR2,
CDmAttributeInfo<Vector>::AttributeTypeName(), // AT_VECTOR3,
CDmAttributeInfo<Vector4D>::AttributeTypeName(), // AT_VECTOR4,
CDmAttributeInfo<QAngle>::AttributeTypeName(), // AT_QANGLE,
CDmAttributeInfo<Quaternion>::AttributeTypeName(), // AT_QUATERNION,
CDmAttributeInfo<VMatrix>::AttributeTypeName(), // AT_VMATRIX,
CDmAttributeInfo< CUtlVector< DmElementHandle_t > >::AttributeTypeName(), // AT_ELEMENT_ARRAY,
CDmAttributeInfo< CUtlVector< int > >::AttributeTypeName(), // AT_INT_ARRAY,
CDmAttributeInfo< CUtlVector< float > >::AttributeTypeName(), // AT_FLOAT_ARRAY,
CDmAttributeInfo< CUtlVector< bool > >::AttributeTypeName(), // AT_BOOL_ARRAY,
CDmAttributeInfo< CUtlVector< CUtlString > >::AttributeTypeName(), // AT_STRING_ARRAY,
CDmAttributeInfo< CUtlVector< CUtlBinaryBlock > >::AttributeTypeName(), // AT_VOID_ARRAY,
CDmAttributeInfo< CUtlVector< DmObjectId_t > >::AttributeTypeName(), // AT_OBJECTID_ARRAY,
CDmAttributeInfo< CUtlVector< Color > >::AttributeTypeName(), // AT_COLOR_ARRAY,
CDmAttributeInfo< CUtlVector< Vector2D > >::AttributeTypeName(), // AT_VECTOR2_ARRAY,
CDmAttributeInfo< CUtlVector< Vector > >::AttributeTypeName(), // AT_VECTOR3_ARRAY,
CDmAttributeInfo< CUtlVector< Vector4D > >::AttributeTypeName(), // AT_VECTOR4_ARRAY,
CDmAttributeInfo< CUtlVector< QAngle > >::AttributeTypeName(), // AT_QANGLE_ARRAY,
CDmAttributeInfo< CUtlVector< Quaternion > >::AttributeTypeName(), // AT_QUATERNION_ARRAY,
CDmAttributeInfo< CUtlVector< VMatrix > >::AttributeTypeName(), // AT_VMATRIX_ARRAY,
};
//-----------------------------------------------------------------------------
// Constructor, destructor
//-----------------------------------------------------------------------------
CDmxAttribute::CDmxAttribute( const char *pAttributeName )
{
m_Name = s_AttributeNameSymbols.AddString( pAttributeName );
m_Type = AT_UNKNOWN;
m_pData = NULL;
}
CDmxAttribute::CDmxAttribute( CUtlSymbol attributeName )
{
m_Name = attributeName;
m_Type = AT_UNKNOWN;
m_pData = NULL;
}
CDmxAttribute::~CDmxAttribute()
{
FreeDataMemory();
}
//-----------------------------------------------------------------------------
// Returns the size of the variables storing the various attribute types
//-----------------------------------------------------------------------------
int CDmxAttribute::AttributeDataSize( DmAttributeType_t type )
{
return s_pAttributeSize[type];
}
//-----------------------------------------------------------------------------
// Allocate, free memory for data
//-----------------------------------------------------------------------------
void CDmxAttribute::AllocateDataMemory( DmAttributeType_t type )
{
FreeDataMemory();
m_Type = type;
m_pData = DMXAlloc( s_pAttributeSize[m_Type] );
}
#define DESTRUCT_ARRAY( _dataType ) \
case CDmAttributeInfo< CUtlVector< _dataType > >::ATTRIBUTE_TYPE: \
Destruct( ( CUtlVector< _dataType >* )m_pData ); \
break;
void CDmxAttribute::FreeDataMemory()
{
if ( m_Type != AT_UNKNOWN )
{
Assert( m_pData != NULL );
if ( !IsArrayType( m_Type ) )
{
if ( m_Type == AT_STRING )
{
Destruct( (CUtlString*)m_pData );
}
else if ( m_Type == AT_VOID )
{
Destruct( (CUtlBinaryBlock*)m_pData );
}
}
else
{
switch ( m_Type )
{
DESTRUCT_ARRAY( int );
DESTRUCT_ARRAY( float );
DESTRUCT_ARRAY( bool );
DESTRUCT_ARRAY( CUtlString );
DESTRUCT_ARRAY( CUtlBinaryBlock );
DESTRUCT_ARRAY( DmObjectId_t );
DESTRUCT_ARRAY( Color );
DESTRUCT_ARRAY( Vector2D );
DESTRUCT_ARRAY( Vector );
DESTRUCT_ARRAY( Vector4D );
DESTRUCT_ARRAY( QAngle );
DESTRUCT_ARRAY( Quaternion );
DESTRUCT_ARRAY( VMatrix );
DESTRUCT_ARRAY( CDmxElement* );
}
}
m_Type = AT_UNKNOWN;
}
}
//-----------------------------------------------------------------------------
// Returns attribute type string
//-----------------------------------------------------------------------------
inline const char* CDmxAttribute::GetTypeString() const
{
return g_pAttributeTypeName[ m_Type ];
}
//-----------------------------------------------------------------------------
// Returns attribute name
//-----------------------------------------------------------------------------
const char *CDmxAttribute::GetName() const
{
return s_AttributeNameSymbols.String( m_Name );
}
//-----------------------------------------------------------------------------
// Gets the size of an array, returns 0 if it's not an array type
//-----------------------------------------------------------------------------
#define GET_ARRAY_COUNT( _dataType ) \
case CDmAttributeInfo< CUtlVector< _dataType > >::ATTRIBUTE_TYPE: \
{ \
const CUtlVector< _dataType > &array = *( CUtlVector< _dataType >* )m_pData; \
return array.Count(); \
}
int CDmxAttribute::GetArrayCount() const
{
if ( !IsArrayType( m_Type ) || !m_pData )
return 0;
switch( m_Type )
{
GET_ARRAY_COUNT( int );
GET_ARRAY_COUNT( float );
GET_ARRAY_COUNT( bool );
GET_ARRAY_COUNT( CUtlString );
GET_ARRAY_COUNT( CUtlBinaryBlock );
GET_ARRAY_COUNT( DmObjectId_t );
GET_ARRAY_COUNT( Color );
GET_ARRAY_COUNT( Vector2D );
GET_ARRAY_COUNT( Vector );
GET_ARRAY_COUNT( Vector4D );
GET_ARRAY_COUNT( QAngle );
GET_ARRAY_COUNT( Quaternion );
GET_ARRAY_COUNT( VMatrix );
GET_ARRAY_COUNT( CDmxElement* );
}
return 0;
}
//-----------------------------------------------------------------------------
// Gets the size of an array, returns 0 if it's not an array type
//-----------------------------------------------------------------------------
#define SERIALIZES_ON_MULTIPLE_LINES( _dataType ) \
case CDmAttributeInfo< _dataType >::ATTRIBUTE_TYPE: \
return ::SerializesOnMultipleLines< _dataType >(); \
case CDmAttributeInfo< CUtlVector< _dataType > >::ATTRIBUTE_TYPE: \
return ::SerializesOnMultipleLines< CUtlVector< _dataType > >()
bool CDmxAttribute::SerializesOnMultipleLines() const
{
switch( m_Type )
{
SERIALIZES_ON_MULTIPLE_LINES( CDmxElement* );
SERIALIZES_ON_MULTIPLE_LINES( int );
SERIALIZES_ON_MULTIPLE_LINES( float );
SERIALIZES_ON_MULTIPLE_LINES( bool );
SERIALIZES_ON_MULTIPLE_LINES( CUtlString );
SERIALIZES_ON_MULTIPLE_LINES( CUtlBinaryBlock );
SERIALIZES_ON_MULTIPLE_LINES( DmObjectId_t );
SERIALIZES_ON_MULTIPLE_LINES( Color );
SERIALIZES_ON_MULTIPLE_LINES( Vector2D );
SERIALIZES_ON_MULTIPLE_LINES( Vector );
SERIALIZES_ON_MULTIPLE_LINES( Vector4D );
SERIALIZES_ON_MULTIPLE_LINES( QAngle );
SERIALIZES_ON_MULTIPLE_LINES( Quaternion );
SERIALIZES_ON_MULTIPLE_LINES( VMatrix );
}
return false;
}
//-----------------------------------------------------------------------------
// Write to file
//-----------------------------------------------------------------------------
#define SERIALIZE_TYPE( _buf, _attributeType, _dataType ) \
case _attributeType: \
{ \
if ( m_pData ) \
return ::Serialize( _buf, *(_dataType*)m_pData ); \
_dataType temp; \
CDmAttributeInfo< _dataType >::SetDefaultValue( temp ); \
return ::Serialize( _buf, temp ); \
}
#define SERIALIZE_ARRAY_TYPE( _buf, _attributeType, _dataType ) \
case _attributeType: \
{ \
if ( m_pData ) \
return ::Serialize( _buf, *(CUtlVector< _dataType >*)m_pData ); \
CUtlVector< _dataType > temp; \
CDmAttributeInfo< CUtlVector< _dataType > >::SetDefaultValue( temp ); \
return ::Serialize( _buf, temp ); \
}
bool CDmxAttribute::Serialize( CUtlBuffer &buf ) const
{
switch( m_Type )
{
SERIALIZE_TYPE( buf, AT_INT, int );
SERIALIZE_TYPE( buf, AT_FLOAT, float );
SERIALIZE_TYPE( buf, AT_BOOL, bool );
SERIALIZE_TYPE( buf, AT_STRING, CUtlString );
SERIALIZE_TYPE( buf, AT_VOID, CUtlBinaryBlock );
SERIALIZE_TYPE( buf, AT_OBJECTID, DmObjectId_t );
SERIALIZE_TYPE( buf, AT_COLOR, Color );
SERIALIZE_TYPE( buf, AT_VECTOR2, Vector2D );
SERIALIZE_TYPE( buf, AT_VECTOR3, Vector );
SERIALIZE_TYPE( buf, AT_VECTOR4, Vector4D );
SERIALIZE_TYPE( buf, AT_QANGLE, QAngle );
SERIALIZE_TYPE( buf, AT_QUATERNION, Quaternion );
SERIALIZE_TYPE( buf, AT_VMATRIX, VMatrix );
SERIALIZE_ARRAY_TYPE( buf, AT_INT_ARRAY, int );
SERIALIZE_ARRAY_TYPE( buf, AT_FLOAT_ARRAY, float );
SERIALIZE_ARRAY_TYPE( buf, AT_BOOL_ARRAY, bool );
SERIALIZE_ARRAY_TYPE( buf, AT_STRING_ARRAY, CUtlString );
SERIALIZE_ARRAY_TYPE( buf, AT_VOID_ARRAY, CUtlBinaryBlock );
SERIALIZE_ARRAY_TYPE( buf, AT_OBJECTID_ARRAY, DmObjectId_t );
SERIALIZE_ARRAY_TYPE( buf, AT_COLOR_ARRAY, Color );
SERIALIZE_ARRAY_TYPE( buf, AT_VECTOR2_ARRAY, Vector2D );
SERIALIZE_ARRAY_TYPE( buf, AT_VECTOR3_ARRAY, Vector );
SERIALIZE_ARRAY_TYPE( buf, AT_VECTOR4_ARRAY, Vector4D );
SERIALIZE_ARRAY_TYPE( buf, AT_QANGLE_ARRAY, QAngle );
SERIALIZE_ARRAY_TYPE( buf, AT_QUATERNION_ARRAY, Quaternion );
SERIALIZE_ARRAY_TYPE( buf, AT_VMATRIX_ARRAY, VMatrix );
default:
AssertMsg( 0, "Cannot serialize elements or element arrays!\n" );
return false;
}
return false;
}
//-----------------------------------------------------------------------------
// Serialize a single element in an array attribute
//-----------------------------------------------------------------------------
#define SERIALIZE_TYPED_ELEMENT( _index, _buf, _attributeType, _dataType ) \
case _attributeType: \
{ \
if ( m_pData ) \
{ \
const CUtlVector< _dataType > &array = *( CUtlVector< _dataType >* )m_pData;\
return ::Serialize( buf, array[_index] ); \
} \
_dataType temp; \
CDmAttributeInfo< _dataType >::SetDefaultValue( temp ); \
return ::Serialize( _buf, temp ); \
}
bool CDmxAttribute::SerializeElement( int nIndex, CUtlBuffer &buf ) const
{
if ( !IsArrayType( m_Type ) )
return false;
switch( m_Type )
{
SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_INT_ARRAY, int );
SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_FLOAT_ARRAY, float );
SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_BOOL_ARRAY, bool );
SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_STRING_ARRAY, CUtlString );
SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_VOID_ARRAY, CUtlBinaryBlock );
SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_OBJECTID_ARRAY, DmObjectId_t );
SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_COLOR_ARRAY, Color );
SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_VECTOR2_ARRAY, Vector2D );
SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_VECTOR3_ARRAY, Vector );
SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_VECTOR4_ARRAY, Vector4D );
SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_QANGLE_ARRAY, QAngle );
SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_QUATERNION_ARRAY, Quaternion );
SERIALIZE_TYPED_ELEMENT( nIndex, buf, AT_VMATRIX_ARRAY, VMatrix );
default:
AssertMsg( 0, "Cannot serialize elements!\n" );
return false;
}
return false;
}
//-----------------------------------------------------------------------------
// Read from file
//-----------------------------------------------------------------------------
#define UNSERIALIZE_TYPE( _buf, _attributeType, _dataType ) \
case _attributeType: \
Construct( (_dataType*)m_pData ); \
return ::Unserialize( _buf, *(_dataType*)m_pData )
#define UNSERIALIZE_ARRAY_TYPE( _buf, _attributeType, _dataType ) \
case _attributeType: \
Construct( (CUtlVector< _dataType > *)m_pData ); \
return ::Unserialize( _buf, *(CUtlVector< _dataType >*)m_pData )
bool CDmxAttribute::Unserialize( DmAttributeType_t type, CUtlBuffer &buf )
{
AllocateDataMemory( type );
switch( type )
{
UNSERIALIZE_TYPE( buf, AT_INT, int );
UNSERIALIZE_TYPE( buf, AT_FLOAT, float );
UNSERIALIZE_TYPE( buf, AT_BOOL, bool );
UNSERIALIZE_TYPE( buf, AT_STRING, CUtlString );
UNSERIALIZE_TYPE( buf, AT_VOID, CUtlBinaryBlock );
UNSERIALIZE_TYPE( buf, AT_OBJECTID, DmObjectId_t );
UNSERIALIZE_TYPE( buf, AT_COLOR, Color );
UNSERIALIZE_TYPE( buf, AT_VECTOR2, Vector2D );
UNSERIALIZE_TYPE( buf, AT_VECTOR3, Vector );
UNSERIALIZE_TYPE( buf, AT_VECTOR4, Vector4D );
UNSERIALIZE_TYPE( buf, AT_QANGLE, QAngle );
UNSERIALIZE_TYPE( buf, AT_QUATERNION, Quaternion );
UNSERIALIZE_TYPE( buf, AT_VMATRIX, VMatrix );
UNSERIALIZE_ARRAY_TYPE( buf, AT_INT_ARRAY, int );
UNSERIALIZE_ARRAY_TYPE( buf, AT_FLOAT_ARRAY, float );
UNSERIALIZE_ARRAY_TYPE( buf, AT_BOOL_ARRAY, bool );
UNSERIALIZE_ARRAY_TYPE( buf, AT_STRING_ARRAY, CUtlString );
UNSERIALIZE_ARRAY_TYPE( buf, AT_VOID_ARRAY, CUtlBinaryBlock );
UNSERIALIZE_ARRAY_TYPE( buf, AT_OBJECTID_ARRAY, DmObjectId_t );
UNSERIALIZE_ARRAY_TYPE( buf, AT_COLOR_ARRAY, Color );
UNSERIALIZE_ARRAY_TYPE( buf, AT_VECTOR2_ARRAY, Vector2D );
UNSERIALIZE_ARRAY_TYPE( buf, AT_VECTOR3_ARRAY, Vector );
UNSERIALIZE_ARRAY_TYPE( buf, AT_VECTOR4_ARRAY, Vector4D );
UNSERIALIZE_ARRAY_TYPE( buf, AT_QANGLE_ARRAY, QAngle );
UNSERIALIZE_ARRAY_TYPE( buf, AT_QUATERNION_ARRAY, Quaternion );
UNSERIALIZE_ARRAY_TYPE( buf, AT_VMATRIX_ARRAY, VMatrix );
default:
AssertMsg( 0, "Cannot unserialize elements or element arrays!\n" );
return false;
}
return false;
}
//-----------------------------------------------------------------------------
// Read element from file
//-----------------------------------------------------------------------------
#define UNSERIALIZE_TYPED_ELEMENT( _buf, _attributeType, _dataType ) \
case _attributeType: \
{ \
if ( !bIsDataMemoryAllocated ) \
{ \
Construct( (CUtlVector< _dataType > *)m_pData ); \
} \
_dataType temp; \
bool bReadElement = ::Unserialize( _buf, temp ); \
if ( bReadElement ) \
{ \
GetArrayForEdit< _dataType >().AddToTail( temp ); \
} \
return bReadElement; \
}
bool CDmxAttribute::UnserializeElement( DmAttributeType_t type, CUtlBuffer &buf )
{
if ( !IsArrayType( type ) )
return false;
bool bIsDataMemoryAllocated = ( m_Type == type );
if ( !bIsDataMemoryAllocated )
{
AllocateDataMemory( type );
}
switch( type )
{
UNSERIALIZE_TYPED_ELEMENT( buf, AT_INT_ARRAY, int );
UNSERIALIZE_TYPED_ELEMENT( buf, AT_FLOAT_ARRAY, float );
UNSERIALIZE_TYPED_ELEMENT( buf, AT_BOOL_ARRAY, bool );
UNSERIALIZE_TYPED_ELEMENT( buf, AT_STRING_ARRAY, CUtlString );
UNSERIALIZE_TYPED_ELEMENT( buf, AT_VOID_ARRAY, CUtlBinaryBlock );
UNSERIALIZE_TYPED_ELEMENT( buf, AT_OBJECTID_ARRAY, DmObjectId_t );
UNSERIALIZE_TYPED_ELEMENT( buf, AT_COLOR_ARRAY, Color );
UNSERIALIZE_TYPED_ELEMENT( buf, AT_VECTOR2_ARRAY, Vector2D );
UNSERIALIZE_TYPED_ELEMENT( buf, AT_VECTOR3_ARRAY, Vector );
UNSERIALIZE_TYPED_ELEMENT( buf, AT_VECTOR4_ARRAY, Vector4D );
UNSERIALIZE_TYPED_ELEMENT( buf, AT_QANGLE_ARRAY, QAngle );
UNSERIALIZE_TYPED_ELEMENT( buf, AT_QUATERNION_ARRAY, Quaternion );
UNSERIALIZE_TYPED_ELEMENT( buf, AT_VMATRIX_ARRAY, VMatrix );
default:
AssertMsg( 0, "Cannot unserialize elements!\n" );
return false;
}
return false;
}
//-----------------------------------------------------------------------------
// Sets name
//-----------------------------------------------------------------------------
void CDmxAttribute::SetName( const char *pAttributeName )
{
m_Name = s_AttributeNameSymbols.Find( pAttributeName );
}
//-----------------------------------------------------------------------------
// Sets values
//-----------------------------------------------------------------------------
void CDmxAttribute::SetValue( const char *pString )
{
AllocateDataMemory( AT_STRING );
CUtlString* pUtlString = (CUtlString*)m_pData;
Construct( pUtlString );
pUtlString->Set( pString );
}
void CDmxAttribute::SetValue( const void *pBuffer, size_t nLen )
{
AllocateDataMemory( AT_VOID );
CUtlBinaryBlock* pBlob = (CUtlBinaryBlock*)m_pData;
Construct( pBlob );
pBlob->Set( pBuffer, nLen );
}
// Untyped method for setting used by unpack
void CDmxAttribute::SetValue( DmAttributeType_t type, const void *pSrc, int nLen )
{
if ( m_Type != type )
{
AllocateDataMemory( type );
}
Assert( nLen == CDmxAttribute::AttributeDataSize( type ) );
if ( nLen > CDmxAttribute::AttributeDataSize( type ) )
{
nLen = CDmxAttribute::AttributeDataSize( type );
}
memcpy( m_pData, pSrc, nLen );
}
void CDmxAttribute::SetValue( const CDmxAttribute *pAttribute )
{
DmAttributeType_t type = pAttribute->GetType();
if ( !IsArrayType( type ) )
{
SetValue( type, pAttribute->m_pData, CDmxAttribute::AttributeDataSize( type ) );
}
else
{
// Copying array attributes not done yet..
Assert( 0 );
}
}
// Sets the attribute to its default value based on its type
#define SET_DEFAULT_VALUE( _dataType ) \
case CDmAttributeInfo< _dataType >::ATTRIBUTE_TYPE: \
CDmAttributeInfo< _dataType >::SetDefaultValue( *reinterpret_cast< _dataType* >( m_pData ) ); \
break; \
case CDmAttributeInfo< CUtlVector< _dataType > >::ATTRIBUTE_TYPE: \
CDmAttributeInfo< CUtlVector< _dataType > >::SetDefaultValue( *reinterpret_cast< CUtlVector< _dataType > * >( m_pData ) ); \
break
void CDmxAttribute::SetToDefaultValue()
{
switch( GetType() )
{
SET_DEFAULT_VALUE( int );
SET_DEFAULT_VALUE( float );
SET_DEFAULT_VALUE( bool );
SET_DEFAULT_VALUE( CUtlString );
SET_DEFAULT_VALUE( CUtlBinaryBlock );
SET_DEFAULT_VALUE( DmObjectId_t );
SET_DEFAULT_VALUE( Color );
SET_DEFAULT_VALUE( Vector2D );
SET_DEFAULT_VALUE( Vector );
SET_DEFAULT_VALUE( Vector4D );
SET_DEFAULT_VALUE( QAngle );
SET_DEFAULT_VALUE( Quaternion );
SET_DEFAULT_VALUE( VMatrix );
SET_DEFAULT_VALUE( CDmxElement* );
default:
break;
}
}
//-----------------------------------------------------------------------------
// Convert to and from string
//-----------------------------------------------------------------------------
void CDmxAttribute::SetValueFromString( const char *pValue )
{
switch ( GetType() )
{
case AT_UNKNOWN:
break;
case AT_STRING:
SetValue( pValue );
break;
default:
{
int nLen = pValue ? Q_strlen( pValue ) : 0;
if ( nLen == 0 )
{
SetToDefaultValue();
break;
}
CUtlBuffer buf( pValue, nLen, CUtlBuffer::TEXT_BUFFER | CUtlBuffer::READ_ONLY );
if ( !Unserialize( GetType(), buf ) )
{
SetToDefaultValue();
}
}
break;
}
}
const char *CDmxAttribute::GetValueAsString( char *pBuffer, size_t nBufLen ) const
{
Assert( pBuffer );
CUtlBuffer buf( pBuffer, nBufLen, CUtlBuffer::TEXT_BUFFER );
Serialize( buf );
return pBuffer;
}