diff options
Diffstat (limited to 'dmxloader/dmxattribute.cpp')
| -rw-r--r-- | dmxloader/dmxattribute.cpp | 643 |
1 files changed, 643 insertions, 0 deletions
diff --git a/dmxloader/dmxattribute.cpp b/dmxloader/dmxattribute.cpp new file mode 100644 index 0000000..aea474c --- /dev/null +++ b/dmxloader/dmxattribute.cpp @@ -0,0 +1,643 @@ +//========= 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; +} |