Backups/hl2sdk
1
0
Fork 0
mirror of https://github.com/alliedmodders/hl2sdk.git synced 2025-09-19 20:16:10 +08:00
Code Activity

Correct few more struct/enum defs

Browse Source
This commit is contained in:
GAMMACASE
2025-03-05 21:55:52 +03:00
parent 460889b454
commit f33999970e
5 changed files with 78 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
public/const.h
View File

@ -156,7 +156,8 @@ enum MoveType_t : unsigned char
MOVETYPE_CUSTOM, // Allows the entity to describe its own physics MOVETYPE_CUSTOM, // Allows the entity to describe its own physics
// should always be defined as the last item in the list // should always be defined as the last item in the list
MOVETYPE_LAST = MOVETYPE_CUSTOM, MOVETYPE_LAST,
MOVETYPE_INVALID = MOVETYPE_LAST,
MOVETYPE_MAX_BITS = 5 MOVETYPE_MAX_BITS = 5
}; };

26
public/datamap.h
View File

@ -28,13 +28,13 @@ struct inputdata_t;
typedef enum _fieldtypes : uint8 typedef enum _fieldtypes : uint8
{ {
FIELD_VOID = 0, // No type or value FIELD_VOID = 0, // No type or value
FIELD_FLOAT, // Any floating point value FIELD_FLOAT32, // Any floating point value
FIELD_STRING, // A string ID (return from ALLOC_STRING) FIELD_STRING, // A string ID (return from ALLOC_STRING)
FIELD_VECTOR, // Any vector, QAngle, or AngularImpulse FIELD_VECTOR, // Any vector, QAngle, or AngularImpulse
FIELD_QUATERNION, // A quaternion FIELD_QUATERNION, // A quaternion
FIELD_INTEGER, // Any integer or enum FIELD_INT32, // Any integer or enum
FIELD_BOOLEAN, // boolean, implemented as an int, I may use this as a hint for compression FIELD_BOOLEAN, // boolean, implemented as an int, I may use this as a hint for compression
FIELD_SHORT, // 2 byte integer FIELD_INT16, // 2 byte integer
FIELD_CHARACTER, // a byte FIELD_CHARACTER, // a byte
FIELD_COLOR32, // 8-bit per channel r,g,b,a (32bit color) FIELD_COLOR32, // 8-bit per channel r,g,b,a (32bit color)
FIELD_EMBEDDED, // an embedded object with a datadesc, recursively traverse and embedded class/structure based on an additional typedescription FIELD_EMBEDDED, // an embedded object with a datadesc, recursively traverse and embedded class/structure based on an additional typedescription
@ -61,7 +61,7 @@ typedef enum _fieldtypes : uint8
FIELD_UNUSED, FIELD_UNUSED,
FIELD_VECTOR2D, // 2 floats FIELD_VECTOR2D, // 2 floats
FIELD_INTEGER64, // 64bit integer FIELD_INT64, // 64bit integer
FIELD_VECTOR4D, // 4 floats FIELD_VECTOR4D, // 4 floats
@ -76,7 +76,7 @@ typedef enum _fieldtypes : uint8
FIELD_FLOAT64, FIELD_FLOAT64,
FIELD_POSITIVEINTEGER_OR_NULL, FIELD_POSITIVEINTEGER_OR_NULL,
FIELD_HSCRIPT_NEW_INSTANCE, FIELD_HSCRIPT_NEW_INSTANCE,
FIELD_UINT, FIELD_UINT32,
FIELD_UTLSTRINGTOKEN, FIELD_UTLSTRINGTOKEN,
FIELD_QANGLE, FIELD_QANGLE,
FIELD_NETWORK_ORIGIN_CELL_QUANTIZED_VECTOR, FIELD_NETWORK_ORIGIN_CELL_QUANTIZED_VECTOR,
@ -149,16 +149,16 @@ public:
#define FIELD_SIZE( _fieldType ) CDatamapFieldSizeDeducer<_fieldType>::SIZE #define FIELD_SIZE( _fieldType ) CDatamapFieldSizeDeducer<_fieldType>::SIZE
#define FIELD_BITS( _fieldType ) (FIELD_SIZE( _fieldType ) * 8) #define FIELD_BITS( _fieldType ) (FIELD_SIZE( _fieldType ) * 8)
DECLARE_FIELD_SIZE( FIELD_FLOAT, sizeof(float) ) DECLARE_FIELD_SIZE( FIELD_FLOAT32, sizeof(float32))
DECLARE_FIELD_SIZE( FIELD_STRING, sizeof(int)) DECLARE_FIELD_SIZE( FIELD_STRING, sizeof(int))
DECLARE_FIELD_SIZE( FIELD_VECTOR, 3 * sizeof(float) ) DECLARE_FIELD_SIZE( FIELD_VECTOR, 3 * sizeof(float32))
DECLARE_FIELD_SIZE( FIELD_VECTOR2D, 2 * sizeof(float) ) DECLARE_FIELD_SIZE( FIELD_VECTOR2D, 2 * sizeof(float32))
DECLARE_FIELD_SIZE( FIELD_VECTOR4D, 4 * sizeof( float ) ) DECLARE_FIELD_SIZE( FIELD_VECTOR4D, 4 * sizeof(float32))
DECLARE_FIELD_SIZE( FIELD_QUATERNION, 4 * sizeof(float)) DECLARE_FIELD_SIZE( FIELD_QUATERNION, 4 * sizeof(float32))
DECLARE_FIELD_SIZE( FIELD_INTEGER, sizeof(int)) DECLARE_FIELD_SIZE( FIELD_INT32, sizeof(int32))
DECLARE_FIELD_SIZE( FIELD_INTEGER64, sizeof(int64)) DECLARE_FIELD_SIZE( FIELD_INT64, sizeof(int64))
DECLARE_FIELD_SIZE( FIELD_BOOLEAN, sizeof(char)) DECLARE_FIELD_SIZE( FIELD_BOOLEAN, sizeof(char))
DECLARE_FIELD_SIZE( FIELD_SHORT, sizeof(short)) DECLARE_FIELD_SIZE( FIELD_INT16, sizeof(int16))
DECLARE_FIELD_SIZE( FIELD_CHARACTER, sizeof(char)) DECLARE_FIELD_SIZE( FIELD_CHARACTER, sizeof(char))
DECLARE_FIELD_SIZE( FIELD_COLOR32, sizeof(int)) DECLARE_FIELD_SIZE( FIELD_COLOR32, sizeof(int))
DECLARE_FIELD_SIZE( FIELD_CLASSPTR, sizeof(int)) DECLARE_FIELD_SIZE( FIELD_CLASSPTR, sizeof(int))

2
public/gametrace.h
View File

@ -98,6 +98,8 @@ public:
float m_softContactFrequency; float m_softContactFrequency;
float m_softContactDampingRatio; float m_softContactDampingRatio;
float m_wheelDrag; float m_wheelDrag;
float m_heatConductivity;
float m_flashpoint;
}; };
class CPhysSurfacePropertiesSoundNames class CPhysSurfacePropertiesSoundNames

114
public/variant.h
View File

@ -61,25 +61,25 @@ inline const char *VariantFieldTypeName(fieldtype_t eType)
switch(eType) switch(eType)
{ {
case FIELD_VOID: return "void"; case FIELD_VOID: return "void";
case FIELD_FLOAT: return "float"; case FIELD_FLOAT32: return "float32";
case FIELD_STRING: return "string_t"; case FIELD_STRING: return "string_t";
case FIELD_VECTOR: return "vector"; case FIELD_VECTOR: return "vector";
case FIELD_QUATERNION: return "quaternion"; case FIELD_QUATERNION: return "quaternion";
case FIELD_INTEGER: return "integer"; case FIELD_INT32: return "int32";
case FIELD_BOOLEAN: return "boolean"; case FIELD_BOOLEAN: return "boolean";
case FIELD_CHARACTER: return "character"; case FIELD_CHARACTER: return "character";
case FIELD_COLOR32: return "color"; case FIELD_COLOR32: return "color";
case FIELD_EHANDLE: return "ehandle"; case FIELD_EHANDLE: return "ehandle";
case FIELD_VECTOR2D: return "vector2d"; case FIELD_VECTOR2D: return "vector2d";
case FIELD_VECTOR4D: return "vector4d"; case FIELD_VECTOR4D: return "vector4d";
case FIELD_INTEGER64: return "int64"; case FIELD_INT64: return "int64";
case FIELD_RESOURCE: return "resourcehandle"; case FIELD_RESOURCE: return "resourcehandle";
case FIELD_CSTRING: return "cstring"; case FIELD_CSTRING: return "cstring";
case FIELD_HSCRIPT: return "hscript"; case FIELD_HSCRIPT: return "hscript";
case FIELD_VARIANT: return "variant"; case FIELD_VARIANT: return "variant";
case FIELD_UINT64: return "uint64"; case FIELD_UINT64: return "uint64";
case FIELD_FLOAT64: return "float64"; case FIELD_FLOAT64: return "float64";
case FIELD_UINT: return "unsigned"; case FIELD_UINT32: return "unsigned";
case FIELD_UTLSTRINGTOKEN: return "utlstringtoken"; case FIELD_UTLSTRINGTOKEN: return "utlstringtoken";
case FIELD_QANGLE: return "qangle"; case FIELD_QANGLE: return "qangle";
case FIELD_HSCRIPT_LIGHTBINDING: return "hscript_lightbinding"; case FIELD_HSCRIPT_LIGHTBINDING: return "hscript_lightbinding";
@ -118,12 +118,12 @@ DECLARE_DEDUCE_VARIANT_FIELDTYPE(FIELD_QUATERNION, const Quaternion &);
DECLARE_DEDUCE_VARIANT_FIELDTYPE(FIELD_STRING, string_t); DECLARE_DEDUCE_VARIANT_FIELDTYPE(FIELD_STRING, string_t);
DECLARE_DEDUCE_VARIANT_FIELDTYPE(FIELD_BOOLEAN, bool); DECLARE_DEDUCE_VARIANT_FIELDTYPE(FIELD_BOOLEAN, bool);
DECLARE_DEDUCE_VARIANT_FIELDTYPE(FIELD_CHARACTER, char); DECLARE_DEDUCE_VARIANT_FIELDTYPE(FIELD_CHARACTER, char);
DECLARE_DEDUCE_VARIANT_FIELDTYPE(FIELD_INTEGER64, int64); DECLARE_DEDUCE_VARIANT_FIELDTYPE(FIELD_INT64, int64);
DECLARE_DEDUCE_VARIANT_FIELDTYPE(FIELD_UINT64, uint64); DECLARE_DEDUCE_VARIANT_FIELDTYPE(FIELD_UINT64, uint64);
DECLARE_DEDUCE_VARIANT_FIELDTYPE(FIELD_FLOAT, float); DECLARE_DEDUCE_VARIANT_FIELDTYPE(FIELD_FLOAT32, float32);
DECLARE_DEDUCE_VARIANT_FIELDTYPE(FIELD_FLOAT64, float64); DECLARE_DEDUCE_VARIANT_FIELDTYPE(FIELD_FLOAT64, float64);
DECLARE_DEDUCE_VARIANT_FIELDTYPE(FIELD_INTEGER, int); DECLARE_DEDUCE_VARIANT_FIELDTYPE(FIELD_INT32, int32);
DECLARE_DEDUCE_VARIANT_FIELDTYPE(FIELD_UINT, uint); DECLARE_DEDUCE_VARIANT_FIELDTYPE(FIELD_UINT32, uint32);
DECLARE_DEDUCE_VARIANT_FIELDTYPE(FIELD_HSCRIPT, HSCRIPT); DECLARE_DEDUCE_VARIANT_FIELDTYPE(FIELD_HSCRIPT, HSCRIPT);
DECLARE_DEDUCE_VARIANT_FIELDTYPE(FIELD_EHANDLE, CEntityHandle); DECLARE_DEDUCE_VARIANT_FIELDTYPE(FIELD_EHANDLE, CEntityHandle);
DECLARE_DEDUCE_VARIANT_FIELDTYPE(FIELD_RESOURCE, ResourceHandle_t); DECLARE_DEDUCE_VARIANT_FIELDTYPE(FIELD_RESOURCE, ResourceHandle_t);
@ -145,11 +145,11 @@ DECLARE_NAMED_VARIANT_FIELDTYPE(const char *, "cstring");
DECLARE_NAMED_VARIANT_FIELDTYPE(char *, "cstring"); DECLARE_NAMED_VARIANT_FIELDTYPE(char *, "cstring");
DECLARE_NAMED_VARIANT_FIELDTYPE(bool, "boolean"); DECLARE_NAMED_VARIANT_FIELDTYPE(bool, "boolean");
DECLARE_NAMED_VARIANT_FIELDTYPE(char, "character"); DECLARE_NAMED_VARIANT_FIELDTYPE(char, "character");
DECLARE_NAMED_VARIANT_FIELDTYPE(int, "integer"); DECLARE_NAMED_VARIANT_FIELDTYPE(int32, "int32");
DECLARE_NAMED_VARIANT_FIELDTYPE(uint, "unsigned integer"); DECLARE_NAMED_VARIANT_FIELDTYPE(uint32, "uint32");
DECLARE_NAMED_VARIANT_FIELDTYPE(int64, "int64"); DECLARE_NAMED_VARIANT_FIELDTYPE(int64, "int64");
DECLARE_NAMED_VARIANT_FIELDTYPE(uint64, "uint64"); DECLARE_NAMED_VARIANT_FIELDTYPE(uint64, "uint64");
DECLARE_NAMED_VARIANT_FIELDTYPE(float, "float"); DECLARE_NAMED_VARIANT_FIELDTYPE(float32, "float32");
DECLARE_NAMED_VARIANT_FIELDTYPE(float64, "float64"); DECLARE_NAMED_VARIANT_FIELDTYPE(float64, "float64");
#undef DECLARE_NAMED_VARIANT_FIELDTYPE #undef DECLARE_NAMED_VARIANT_FIELDTYPE
@ -167,9 +167,9 @@ public:
typedef A Allocator; typedef A Allocator;
CVariantBase() : m_type( FIELD_VOID ), m_flags( 0 ) { m_pData = NULL; } CVariantBase() : m_type( FIELD_VOID ), m_flags( 0 ) { m_pData = NULL; }
CVariantBase( int val ) : m_type( FIELD_INTEGER ), m_flags( 0 ) { m_int = val;} CVariantBase( int32 val ) : m_type( FIELD_INT32 ), m_flags( 0 ) { m_int32 = val;}
CVariantBase( uint val) : m_type( FIELD_UINT ), m_flags( 0 ) { m_uint = val; } CVariantBase( uint32 val) : m_type( FIELD_UINT32 ), m_flags( 0 ) { m_uint32 = val; }
CVariantBase( float val ) : m_type( FIELD_FLOAT ), m_flags( 0 ) { m_float = val; } CVariantBase( float32 val ) : m_type( FIELD_FLOAT32 ), m_flags( 0 ) { m_float32 = val; }
CVariantBase( float64 val ) : m_type( FIELD_FLOAT64 ), m_flags( 0 ) { m_float64 = val; } CVariantBase( float64 val ) : m_type( FIELD_FLOAT64 ), m_flags( 0 ) { m_float64 = val; }
CVariantBase( char val ) : m_type( FIELD_CHARACTER ), m_flags( 0 ) { m_char = val; } CVariantBase( char val ) : m_type( FIELD_CHARACTER ), m_flags( 0 ) { m_char = val; }
CVariantBase( bool val ) : m_type( FIELD_BOOLEAN ), m_flags( 0 ) { m_bool = val; } CVariantBase( bool val ) : m_type( FIELD_BOOLEAN ), m_flags( 0 ) { m_bool = val; }
@ -178,7 +178,7 @@ public:
CVariantBase( CUtlStringToken val ) : m_type( FIELD_UTLSTRINGTOKEN ), m_flags( 0 ){ m_utlStringToken = val; } CVariantBase( CUtlStringToken val ) : m_type( FIELD_UTLSTRINGTOKEN ), m_flags( 0 ){ m_utlStringToken = val; }
CVariantBase( ResourceHandle_t val ) : m_type( FIELD_RESOURCE ), m_flags( 0 ) { m_hResource = val; } CVariantBase( ResourceHandle_t val ) : m_type( FIELD_RESOURCE ), m_flags( 0 ) { m_hResource = val; }
CVariantBase( string_t val ) : m_type( FIELD_STRING ), m_flags( 0 ) { m_stringt = val; } CVariantBase( string_t val ) : m_type( FIELD_STRING ), m_flags( 0 ) { m_stringt = val; }
CVariantBase( int64 val ) : m_type( FIELD_INTEGER64 ), m_flags( 0 ) { m_int64 = val; } CVariantBase( int64 val ) : m_type( FIELD_INT64 ), m_flags( 0 ) { m_int64 = val; }
CVariantBase( uint64 val ) : m_type( FIELD_UINT64), m_flags( 0 ) { m_uint64 = val; } CVariantBase( uint64 val ) : m_type( FIELD_UINT64), m_flags( 0 ) { m_uint64 = val; }
CVariantBase( const Vector &val, bool bCopy = true) : m_type( FIELD_VECTOR ), m_flags( 0 ) { CopyData(val, bCopy); } CVariantBase( const Vector &val, bool bCopy = true) : m_type( FIELD_VECTOR ), m_flags( 0 ) { CopyData(val, bCopy); }
@ -240,11 +240,11 @@ public:
} }
} }
operator int() const { Assert( m_type == FIELD_INTEGER ); return m_int; } operator int32() const { Assert( m_type == FIELD_INT32 ); return m_int32; }
operator uint() const { Assert( m_type == FIELD_UINT ); return m_uint; } operator uint32() const { Assert( m_type == FIELD_UINT32 ); return m_uint32; }
operator int64() const { Assert( m_type == FIELD_INTEGER64); return m_int64; } operator int64() const { Assert( m_type == FIELD_INT64); return m_int64; }
operator uint64() const { Assert( m_type == FIELD_UINT64); return m_uint64; } operator uint64() const { Assert( m_type == FIELD_UINT64); return m_uint64; }
operator float() const { Assert( m_type == FIELD_FLOAT ); return m_float; } operator float32() const { Assert( m_type == FIELD_FLOAT32 ); return m_float32; }
operator float64() const { Assert( m_type == FIELD_FLOAT64 ); return m_float64; } operator float64() const { Assert( m_type == FIELD_FLOAT64 ); return m_float64; }
operator const string_t() const { Assert( m_type == FIELD_STRING ); return m_stringt; } operator const string_t() const { Assert( m_type == FIELD_STRING ); return m_stringt; }
operator const char *() const { Assert( m_type == FIELD_CSTRING ); return ( m_pszString ) ? m_pszString : ""; } operator const char *() const { Assert( m_type == FIELD_CSTRING ); return ( m_pszString ) ? m_pszString : ""; }
@ -261,11 +261,11 @@ public:
operator CUtlStringToken() const { Assert( m_type == FIELD_UTLSTRINGTOKEN); return m_utlStringToken; } operator CUtlStringToken() const { Assert( m_type == FIELD_UTLSTRINGTOKEN); return m_utlStringToken; }
operator ResourceHandle_t() const { Assert( m_type == FIELD_RESOURCE); return m_hResource; } operator ResourceHandle_t() const { Assert( m_type == FIELD_RESOURCE); return m_hResource; }
void operator=( int i ) { m_type = FIELD_INTEGER; m_int = i; } void operator=( int32 i ) { m_type = FIELD_INT32; m_int32 = i; }
void operator=( uint u ) { m_type = FIELD_UINT; m_uint = u; } void operator=( uint32 u ) { m_type = FIELD_UINT32; m_uint32 = u; }
void operator=( int64 i ) { m_type = FIELD_INTEGER64; m_int64 = i; } void operator=( int64 i ) { m_type = FIELD_INT64; m_int64 = i; }
void operator=( uint64 u ) { m_type = FIELD_UINT64; m_uint64 = u; } void operator=( uint64 u ) { m_type = FIELD_UINT64; m_uint64 = u; }
void operator=( float f ) { m_type = FIELD_FLOAT; m_float = f; } void operator=( float32 f ) { m_type = FIELD_FLOAT32; m_float32 = f; }
void operator=( float64 d ) { m_type = FIELD_FLOAT64; m_float64 = d; } void operator=( float64 d ) { m_type = FIELD_FLOAT64; m_float64 = d; }
void operator=( const Vector &vec ) { m_type = FIELD_VECTOR; *(Vector *)m_pVector = vec; } void operator=( const Vector &vec ) { m_type = FIELD_VECTOR; *(Vector *)m_pVector = vec; }
void operator=( const Vector *vec ) { m_type = FIELD_VECTOR; m_pVector = vec; } void operator=( const Vector *vec ) { m_type = FIELD_VECTOR; m_pVector = vec; }
@ -314,11 +314,11 @@ public:
switch(m_type) switch(m_type)
{ {
case FIELD_VOID: return false; case FIELD_VOID: return false;
case FIELD_FLOAT: buf.Format("%g", m_float); return true; case FIELD_FLOAT32: buf.Format("%g", m_float32); return true;
case FIELD_FLOAT64: buf.Format("%g", m_float64); return true; case FIELD_FLOAT64: buf.Format("%g", m_float64); return true;
case FIELD_INTEGER: buf.Format("%d", m_int); return true; case FIELD_INT32: buf.Format("%d", m_int32); return true;
case FIELD_UINT: buf.Format("%u", m_uint); return true; case FIELD_UINT32: buf.Format("%u", m_uint32); return true;
case FIELD_INTEGER64: buf.Format("%lld", m_int64); return true; case FIELD_INT64: buf.Format("%lld", m_int64); return true;
case FIELD_UINT64: buf.Format("%llu", m_uint64); return true; case FIELD_UINT64: buf.Format("%llu", m_uint64); return true;
case FIELD_BOOLEAN: buf.Insert(0, m_bool ? "true" : "false"); return true; case FIELD_BOOLEAN: buf.Insert(0, m_bool ? "true" : "false"); return true;
case FIELD_STRING: buf.Insert(0, m_stringt.ToCStr()); return true; case FIELD_STRING: buf.Insert(0, m_stringt.ToCStr()); return true;
@ -353,11 +353,11 @@ public:
switch(m_type) switch(m_type)
{ {
case FIELD_VOID: *pDest = 0.0; return false; case FIELD_VOID: *pDest = 0.0; return false;
case FIELD_INTEGER: *pDest = m_int; return true; case FIELD_INT32: *pDest = m_int32; return true;
case FIELD_INTEGER64: *pDest = m_int64; return true; case FIELD_INT64: *pDest = m_int64; return true;
case FIELD_UINT: *pDest = m_uint; return true; case FIELD_UINT32: *pDest = m_uint32; return true;
case FIELD_UINT64: *pDest = m_uint64; return true; case FIELD_UINT64: *pDest = m_uint64; return true;
case FIELD_FLOAT: *pDest = m_float; return true; case FIELD_FLOAT32: *pDest = m_float32; return true;
case FIELD_FLOAT64: *pDest = m_float64; return true; case FIELD_FLOAT64: *pDest = m_float64; return true;
case FIELD_BOOLEAN: *pDest = m_bool; return true; case FIELD_BOOLEAN: *pDest = m_bool; return true;
case FIELD_CSTRING: case FIELD_CSTRING:
@ -389,11 +389,11 @@ public:
switch(m_type) switch(m_type)
{ {
case FIELD_VOID: *pDest = 0; return false; case FIELD_VOID: *pDest = 0; return false;
case FIELD_INTEGER: *pDest = m_int; return true; case FIELD_INT32: *pDest = m_int32; return true;
case FIELD_INTEGER64: *pDest = m_int64; return true; case FIELD_INT64: *pDest = m_int64; return true;
case FIELD_UINT: *pDest = m_uint; return true; case FIELD_UINT32: *pDest = m_uint32; return true;
case FIELD_UINT64: *pDest = m_uint64; return true; case FIELD_UINT64: *pDest = m_uint64; return true;
case FIELD_FLOAT: *pDest = m_float; return true; case FIELD_FLOAT32: *pDest = m_float32; return true;
case FIELD_FLOAT64: *pDest = m_float64; return true; case FIELD_FLOAT64: *pDest = m_float64; return true;
case FIELD_BOOLEAN: *pDest = m_bool; return true; case FIELD_BOOLEAN: *pDest = m_bool; return true;
case FIELD_CSTRING: case FIELD_CSTRING:
@ -425,11 +425,11 @@ public:
switch(m_type) switch(m_type)
{ {
case FIELD_VOID: *pDest = 0; return false; case FIELD_VOID: *pDest = 0; return false;
case FIELD_INTEGER: *pDest = m_int != 0; return true; case FIELD_INT32: *pDest = m_int32 != 0; return true;
case FIELD_INTEGER64: *pDest = m_int64 != 0; return true; case FIELD_INT64: *pDest = m_int64 != 0; return true;
case FIELD_UINT: *pDest = m_uint != 0; return true; case FIELD_UINT32: *pDest = m_uint32 != 0; return true;
case FIELD_UINT64: *pDest = m_uint64 != 0; return true; case FIELD_UINT64: *pDest = m_uint64 != 0; return true;
case FIELD_FLOAT: *pDest = m_float != 0.0; return true; case FIELD_FLOAT32: *pDest = m_float32 != 0.0; return true;
case FIELD_FLOAT64: *pDest = m_float64 != 0.0; return true; case FIELD_FLOAT64: *pDest = m_float64 != 0.0; return true;
case FIELD_BOOLEAN: *pDest = m_bool; return true; case FIELD_BOOLEAN: *pDest = m_bool; return true;
case FIELD_CSTRING: case FIELD_CSTRING:
@ -811,11 +811,11 @@ public:
switch(m_type) switch(m_type)
{ {
case FIELD_VOID: *pDest = 0; return false; case FIELD_VOID: *pDest = 0; return false;
case FIELD_INTEGER: *pDest = m_int; return true; case FIELD_INT32: *pDest = m_int32; return true;
case FIELD_INTEGER64: *pDest = m_int64; return true; case FIELD_INT64: *pDest = m_int64; return true;
case FIELD_UINT: *pDest = m_uint; return true; case FIELD_UINT32: *pDest = m_uint32; return true;
case FIELD_UINT64: *pDest = m_uint64; return true; case FIELD_UINT64: *pDest = m_uint64; return true;
case FIELD_FLOAT: *pDest = m_float; return true; case FIELD_FLOAT32: *pDest = m_float32; return true;
case FIELD_FLOAT64: *pDest = m_float64; return true; case FIELD_FLOAT64: *pDest = m_float64; return true;
case FIELD_CHARACTER: *pDest = m_char; return true; case FIELD_CHARACTER: *pDest = m_char; return true;
case FIELD_BOOLEAN: *pDest = m_bool; return true; case FIELD_BOOLEAN: *pDest = m_bool; return true;
@ -867,11 +867,11 @@ public:
switch(ftype) switch(ftype)
{ {
case FIELD_VOID: Free(); m_type = FIELD_VOID; m_pData = NULL; return; case FIELD_VOID: Free(); m_type = FIELD_VOID; m_pData = NULL; return;
case FIELD_FLOAT: CopyData(*(float *)pData, false); return; case FIELD_FLOAT32: CopyData(*(float32 *)pData, false); return;
case FIELD_FLOAT64: CopyData(*(float64 *)pData, false); return; case FIELD_FLOAT64: CopyData(*(float64 *)pData, false); return;
case FIELD_INTEGER: CopyData(*(int *)pData, false); return; case FIELD_INT32: CopyData(*(int32 *)pData, false); return;
case FIELD_UINT: CopyData(*(uint *)pData, false); return; case FIELD_UINT32: CopyData(*(uint32 *)pData, false); return;
case FIELD_INTEGER64: CopyData(*(int64 *)pData, false); return; case FIELD_INT64: CopyData(*(int64 *)pData, false); return;
case FIELD_UINT64: CopyData(*(uint64 *)pData, false); return; case FIELD_UINT64: CopyData(*(uint64 *)pData, false); return;
case FIELD_BOOLEAN: CopyData(*(bool *)pData, false); return; case FIELD_BOOLEAN: CopyData(*(bool *)pData, false); return;
case FIELD_CHARACTER: CopyData(*(char *)pData, false); return; case FIELD_CHARACTER: CopyData(*(char *)pData, false); return;
@ -903,11 +903,11 @@ public:
switch(newType) switch(newType)
{ {
case FIELD_VOID: successful = true; Free(); m_type = FIELD_VOID; m_pData = NULL; break; case FIELD_VOID: successful = true; Free(); m_type = FIELD_VOID; m_pData = NULL; break;
case FIELD_FLOAT: if((successful = AssignTo((float *)&pData))) { Set(newType, &pData); } break; case FIELD_FLOAT32: if((successful = AssignTo((float32 *)&pData))) { Set(newType, &pData); } break;
case FIELD_FLOAT64: if((successful = AssignTo((float64 *)&pData))) { Set(newType, &pData); } break; case FIELD_FLOAT64: if((successful = AssignTo((float64 *)&pData))) { Set(newType, &pData); } break;
case FIELD_INTEGER: if((successful = AssignTo((int *)&pData))) { Set(newType, &pData); } break; case FIELD_INT32: if((successful = AssignTo((int32 *)&pData))) { Set(newType, &pData); } break;
case FIELD_UINT: if((successful = AssignTo((uint *)&pData))) { Set(newType, &pData); } break; case FIELD_UINT32: if((successful = AssignTo((uint32 *)&pData))) { Set(newType, &pData); } break;
case FIELD_INTEGER64: if((successful = AssignTo((int64 *)&pData))) { Set(newType, &pData); } break; case FIELD_INT64: if((successful = AssignTo((int64 *)&pData))) { Set(newType, &pData); } break;
case FIELD_UINT64: if((successful = AssignTo((uint64 *)&pData))) { Set(newType, &pData); } break; case FIELD_UINT64: if((successful = AssignTo((uint64 *)&pData))) { Set(newType, &pData); } break;
case FIELD_BOOLEAN: if((successful = AssignTo((bool *)&pData))) { Set(newType, &pData); } break; case FIELD_BOOLEAN: if((successful = AssignTo((bool *)&pData))) { Set(newType, &pData); } break;
case FIELD_CHARACTER: if((successful = AssignTo((char *)&pData))) { Set(newType, &pData); } break; case FIELD_CHARACTER: if((successful = AssignTo((char *)&pData))) { Set(newType, &pData); } break;
@ -943,9 +943,12 @@ public:
public: public:
union union
{ {
int m_int; int32 m_int32;
uint m_uint; uint32 m_uint32;
float m_float; int64 m_int64;
uint64 m_uint64;
float32 m_float32;
float64 m_float64;
const char *m_pszString; const char *m_pszString;
const Vector *m_pVector; const Vector *m_pVector;
const QAngle *m_pQAngle; const QAngle *m_pQAngle;
@ -958,9 +961,6 @@ public:
bool m_bool; bool m_bool;
HSCRIPT m_hScript; HSCRIPT m_hScript;
CEntityHandle m_hEntity; CEntityHandle m_hEntity;
uint64 m_uint64;
int64 m_int64;
float64 m_float64;
string_t m_stringt; string_t m_stringt;
CUtlStringToken m_utlStringToken; CUtlStringToken m_utlStringToken;
ResourceHandle_t m_hResource; ResourceHandle_t m_hResource;

6
public/vscript/ivscript.h
View File

@ -1,4 +1,4 @@
//========== Copyright <20> 2008, Valve Corporation, All rights reserved. ======== //========== Copyright <20> 2008, Valve Corporation, All rights reserved. ========
// //
// Purpose: VScript // Purpose: VScript
// //
@ -175,12 +175,12 @@ template <typename T> struct ScriptDeducer { /*enum { FIELD_TYPE = FIELD_TYPEUNK
#define DECLARE_DEDUCE_FIELDTYPE( fieldType, type ) template<> struct ScriptDeducer<type> { enum { FIELD_TYPE = fieldType }; }; #define DECLARE_DEDUCE_FIELDTYPE( fieldType, type ) template<> struct ScriptDeducer<type> { enum { FIELD_TYPE = fieldType }; };
DECLARE_DEDUCE_FIELDTYPE( FIELD_VOID, void ); DECLARE_DEDUCE_FIELDTYPE( FIELD_VOID, void );
DECLARE_DEDUCE_FIELDTYPE( FIELD_FLOAT, float ); DECLARE_DEDUCE_FIELDTYPE( FIELD_FLOAT32, float32 );
DECLARE_DEDUCE_FIELDTYPE( FIELD_CSTRING, const char * ); DECLARE_DEDUCE_FIELDTYPE( FIELD_CSTRING, const char * );
DECLARE_DEDUCE_FIELDTYPE( FIELD_CSTRING, char * ); DECLARE_DEDUCE_FIELDTYPE( FIELD_CSTRING, char * );
DECLARE_DEDUCE_FIELDTYPE( FIELD_VECTOR, Vector ); DECLARE_DEDUCE_FIELDTYPE( FIELD_VECTOR, Vector );
DECLARE_DEDUCE_FIELDTYPE( FIELD_VECTOR, const Vector & ); DECLARE_DEDUCE_FIELDTYPE( FIELD_VECTOR, const Vector & );
DECLARE_DEDUCE_FIELDTYPE( FIELD_INTEGER, int ); DECLARE_DEDUCE_FIELDTYPE( FIELD_INT32, int32 );
DECLARE_DEDUCE_FIELDTYPE( FIELD_BOOLEAN, bool ); DECLARE_DEDUCE_FIELDTYPE( FIELD_BOOLEAN, bool );
DECLARE_DEDUCE_FIELDTYPE( FIELD_CHARACTER, char ); DECLARE_DEDUCE_FIELDTYPE( FIELD_CHARACTER, char );
DECLARE_DEDUCE_FIELDTYPE( FIELD_HSCRIPT, HSCRIPT ); DECLARE_DEDUCE_FIELDTYPE( FIELD_HSCRIPT, HSCRIPT );