sqwarmed/sdk_src/game/shared/predictioncopy.cpp

1727 lines
50 KiB
C++

//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//=============================================================================//
#include "cbase.h"
#if !defined( NO_ENTITY_PREDICTION )
#include "IGameSystem.h"
#include <typeinfo.h>
#include "cdll_int.h"
#include <memory.h>
#include <stdarg.h>
#include "tier0/dbg.h"
#include "tier1/strtools.h"
#include "predictioncopy.h"
#include "engine/ivmodelinfo.h"
#include "tier1/fmtstr.h"
#include "utlvector.h"
#include "tier0/vprof.h"
#include "tier1/tokenset.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
CClassMemoryPool< optimized_datamap_t > g_OptimizedDataMapPool( 20, CUtlMemoryPool::GROW_SLOW );
// --------------------------------------------------------------
//
// CSave
//
// --------------------------------------------------------------
static const char *g_FieldTypes[ FIELD_TYPECOUNT ] =
{
"FIELD_VOID", // FIELD_VOID
"FIELD_FLOAT", // FIELD_FLOAT
"FIELD_STRING", // FIELD_STRING
"FIELD_VECTOR", // FIELD_VECTOR
"FIELD_QUATERNION", // FIELD_QUATERNION
"FIELD_INTEGER", // FIELD_INTEGER
"FIELD_BOOLEAN", // FIELD_BOOLEAN
"FIELD_SHORT", // FIELD_SHORT
"FIELD_CHARACTER", // FIELD_CHARACTER
"FIELD_COLOR32", // FIELD_COLOR32
"FIELD_EMBEDDED", // FIELD_EMBEDDED (handled specially)
"FIELD_CUSTOM", // FIELD_CUSTOM (handled specially)
"FIELD_CLASSPTR", // FIELD_CLASSPTR
"FIELD_EHANDLE", // FIELD_EHANDLE
"FIELD_EDICT", // FIELD_EDICT
"FIELD_POSITION_VECTOR",// FIELD_POSITION_VECTOR
"FIELD_TIME", // FIELD_TIME
"FIELD_TICK", // FIELD_TICK
"FIELD_MODELNAME", // FIELD_MODELNAME
"FIELD_SOUNDNAME", // FIELD_SOUNDNAME
"FIELD_INPUT", // FIELD_INPUT (uses custom type)
"FIELD_FUNCTION", // FIELD_FUNCTION
"FIELD_VMATRIX",
"FIELD_VMATRIX_WORLDSPACE",
"FIELD_MATRIX3X4_WORLDSPACE",
"FIELD_INTERVAL" // FIELD_INTERVAL
"FIELD_MODELINDEX" // FIELD_MODELINDEX
};
static int g_FieldSizes[FIELD_TYPECOUNT] =
{
0, // FIELD_VOID
sizeof(float), // FIELD_FLOAT
sizeof(int), // FIELD_STRING
sizeof(Vector), // FIELD_VECTOR
sizeof(Quaternion), // FIELD_QUATERNION
sizeof(int), // FIELD_INTEGER
sizeof(char), // FIELD_BOOLEAN
sizeof(short), // FIELD_SHORT
sizeof(char), // FIELD_CHARACTER
sizeof(color32), // FIELD_COLOR32
sizeof(int), // FIELD_EMBEDDED (handled specially)
sizeof(int), // FIELD_CUSTOM (handled specially)
//---------------------------------
sizeof(int), // FIELD_CLASSPTR
sizeof(EHANDLE), // FIELD_EHANDLE
sizeof(int), // FIELD_EDICT
sizeof(Vector), // FIELD_POSITION_VECTOR
sizeof(float), // FIELD_TIME
sizeof(int), // FIELD_TICK
sizeof(int), // FIELD_MODELNAME
sizeof(int), // FIELD_SOUNDNAME
sizeof(int), // FIELD_INPUT (uses custom type)
sizeof(int *), // FIELD_FUNCTION
sizeof(VMatrix), // FIELD_VMATRIX
sizeof(VMatrix), // FIELD_VMATRIX_WORLDSPACE
sizeof(matrix3x4_t),// FIELD_MATRIX3X4_WORLDSPACE // NOTE: Use array(FIELD_FLOAT, 12) for matrix3x4_t NOT in worldspace
sizeof(interval_t), // FIELD_INTERVAL
sizeof(int), // FIELD_MODELINDEX
};
#define PREDICTIONCOPY_APPLY( func, nFieldType, pCurrentMap, pField, pOutputData, pInputData, fieldSize ) \
switch( nFieldType ) \
{ \
case FIELD_EMBEDDED: \
{ \
Error( "FIELD_EMBEDDED in flat list!!!" ); \
} \
break; \
case FIELD_FLOAT: \
func( pCurrentMap, pField, (float *)pOutputData, (const float *)pInputData, fieldSize ); \
break; \
case FIELD_STRING: \
func( pCurrentMap, pField, (char *)pOutputData, (const char *)pInputData, fieldSize ); \
break; \
case FIELD_VECTOR: \
func( pCurrentMap, pField, (Vector *)pOutputData, (const Vector *)pInputData, fieldSize ); \
break; \
case FIELD_QUATERNION: \
func( pCurrentMap, pField, (Quaternion *)pOutputData, (const Quaternion *)pInputData, fieldSize );\
break; \
case FIELD_COLOR32: \
func( pCurrentMap, pField, (color32 *)pOutputData, (const color32 *)pInputData, fieldSize ); \
break; \
case FIELD_BOOLEAN: \
func( pCurrentMap, pField, (bool *)pOutputData, (const bool *)pInputData, fieldSize ); \
break; \
case FIELD_INTEGER: \
func( pCurrentMap, pField, (int *)pOutputData, (const int *)pInputData, fieldSize ); \
break; \
case FIELD_SHORT: \
func( pCurrentMap, pField, (short *)pOutputData, (const short *)pInputData, fieldSize ); \
break; \
case FIELD_CHARACTER: \
func( pCurrentMap, pField, (uint8 *)pOutputData, (const uint8 *)pInputData, fieldSize ); \
break; \
case FIELD_EHANDLE: \
func( pCurrentMap, pField, (EHANDLE *)pOutputData, (const EHANDLE *)pInputData, fieldSize );\
break; \
default: \
break; \
}
#define PREDICTIONCOPY_APPLY_NOEMBEDDED( func, nFieldType, pCurrentMap, pField, pOutputData, pInputData, fieldSize ) \
switch( nFieldType ) \
{ \
case FIELD_FLOAT: \
func( pCurrentMap, pField, (float *)pOutputData, (const float *)pInputData, fieldSize ); \
break; \
case FIELD_STRING: \
func( pCurrentMap, pField, (char *)pOutputData, (const char *)pInputData, fieldSize ); \
break; \
case FIELD_VECTOR: \
func( pCurrentMap, pField, (Vector *)pOutputData, (const Vector *)pInputData, fieldSize ); \
break; \
case FIELD_QUATERNION: \
func( pCurrentMap, pField, (Quaternion *)pOutputData, (const Quaternion *)pInputData, fieldSize );\
break; \
case FIELD_COLOR32: \
func( pCurrentMap, pField, (color32 *)pOutputData, (const color32 *)pInputData, fieldSize ); \
break; \
case FIELD_BOOLEAN: \
func( pCurrentMap, pField, (bool *)pOutputData, (const bool *)pInputData, fieldSize ); \
break; \
case FIELD_INTEGER: \
func( pCurrentMap, pField, (int *)pOutputData, (const int *)pInputData, fieldSize ); \
break; \
case FIELD_SHORT: \
func( pCurrentMap, pField, (short *)pOutputData, (const short *)pInputData, fieldSize ); \
break; \
case FIELD_CHARACTER: \
func( pCurrentMap, pField, (uint8 *)pOutputData, (const uint8 *)pInputData, fieldSize ); \
break; \
case FIELD_EHANDLE: \
func( pCurrentMap, pField, (EHANDLE *)pOutputData, (const EHANDLE *)pInputData, fieldSize );\
break; \
default: \
break; \
}
CPredictionCopy::CPredictionCopy( int type, byte *dest, bool dest_packed, const byte *src, bool src_packed,
optype_t opType, FN_FIELD_COMPARE func /*= NULL*/ )
{
m_OpType = opType;
m_nType = type;
m_pDest = dest;
m_pSrc = src;
m_nDestOffsetIndex = dest_packed ? TD_OFFSET_PACKED : TD_OFFSET_NORMAL;
m_nSrcOffsetIndex = src_packed ? TD_OFFSET_PACKED : TD_OFFSET_NORMAL;
m_nErrorCount = 0;
m_nEntIndex = -1;
m_pWatchField = NULL;
m_FieldCompareFunc = func;
}
static ConVar cl_pred_error_verbose( "cl_pred_error_verbose", "0", 0, "Show more field info when spewing prediction errors." );
template< class T >
inline void CPredictionCopy::CopyField( difftype_t difftype, T *outvalue, const T *invalue, int count )
{
for ( int i = 0; i < count; ++i )
{
outvalue[ i ] = invalue[ i ];
}
}
// specialized for strings
template<>
inline void CPredictionCopy::CopyField( difftype_t difftype, char *outvalue, const char *invalue, int count )
{
Q_strcpy( outvalue, invalue );
}
template< class T >
inline void CPredictionCopy::WatchField( const typedescription_t *pField, const T *outvalue, int count )
{
Assert( 0 );
}
// Short
template<>
inline void CPredictionCopy::WatchField( const typedescription_t *pField, const short *outvalue, int count )
{
WatchMsg( pField, "short (%i)", (int)(outvalue[0]) );
}
// Int
template<>
inline void CPredictionCopy::WatchField( const typedescription_t *pField, const int *outvalue, int count )
{
bool described = false;
if ( pField->flags & FTYPEDESC_MODELINDEX )
{
int modelindex = outvalue[0];
model_t const *m = modelinfo->GetModel( modelindex );
if ( m )
{
described = true;
char shortfile[ 512 ];
shortfile[ 0 ] = 0;
Q_FileBase( modelinfo->GetModelName( m ), shortfile, sizeof( shortfile ) );
WatchMsg( pField, "integer (%i->%s)", outvalue[0], shortfile );
}
}
if ( !described )
{
WatchMsg( pField, "integer (%i)", outvalue[0] );
}
}
template<>
inline void CPredictionCopy::WatchField( const typedescription_t *pField, const bool *outvalue, int count )
{
WatchMsg( pField, "bool (%s)", (outvalue[0]) ? "true" : "false" );
}
template<>
inline void CPredictionCopy::WatchField( const typedescription_t *pField, const float *outvalue, int count )
{
WatchMsg( pField, "float (%f)", outvalue[ 0 ] );
}
template<>
inline void CPredictionCopy::WatchField( const typedescription_t *pField, const char *outstring, int count )
{
WatchMsg( pField, "string (%s)", outstring );
}
template<>
inline void CPredictionCopy::WatchField( const typedescription_t *pField, const Vector* outValue, int count )
{
WatchMsg( pField, "vector (%f %f %f)", outValue[0].x, outValue[0].y, outValue[0].z );
}
template<>
inline void CPredictionCopy::WatchField( const typedescription_t *pField, const Quaternion* outValue, int count )
{
WatchMsg( pField, "quaternion (%f %f %f %f)", outValue[0].x, outValue[0].y, outValue[0].z, outValue[0].w );
}
template<>
inline void CPredictionCopy::WatchField( const typedescription_t *pField, const EHANDLE *outvalue, int count )
{
C_BaseEntity *ent = outvalue[0].Get();
if ( ent )
{
const char *classname = ent->GetClassname();
if ( !classname[0] )
{
classname = typeid( *ent ).name();
}
WatchMsg( pField, "EHandle (0x%p->%s)", (void *)outvalue[ 0 ], classname );
}
else
{
WatchMsg( pField, "EHandle (NULL)" );
}
}
void CPredictionCopy::DumpWatchField( const typedescription_t *pField, const byte *outvalue, int count )
{
switch ( pField->fieldType )
{
case FIELD_FLOAT:
WatchField( pField, (const float *)outvalue, count );
break;
case FIELD_STRING:
WatchField( pField, (const char *)outvalue, count );
break;
case FIELD_VECTOR:
WatchField( pField, (const Vector *)outvalue, count );
break;
case FIELD_QUATERNION:
WatchField( pField, (const Quaternion *)outvalue, count );
break;
case FIELD_COLOR32:
WatchField( pField, (const color32 *)outvalue, count );
break;
case FIELD_BOOLEAN:
WatchField( pField, (const bool *)outvalue, count );
break;
case FIELD_INTEGER:
WatchField( pField, (const int *)outvalue, count );
break;
case FIELD_SHORT:
WatchField( pField, (const short *)outvalue, count );
break;
case FIELD_CHARACTER:
WatchField( pField, (const uint8 *)outvalue, count );
break;
case FIELD_EHANDLE:
WatchField( pField, (const EHANDLE *)outvalue, count );
break;
default:
break;
}
}
// color32
template<>
inline void CPredictionCopy::WatchField( const typedescription_t *pField, const color32 *outvalue, int count )
{
WatchMsg( pField, "color32 (%d %d %d %d)", outvalue[0].r, outvalue[0].g, outvalue[0].b, outvalue[0].a );
}
inline bool QuaternionCompare( const Quaternion& q1, const Quaternion& q2 )
{
for ( int i = 0; i < 4; ++i )
{
if ( q1[i] != q2[i] )
return false;
}
return true;
}
template< class T >
inline CPredictionCopy::difftype_t CPredictionCopy::CompareField( const typedescription_t *pField, const T *outvalue, const T *invalue, int count )
{
for ( int i = 0; i < count; i++ )
{
if ( outvalue[ i ] == invalue[ i ] )
continue;
return DIFFERS;
}
return IDENTICAL;
}
// float uses tolerance
template<>
inline CPredictionCopy::difftype_t CPredictionCopy::CompareField( const typedescription_t *pField, const float *outvalue, const float *invalue, int count )
{
difftype_t retval = IDENTICAL;
float tolerance = pField->fieldTolerance;
Assert( tolerance >= 0.0f );
bool usetolerance = tolerance > 0.0f;
if ( usetolerance )
{
for ( int i = 0; i < count; ++i )
{
float diff = fabs( outvalue[ i ] - invalue[ i ] );
if ( diff <= tolerance )
{
retval = WITHINTOLERANCE;
continue;
}
return DIFFERS;
}
}
else
{
for ( int i = 0; i < count; ++i )
{
if ( outvalue[ i ] == invalue[ i ] )
continue;
return DIFFERS;
}
}
return retval;
}
// vector uses tolerance
template<>
inline CPredictionCopy::difftype_t CPredictionCopy::CompareField( const typedescription_t *pField, const Vector *outvalue, const Vector *invalue, int count )
{
difftype_t retval = IDENTICAL;
float tolerance = pField->fieldTolerance;
Assert( tolerance >= 0.0f );
bool usetolerance = tolerance > 0.0f;
if ( usetolerance )
{
for ( int i = 0; i < count; ++i )
{
Vector delta = outvalue[ i ] - invalue[ i ];
if ( delta.x <= tolerance &&
delta.y <= tolerance &&
delta.z <= tolerance )
{
retval = WITHINTOLERANCE;
continue;
}
return DIFFERS;
}
}
else
{
for ( int i = 0; i < count; ++i )
{
if ( outvalue[ i ] == invalue[ i ] )
continue;
return DIFFERS;
}
}
return retval;
}
// quaternion uses tolerance
template<>
inline CPredictionCopy::difftype_t CPredictionCopy::CompareField( const typedescription_t *pField, const Quaternion *outvalue, const Quaternion *invalue, int count )
{
difftype_t retval = IDENTICAL;
float tolerance = pField->fieldTolerance;
Assert( tolerance >= 0.0f );
bool usetolerance = tolerance > 0.0f;
if ( usetolerance )
{
for ( int i = 0; i < count; ++i )
{
Quaternion delta;
for ( int j = 0; j < 4; j++ )
{
delta[i] = outvalue[i][j] - invalue[i][j];
}
if ( delta.x <= tolerance &&
delta.y <= tolerance &&
delta.z <= tolerance &&
delta.w <= tolerance )
{
retval = WITHINTOLERANCE;
continue;
}
return DIFFERS;
}
}
else
{
for ( int i = 0; i < count; ++i )
{
if ( QuaternionCompare( outvalue[ i ], invalue[ i ] ) )
continue;
return DIFFERS;
}
}
return retval;
}
// string
template<>
inline CPredictionCopy::difftype_t CPredictionCopy::CompareField( const typedescription_t *pField, const char *outvalue, const char *invalue, int count )
{
if ( Q_strcmp( outvalue, invalue ) )
{
return DIFFERS;
}
return IDENTICAL;
}
// ehandle
template<>
inline CPredictionCopy::difftype_t CPredictionCopy::CompareField( const typedescription_t *pField, const EHANDLE *outvalue, const EHANDLE *invalue, int count )
{
for ( int i = 0; i < count; i++ )
{
if ( outvalue[ i ].Get() == invalue[ i ].Get() )
continue;
return DIFFERS;
}
return IDENTICAL;
}
// color32
template<>
inline CPredictionCopy::difftype_t CPredictionCopy::CompareField( const typedescription_t *pField, const color32 *outvalue, const color32 *invalue, int count )
{
for ( int i = 0; i < count; i++ )
{
if ( outvalue[ i ] != invalue[ i ] )
return DIFFERS;
}
return IDENTICAL;
}
template< class T >
inline void CPredictionCopy::DescribeField( const datamap_t *pCurrentMap, const typedescription_t *pField, difftype_t difftype, const T *outvalue, const T *invalue, int count )
{
Assert( 0 );
}
// short
template<>
inline void CPredictionCopy::DescribeField( const datamap_t *pCurrentMap, const typedescription_t *pField, difftype_t difftype, const short *outvalue, const short *invalue, int count )
{
if ( difftype == DIFFERS )
{
int i = 0;
ReportFieldsDiffer( pCurrentMap, pField, "short differs (net %i pred %i) diff(%i)\n", (int)(invalue[i]), (int)(outvalue[i]), (int)(outvalue[i] - invalue[i]) );
}
OutputFieldDescription( pCurrentMap, pField, difftype, "short (%i)\n", (int)(outvalue[0]) );
}
// int
template<>
inline void CPredictionCopy::DescribeField( const datamap_t *pCurrentMap, const typedescription_t *pField, difftype_t difftype, const int *outvalue, const int *invalue, int count )
{
if ( difftype == DIFFERS )
{
int i = 0;
ReportFieldsDiffer( pCurrentMap, pField, "int differs (net %i pred %i) diff(%i)\n", invalue[i], outvalue[i], outvalue[i] - invalue[i] );
}
bool described = false;
if ( pField->flags & FTYPEDESC_MODELINDEX )
{
int modelindex = outvalue[0];
model_t const *m = modelinfo->GetModel( modelindex );
if ( m )
{
described = true;
char shortfile[ 512 ];
shortfile[ 0 ] = 0;
Q_FileBase( modelinfo->GetModelName( m ), shortfile, sizeof( shortfile ) );
OutputFieldDescription( pCurrentMap, pField, difftype, "integer (%i->%s)\n", outvalue[0], shortfile );
}
}
if ( !described )
{
OutputFieldDescription( pCurrentMap, pField, difftype, "integer (%i)\n", outvalue[0] );
}
}
// bool
template<>
inline void CPredictionCopy::DescribeField( const datamap_t *pCurrentMap, const typedescription_t *pField, difftype_t difftype, const bool *outvalue, const bool *invalue, int count )
{
if ( difftype == DIFFERS )
{
int i = 0;
ReportFieldsDiffer( pCurrentMap, pField, "bool differs (net %s pred %s)\n", (invalue[i]) ? "true" : "false", (outvalue[i]) ? "true" : "false" );
}
OutputFieldDescription( pCurrentMap, pField, difftype, "bool (%s)\n", (outvalue[0]) ? "true" : "false" );
}
template<>
inline void CPredictionCopy::DescribeField( const datamap_t *pCurrentMap, const typedescription_t *pField, difftype_t difftype, const float *outvalue, const float *invalue, int count )
{
if ( difftype == DIFFERS )
{
int i = 0;
ReportFieldsDiffer( pCurrentMap, pField, "float differs (net %f pred %f) diff(%f)\n", invalue[ i ], outvalue[ i ], outvalue[ i ] - invalue[ i ] );
}
OutputFieldDescription( pCurrentMap, pField, difftype, "float (%f)\n", outvalue[ 0 ] );
}
template<>
inline void CPredictionCopy::DescribeField( const datamap_t *pCurrentMap, const typedescription_t *pField, difftype_t difftype, const char *outstring, const char *instring, int count )
{
if ( difftype == DIFFERS )
{
ReportFieldsDiffer( pCurrentMap, pField, "string differs (net %s pred %s)\n", instring, outstring );
}
OutputFieldDescription( pCurrentMap, pField, difftype, "string (%s)\n", outstring );
}
template<>
inline void CPredictionCopy::DescribeField( const datamap_t *pCurrentMap, const typedescription_t *pField, difftype_t difftype, const Vector *outValue, const Vector *inValue, int count )
{
if ( difftype == DIFFERS )
{
int i = 0;
Vector delta = outValue[ i ] - inValue[ i ];
ReportFieldsDiffer( pCurrentMap, pField, "vec[] differs (1st diff) (net %f %f %f - pred %f %f %f) delta(%f %f %f)\n",
inValue[i].x, inValue[i].y, inValue[i].z,
outValue[i].x, outValue[i].y, outValue[i].z,
delta.x, delta.y, delta.z );
}
OutputFieldDescription( pCurrentMap, pField, difftype, "vector (%f %f %f)\n",
outValue[0].x, outValue[0].y, outValue[0].z );
}
template<>
inline void CPredictionCopy::DescribeField( const datamap_t *pCurrentMap, const typedescription_t *pField, difftype_t difftype, const Quaternion *outValue, const Quaternion *inValue, int count )
{
if ( difftype == DIFFERS )
{
int i = 0;
Quaternion delta;
for ( int j = 0; j < 4; j++ )
{
delta[i] = outValue[i][j] - inValue[i][j];
}
ReportFieldsDiffer( pCurrentMap, pField, "quaternion[] differs (1st diff) (net %f %f %f %f - pred %f %f %f %f) delta(%f %f %f %f)\n",
inValue[i].x, inValue[i].y, inValue[i].z, inValue[i].w,
outValue[i].x, outValue[i].y, outValue[i].z, outValue[i].w,
delta[0], delta[1], delta[2], delta[3] );
}
OutputFieldDescription( pCurrentMap, pField, difftype, "quaternion (%f %f %f %f)\n", outValue[0][0], outValue[0][1], outValue[0][2], outValue[3] );
}
template<>
inline void CPredictionCopy::DescribeField( const datamap_t *pCurrentMap, const typedescription_t *pField, difftype_t difftype, const EHANDLE *outvalue, EHANDLE const *invalue, int count )
{
if ( difftype == DIFFERS )
{
int i = 0;
ReportFieldsDiffer( pCurrentMap, pField, "EHandles differ (net) 0x%p (pred) 0x%p\n", (void const *)invalue[ i ].Get(), (void *)outvalue[ i ].Get() );
}
C_BaseEntity *ent = outvalue[0].Get();
if ( ent )
{
const char *classname = ent->GetClassname();
if ( !classname[0] )
{
classname = typeid( *ent ).name();
}
OutputFieldDescription( pCurrentMap, pField, difftype, "EHandle (0x%p->%s)", (void *)outvalue[ 0 ], classname );
}
else
{
OutputFieldDescription( pCurrentMap, pField, difftype, "EHandle (NULL)" );
}
}
// color32
template<>
inline void CPredictionCopy::DescribeField( const datamap_t *pCurrentMap, const typedescription_t *pField, difftype_t difftype, const color32 *outvalue, const color32 *invalue, int count )
{
if ( difftype == DIFFERS )
{
ReportFieldsDiffer( pCurrentMap, pField, "color differs (net %d %d %d %d pred %d %d %d %d)\n",
outvalue[ 0 ].r,
outvalue[ 0 ].g,
outvalue[ 0 ].b,
outvalue[ 0 ].a,
invalue[ 0 ].r,
invalue[ 0 ].g,
invalue[ 0 ].b,
invalue[ 0 ].a
);
}
OutputFieldDescription( pCurrentMap, pField, difftype, "color (%d %d %d %d)\n",
outvalue[ 0 ].r,
outvalue[ 0 ].g,
outvalue[ 0 ].b,
outvalue[ 0 ].a );
}
template<>
inline void CPredictionCopy::DescribeField( const datamap_t *pCurrentMap, const typedescription_t *pField, difftype_t difftype, const uint8 *outstring, const uint8 *instring, int count )
{
if ( difftype == DIFFERS )
{
ReportFieldsDiffer( pCurrentMap, pField, "byte differs (net %d pred %d)\n", int(instring[0]), int(outstring[0]) );
}
OutputFieldDescription( pCurrentMap, pField, difftype, "byte (%d)\n", int(outstring[0]) );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *fmt -
// ... -
//-----------------------------------------------------------------------------
void CPredictionCopy::ReportFieldsDiffer( const datamap_t *pCurrentMap, const typedescription_t *pField, const char *fmt, ... )
{
++m_nErrorCount;
if ( m_FieldCompareFunc )
return;
const char *fieldname = "empty";
const char *classname = "empty";
int flags = 0;
if ( pField )
{
flags = pField->flags;
fieldname = pField->fieldName ? pField->fieldName : "NULL";
classname = pCurrentMap->dataClassName;
}
va_list argptr;
char data[ 4096 ];
int len;
va_start(argptr, fmt);
len = Q_vsnprintf(data, sizeof( data ), fmt, argptr);
va_end(argptr);
bool bUseLongName = cl_pred_error_verbose.GetBool();
CUtlString longName;
for ( int i = 0; i < m_FieldStack.Count(); ++i )
{
const typedescription_t *top = m_FieldStack[ i ];
if ( !top )
continue;
if ( top->flags & FTYPEDESC_KEY )
bUseLongName = true;
longName += top->fieldName ? top->fieldName : "NULL";
longName += "/";
}
if ( bUseLongName )
{
Msg( "%2d (%d)%s%s::%s - %s",
m_nErrorCount,
m_nEntIndex,
longName.String(),
classname,
fieldname,
data );
}
else
{
Msg( "%2d (%d)%s::%s - %s",
m_nErrorCount,
m_nEntIndex,
classname,
fieldname,
data );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *fmt -
// ... -
//-----------------------------------------------------------------------------
void CPredictionCopy::OutputFieldDescription( const datamap_t *pCurrentMap, const typedescription_t *pField, difftype_t dt, const char *fmt, ... )
{
if ( !m_FieldCompareFunc )
return;
const char *fieldname = "empty";
const char *classname = "empty";
int flags = 0;
if ( pField )
{
flags = pField->flags;
fieldname = pField->fieldName ? pField->fieldName : "NULL";
classname = pCurrentMap->dataClassName;
}
va_list argptr;
char data[ 4096 ];
int len;
va_start(argptr, fmt);
len = Q_vsnprintf(data, sizeof( data ), fmt, argptr);
va_end(argptr);
bool isnetworked = ( flags & FTYPEDESC_INSENDTABLE ) ? true : false;
bool isnoterrorchecked = ( flags & FTYPEDESC_NOERRORCHECK ) ? true : false;
( *m_FieldCompareFunc )(
classname,
fieldname,
g_FieldTypes[ pField->fieldType ],
isnetworked,
isnoterrorchecked,
dt != IDENTICAL ? true : false,
dt == WITHINTOLERANCE ? true : false,
data
);
}
void CPredictionCopy::DescribeFields( const CUtlVector< const datamap_t * > &vecGroups, const datamap_t *pCurrentMap, int nPredictionCopyType )
{
int i;
int flags;
int fieldOffsetSrc;
int fieldOffsetDest;
int fieldSize;
const flattenedoffsets_t &flat = pCurrentMap->m_pOptimizedDataMap->m_Info[ nPredictionCopyType ].m_Flat;
int fieldCount = flat.m_Flattened.Count();
const typedescription_t * RESTRICT pField = &flat.m_Flattened[ 0 ];
PREFETCH360(pField, 0);
for ( i = 0; i < fieldCount; ++i, pField++ )
{
#if _X360
if ( !(i & 0xF) )
{
PREFETCH360(pField, 128);
}
#endif
flags = pField->flags;
int nFieldType = pField->fieldType;
const byte * RESTRICT pOutputData;
const byte * RESTRICT pInputData;
fieldOffsetDest = pField->flatOffset[ m_nSrcOffsetIndex ];
fieldOffsetSrc = pField->flatOffset[ m_nDestOffsetIndex ];
fieldSize = pField->fieldSize;
pOutputData = (m_pDest + fieldOffsetDest );
pInputData = (m_pSrc + fieldOffsetSrc );
const datamap_t *sourceGroup = pCurrentMap;
if ( pField->flatGroup >= 0 && pField->flatGroup < vecGroups.Count() )
{
sourceGroup = vecGroups[ pField->flatGroup ];
}
PREDICTIONCOPY_APPLY( ProcessField_Describe, nFieldType, sourceGroup, pField, pOutputData, pInputData, fieldSize );
}
}
//-----------------------------------------------------------------------------
// Purpose: static method
// Input : *fieldname -
// *dmap -
// Output : typedescription_t
//-----------------------------------------------------------------------------
// static method
const typedescription_t *CPredictionCopy::FindFlatFieldByName( const char *fieldname, const datamap_t *dmap )
{
PrepareDataMap( const_cast< datamap_t * >( dmap ) );
for ( int i = 0; i < PC_COPYTYPE_COUNT; ++i )
{
const flattenedoffsets_t &flat = dmap->m_pOptimizedDataMap->m_Info[ i ].m_Flat;
int c = flat.m_Flattened.Count();
for ( int j = 0; j < c; ++j )
{
const typedescription_t *td = &flat.m_Flattened[ j ];
if ( !Q_stricmp( td->fieldName, fieldname ) )
{
return td;
}
}
}
return NULL;
}
static ConVar pwatchent( "pwatchent", "-1", FCVAR_CHEAT, "Entity to watch for prediction system changes." );
static ConVar pwatchvar( "pwatchvar", "", FCVAR_CHEAT, "Entity variable to watch in prediction system for changes." );
//-----------------------------------------------------------------------------
// Purpose:
// Input : *fmt -
// ... -
//-----------------------------------------------------------------------------
void CPredictionCopy::WatchMsg( const typedescription_t *pField, const char *fmt, ... )
{
Assert( pField );
Assert( m_pOperation );
va_list argptr;
char data[ 4096 ];
int len;
va_start(argptr, fmt);
len = Q_vsnprintf(data, sizeof( data ), fmt, argptr);
va_end(argptr);
Msg( "%i %s %s : %s\n", gpGlobals->tickcount, m_pOperation, pField->fieldName, data );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *operation -
// entindex -
// *dmap -
//-----------------------------------------------------------------------------
void CPredictionCopy::DetermineWatchField( const char *operation, int entindex, const datamap_t *dmap )
{
m_pWatchField = NULL;
m_pOperation = operation;
if ( !m_pOperation || !m_pOperation[0] )
return;
int enttowatch = pwatchent.GetInt();
if ( enttowatch < 0 )
return;
if ( entindex != enttowatch )
return;
// See if they specified a field
if ( pwatchvar.GetString()[0] == 0 )
return;
m_pWatchField = CPredictionCopy::FindFlatFieldByName( pwatchvar.GetString(), dmap );
}
static void RemoveFieldsByName( char const *pchFieldName, CUtlVector< typedescription_t > &build )
{
// Don't start at final field, since it the one we just added with FTYPEDESC_OVERRIDE
for ( int i = build.Count() - 2; i >= 0 ; --i )
{
// Embedded field "offsets" can be the same as their first data field, so don't remove
if ( build[ i ].fieldType == FIELD_EMBEDDED )
continue;
if ( !Q_stricmp( build[ i ].fieldName, pchFieldName ) )
{
// Msg( "Removing %s %d due to override\n", build[ i ]->fieldName, build[ i ]->flatOffset[ TD_OFFSET_NORMAL ] );
build.Remove( i );
}
}
}
static void BuildGroupList_R( int nPredictionCopyType, int nGroup, const datamap_t *dmap, CUtlVector< const datamap_t * > &vecGroups )
{
// Descend to base classes first so FTYPEDESC_OVERRIDE can remove the previous ones
if ( dmap->baseMap )
{
BuildGroupList_R( nPredictionCopyType, nGroup + 1, dmap->baseMap, vecGroups );
}
vecGroups.AddToTail( dmap );
}
static void BuildFlattenedChains_R(
int nPredictionCopyType,
int &nMaxGroupSeen,
int nGroup,
datamap_t *dmap,
CUtlVector< typedescription_t > &build,
int nBaseOffset )
{
// Descend to base classes first so FTYPEDESC_OVERRIDE can remove the previous ones
if ( dmap->baseMap )
{
BuildFlattenedChains_R( nPredictionCopyType, nMaxGroupSeen, nGroup + 1, dmap->baseMap, build, nBaseOffset );
}
if ( nGroup > nMaxGroupSeen )
{
nMaxGroupSeen = nGroup;
}
int c = dmap->dataNumFields;
for ( int i = 0; i < c; i++ )
{
typedescription_t *pField = &dmap->dataDesc[ i ];
if ( pField->fieldType == FIELD_VOID )
continue;
bool bAdd = true;
if ( pField->fieldType != FIELD_EMBEDDED )
{
if ( pField->flags & FTYPEDESC_PRIVATE )
{
if ( pField->flags & FTYPEDESC_OVERRIDE )
{
// Find previous field targeting same offset
RemoveFieldsByName( pField->fieldName, build );
}
continue;
}
// For PC_NON_NETWORKED_ONLYs skip any fields that are present in the network send tables
if ( nPredictionCopyType == PC_NON_NETWORKED_ONLY && ( pField->flags & FTYPEDESC_INSENDTABLE ) )
{
bAdd = false;
}
// For PC_NETWORKED_ONLYs skip any fields that are not present in the network send tables
if ( nPredictionCopyType == PC_NETWORKED_ONLY && !( pField->flags & FTYPEDESC_INSENDTABLE ) )
{
bAdd = false;
}
}
else
{
bAdd = false;
}
pField->flatGroup = nGroup;
pField->flatOffset[ TD_OFFSET_NORMAL ] = nBaseOffset + pField->fieldOffset;
if ( bAdd )
{
build.AddToTail( *pField );
}
// Msg( "Visit %s offset %d\n", pField->fieldName, pField->flatOffset[ nPackType ] );
if ( pField->fieldType == FIELD_EMBEDDED )
{
AssertFatalMsg( !(pField->flags & FTYPEDESC_PTR ), ( "Prediction copy does not support FTYPEDESC_PTR(%d)", pField->fieldName ) );
BuildFlattenedChains_R( nPredictionCopyType, nMaxGroupSeen, nGroup, pField->td, build, pField->flatOffset[ TD_OFFSET_NORMAL ] );
}
if ( pField->flags & FTYPEDESC_OVERRIDE )
{
// Find previous field targeting same offset
RemoveFieldsByName( pField->fieldName, build );
}
}
}
static int __cdecl CompareFlattenedOffsets( const void *pv1, const void *pv2 )
{
const typedescription_t *td1 = (const typedescription_t *)pv1;
const typedescription_t *td2 = (const typedescription_t *)pv2;
if ( td1->flatOffset[ TD_OFFSET_NORMAL ] < td2->flatOffset[ TD_OFFSET_NORMAL ] )
return -1;
else if ( td1->flatOffset[ TD_OFFSET_NORMAL ] > td2->flatOffset[ TD_OFFSET_NORMAL ] )
return 1;
if ( td1->flatGroup < td2->flatGroup )
return -1;
else if ( td1->flatGroup > td2->flatGroup )
return 1;
return 0;
}
static int BuildPackedFlattenedOffsets( int nStartOffset, flattenedoffsets_t &flat )
{
int current_position = nStartOffset;
for ( int i = 0; i < flat.m_Flattened.Count(); ++i )
{
typedescription_t *field = &flat.m_Flattened[ i ];
switch ( field->fieldType )
{
default:
case FIELD_MODELINDEX:
case FIELD_MODELNAME:
case FIELD_SOUNDNAME:
case FIELD_TIME:
case FIELD_TICK:
case FIELD_CUSTOM:
case FIELD_CLASSPTR:
case FIELD_EDICT:
case FIELD_POSITION_VECTOR:
case FIELD_FUNCTION:
Assert( 0 );
break;
case FIELD_EMBEDDED:
{
Error( "Not expecting FIELD_EMBEDDED in flattened list (%s)", field->fieldName );
}
break;
case FIELD_FLOAT:
case FIELD_VECTOR:
case FIELD_QUATERNION:
case FIELD_INTEGER:
case FIELD_EHANDLE:
case FIELD_COLOR32:
case FIELD_VMATRIX:
case FIELD_VECTOR4D:
{
current_position = ALIGN_VALUE( current_position, 4 );
field->flatOffset[ TD_OFFSET_PACKED ] = current_position;
current_position += field->fieldSizeInBytes;
}
break;
case FIELD_SHORT:
{
current_position = ALIGN_VALUE( current_position, 2 );
field->flatOffset[ TD_OFFSET_PACKED ] = current_position;
current_position += field->fieldSizeInBytes;
}
break;
case FIELD_STRING:
case FIELD_BOOLEAN:
case FIELD_CHARACTER:
{
field->flatOffset[ TD_OFFSET_PACKED ] = current_position;
current_position += field->fieldSizeInBytes;
}
break;
case FIELD_VOID:
{
// Special case, just skip it
}
break;
}
// Msg( "%s packed to %d size %d\n", field->fieldName, field->flatOffset[ TD_OFFSET_PACKED ], field->fieldSizeInBytes );
}
flat.m_nPackedStartOffset = nStartOffset;
flat.m_nPackedSize = current_position - nStartOffset;
current_position = ALIGN_VALUE( current_position, 4 );
return current_position;
}
static void BuildDataRuns( datamap_t *dmap )
{
for ( int pc = 0; pc < PC_COPYTYPE_COUNT; ++pc )
{
datamapinfo_t &info = dmap->m_pOptimizedDataMap->m_Info[ pc ];
datacopyruns_t *runs = &info.m_CopyRuns;
Assert( !info.m_CopyRuns.m_vecRuns.Count() );
const flattenedoffsets_t &flat = info.m_Flat;
int nRunStartField = 0;
int nCurrentRunStartOffset = 0;
int nLastFieldEndOffset = 0;
CUtlVector< datarun_t > &vecRuns = runs->m_vecRuns;
int i;
for ( i = 0; i < flat.m_Flattened.Count(); ++i )
{
const typedescription_t *td = &flat.m_Flattened[ i ];
int offset = td->flatOffset[ TD_OFFSET_NORMAL ];
if ( i == 0 )
{
nRunStartField = i;
nLastFieldEndOffset = offset;
nCurrentRunStartOffset = offset;
}
if ( td->fieldType == FIELD_EMBEDDED )
{
Assert( 0 );
continue;
}
if ( nLastFieldEndOffset != offset )
{
datarun_t run;
run.m_nStartFlatField = nRunStartField;
run.m_nEndFlatField = i;
Assert( nCurrentRunStartOffset == flat.m_Flattened[ nRunStartField ].flatOffset[ TD_OFFSET_NORMAL ] );
run.m_nStartOffset[ TD_OFFSET_NORMAL ] = nCurrentRunStartOffset;
run.m_nStartOffset[ TD_OFFSET_PACKED ] = flat.m_Flattened[ nRunStartField ].flatOffset[ TD_OFFSET_PACKED ];
run.m_nLength = nLastFieldEndOffset - nCurrentRunStartOffset;
#ifdef _X360
if ( vecRuns.Count() > 0 )
{
for ( int td = 0; td < TD_OFFSET_COUNT; ++td )
{
vecRuns[ vecRuns.Count() - 1 ].m_nPrefetchOffset[ td ] = run.m_nStartOffset[ td ];
}
}
#endif
vecRuns.AddToTail( run );
nRunStartField = i;
nCurrentRunStartOffset = offset;
}
nLastFieldEndOffset = td->flatOffset[ TD_OFFSET_NORMAL ] + td->fieldSizeInBytes;
}
// Close off last run
if ( nLastFieldEndOffset != nCurrentRunStartOffset )
{
datarun_t run;
run.m_nStartFlatField = nRunStartField;
run.m_nEndFlatField = i - 1;
Assert( nCurrentRunStartOffset == flat.m_Flattened[ nRunStartField ].flatOffset[ TD_OFFSET_NORMAL ] );
run.m_nStartOffset[ TD_OFFSET_NORMAL ] = nCurrentRunStartOffset;
run.m_nStartOffset[ TD_OFFSET_PACKED ] = flat.m_Flattened[ nRunStartField ].flatOffset[ TD_OFFSET_PACKED ];
run.m_nLength = nLastFieldEndOffset - nCurrentRunStartOffset;
#ifdef _X360
if ( vecRuns.Count() > 0 )
{
for ( int td = 0; td < TD_OFFSET_COUNT; ++td )
{
vecRuns[ vecRuns.Count() - 1 ].m_nPrefetchOffset[ td ] = run.m_nStartOffset[ td ];
}
}
#endif
vecRuns.AddToTail( run );
}
}
}
static void BuildFlattenedChains( datamap_t *dmap )
{
if ( dmap->m_pOptimizedDataMap )
return;
dmap->m_pOptimizedDataMap = g_OptimizedDataMapPool.AllocZero();
int nMaxGroupSeen[ PC_COPYTYPE_COUNT ] = { 0 };
for ( int nPredictionCopyType = 0; nPredictionCopyType < PC_COPYTYPE_COUNT; ++nPredictionCopyType )
{
CUtlVector< typedescription_t > &build = dmap->m_pOptimizedDataMap->m_Info[ nPredictionCopyType ].m_Flat.m_Flattened;
int nGroupCount = 0;
int nBaseOffset = 0;
BuildFlattenedChains_R(
nPredictionCopyType,
nMaxGroupSeen[ nPredictionCopyType ],
nGroupCount,
dmap,
build,
nBaseOffset );
// Msg( "%d == %d entries\n", nPredictionCopyType, build[ nPredictionCopyType ].Count() );
}
for ( int nPredictionCopyType = 0; nPredictionCopyType < PC_COPYTYPE_COUNT; ++nPredictionCopyType )
{
int nMaxGroup = nMaxGroupSeen[ nPredictionCopyType ];
CUtlVector< typedescription_t > &build = dmap->m_pOptimizedDataMap->m_Info[ nPredictionCopyType ].m_Flat.m_Flattened;
for ( int i = 0; i < build.Count(); ++i )
{
typedescription_t *field = &build[ i ];
field->flatGroup = nMaxGroup - field->flatGroup;
}
}
int nPackedDataStartOffset = 0;
for ( int nPredictionCopyType = 0; nPredictionCopyType < PC_COPYTYPE_COUNT; ++nPredictionCopyType )
{
flattenedoffsets_t &flat = dmap->m_pOptimizedDataMap->m_Info[ nPredictionCopyType ].m_Flat;
qsort( flat.m_Flattened.Base(), flat.m_Flattened.Count(), sizeof( typedescription_t ), (int (__cdecl *)(const void *, const void *))CompareFlattenedOffsets );
nPackedDataStartOffset = BuildPackedFlattenedOffsets( nPackedDataStartOffset, flat );
dmap->m_nPackedSize = nPackedDataStartOffset;
}
BuildDataRuns( dmap );
}
const tokenset_t< int > s_PredCopyType[] =
{
{ "Non-Sendtable" , PC_NON_NETWORKED_ONLY },
{ "SendTable" , PC_NETWORKED_ONLY },
{ "Everything" , PC_EVERYTHING },
{ NULL, -1 }
};
const tokenset_t< int > s_PredPackType[] =
{
{ "Normal" , TD_OFFSET_NORMAL },
{ "Packed" , TD_OFFSET_PACKED },
{ NULL, -1 }
};
static void DescribeRuns( const datamap_t *dmap, int nPredictionCopyType, int packType )
{
const datacopyruns_t &runs = dmap->m_pOptimizedDataMap->m_Info[ nPredictionCopyType ].m_CopyRuns;
const flattenedoffsets_t &flat = dmap->m_pOptimizedDataMap->m_Info[ nPredictionCopyType ].m_Flat;
Msg( " Runs for copy type: %s, packing: %s\n", s_PredCopyType->GetNameByToken( nPredictionCopyType ), s_PredPackType->GetNameByToken( packType ) );
for ( int i = 0; i < runs.m_vecRuns.Count(); ++i )
{
const datarun_t *run = &runs.m_vecRuns[ i ];
Msg( " %5d: %5d -> %5d (%5d bytes): %s to %s\n",
i, run->m_nStartOffset[ packType ], run->m_nStartOffset[ packType ] + run->m_nLength, run->m_nLength,
flat.m_Flattened[ run->m_nStartFlatField ].fieldName,
flat.m_Flattened[ run->m_nEndFlatField ].fieldName );
}
}
static void DescribeFlattenedList( const datamap_t *dmap, int nPredictionCopyType, int packType )
{
char const *prefix = dmap->dataClassName;
Msg( "->Sorted %s for copy type: %s, packing: %s\n", prefix, s_PredCopyType->GetNameByToken( nPredictionCopyType ), s_PredPackType->GetNameByToken( packType ) );
// Now dump the flattened list
int nLastFieldEnd = 0;
int nCurrentRunStartOffset = 0;
int nRuns = 0;
int nBytesInRuns = 0;
int offset = 0;
const flattenedoffsets_t &list = dmap->m_pOptimizedDataMap->m_Info[ nPredictionCopyType ].m_Flat;
for ( int i = 0; i < list.m_Flattened.Count(); ++i )
{
const typedescription_t *td = &list.m_Flattened[ i ];
offset = td->flatOffset[ packType ];
if ( i == 0 )
{
nLastFieldEnd = offset;
nCurrentRunStartOffset = offset;
}
if ( td->fieldType != FIELD_EMBEDDED )
{
if ( nLastFieldEnd != offset )
{
Msg( " gap of %d bytes [last run %d]\n", offset - nLastFieldEnd, ( nLastFieldEnd - nCurrentRunStartOffset ) );
++nRuns;
nBytesInRuns += ( nLastFieldEnd - nCurrentRunStartOffset );
nCurrentRunStartOffset = offset;
}
nLastFieldEnd = td->flatOffset[ packType ] + td->fieldSizeInBytes;
}
Msg( "group %s [flat %d] [sort %d] %d bytes\n",
td->fieldName,
td->flatOffset[ packType ],
td->flatOffset[ TD_OFFSET_NORMAL ],
td->fieldSizeInBytes );
}
// Close off last run
if ( nLastFieldEnd != nCurrentRunStartOffset )
{
Msg( "Last run %d\n", nLastFieldEnd - nCurrentRunStartOffset );
++nRuns;
nBytesInRuns += ( nLastFieldEnd - nCurrentRunStartOffset );
}
if ( nRuns > 0 )
{
float flAvgBytesPerRun = (float)nBytesInRuns/(float)nRuns;
Msg( "%d runs, %d bytes in runs, %f avg bytes per run\n",
nRuns, nBytesInRuns, flAvgBytesPerRun );
}
Msg( "->\n" );
DescribeRuns( dmap, nPredictionCopyType, packType );
}
void CPredictionCopy::CopyFlatFieldsUsingRuns( const datamap_t *pCurrentMap, int nPredictionCopyType )
{
int fieldOffsetSrc;
int fieldOffsetDest;
byte * RESTRICT pOutputData;
const byte * RESTRICT pInputData;
const datacopyruns_t &runs = pCurrentMap->m_pOptimizedDataMap->m_Info[ nPredictionCopyType ].m_CopyRuns;
byte * RESTRICT pDest = ( byte * RESTRICT )m_pDest;
const byte * RESTRICT pSrc = (const byte * RESTRICT)m_pSrc;
PREFETCH360( pSrc, 0 );
PREFETCH360( pDest, 0 );
int c = runs.m_vecRuns.Count();
for ( int i = 0; i < c; ++i )
{
const datarun_t * RESTRICT run = &runs.m_vecRuns[ i ];
fieldOffsetDest = run->m_nStartOffset[ m_nDestOffsetIndex ];
fieldOffsetSrc = run->m_nStartOffset[ m_nSrcOffsetIndex ];
pOutputData = pDest + fieldOffsetDest;
pInputData = pSrc + fieldOffsetSrc;
#ifdef _X360
PREFETCH360( pDest + run->m_nPrefetchOffset[ m_nDestOffsetIndex ], 0 );
PREFETCH360( pSrc + run->m_nPrefetchOffset[ m_nSrcOffsetIndex ], 0 );
#endif
Q_memcpy( pOutputData, pInputData, run->m_nLength );
}
}
void CPredictionCopy::CopyFlatFields( const datamap_t *pCurrentMap, int nPredictionCopyType )
{
int fieldOffsetSrc;
int fieldOffsetDest;
byte * RESTRICT pOutputData;
const byte * RESTRICT pInputData;
byte * RESTRICT pDest = (byte * RESTRICT)m_pDest;
const byte * RESTRICT pSrc = (const byte * RESTRICT)m_pSrc;
PREFETCH360( pSrc, 0 );
PREFETCH360( pDest, 0 );
const flattenedoffsets_t &flat = pCurrentMap->m_pOptimizedDataMap->m_Info[ nPredictionCopyType ].m_Flat;
int fieldCount = flat.m_Flattened.Count();
for ( int i = 0; i < fieldCount; ++i )
{
const typedescription_t *pField = &flat.m_Flattened[ i ];
fieldOffsetDest = pField->flatOffset[ m_nDestOffsetIndex ];
fieldOffsetSrc = pField->flatOffset[ m_nSrcOffsetIndex ];
pOutputData = pDest + fieldOffsetDest;
PREFETCH360( pOutputData, 0 );
pInputData = pSrc + fieldOffsetSrc;
PREFETCH360( pInputData, 0 );
Q_memcpy( pOutputData, pInputData, pField->fieldSizeInBytes );
}
}
void CPredictionCopy::ErrorCheckFlatFields_NoSpew( const datamap_t *pCurrentMap, int nPredictionCopyType )
{
int i;
int flags;
int fieldOffsetSrc;
int fieldOffsetDest;
int fieldSize;
const flattenedoffsets_t &flat = pCurrentMap->m_pOptimizedDataMap->m_Info[ nPredictionCopyType ].m_Flat;
const typedescription_t *pBase = &flat.m_Flattened[ 0 ];
PREFETCH360( pBase, 0 );
int fieldCount = flat.m_Flattened.Count();
const byte * RESTRICT pDest = (const byte * RESTRICT)m_pDest;
const byte * RESTRICT pSrc = (const byte * RESTRICT)m_pSrc;
const byte *pOutputData;
const byte *pInputData;
PREFETCH360( pSrc, 0 );
PREFETCH360( pDest, 0 );
for ( i = 0; i < fieldCount && !m_nErrorCount; ++i )
{
const typedescription_t * RESTRICT pField = &pBase[ i ];
flags = pField->flags;
if ( flags & FTYPEDESC_NOERRORCHECK )
continue;
#if _X360
if ( !(i & 0xF) )
{
PREFETCH360(pField, 128);
}
#endif
fieldOffsetDest = pField->flatOffset[ m_nDestOffsetIndex ];
fieldOffsetSrc = pField->flatOffset[ m_nSrcOffsetIndex ];
pOutputData = pDest + fieldOffsetDest;
PREFETCH360( pOutputData, 0 );
pInputData = pSrc + fieldOffsetSrc;
PREFETCH360( pInputData, 0 );
fieldSize = pField->fieldSize;
int nFieldType = pField->fieldType;
PREDICTIONCOPY_APPLY( ProcessField_Compare_NoSpew, nFieldType, pCurrentMap, pField, pOutputData, pInputData, fieldSize );
}
}
void CPredictionCopy::ErrorCheckFlatFields_Spew( const datamap_t *pCurrentMap, int nPredictionCopyType )
{
int i;
int flags;
int fieldOffsetSrc;
int fieldOffsetDest;
int fieldSize;
const flattenedoffsets_t &flat = pCurrentMap->m_pOptimizedDataMap->m_Info[ nPredictionCopyType ].m_Flat;
const typedescription_t *pBase = &flat.m_Flattened[ 0 ];
PREFETCH360( pBase, 0 );
int fieldCount = flat.m_Flattened.Count();
const byte * RESTRICT pDest = m_pDest;
const byte * RESTRICT pSrc = m_pSrc;
const byte *pOutputData;
const byte *pInputData;
PREFETCH360( pSrc, 0 );
PREFETCH360( pDest, 0 );
for ( i = 0; i < fieldCount ; ++i )
{
const typedescription_t * RESTRICT pField = &pBase[ i ];
flags = pField->flags;
if ( flags & FTYPEDESC_NOERRORCHECK )
continue;
#if _X360
if ( !(i & 0xF) )
{
PREFETCH360(pField, 128);
}
#endif
fieldOffsetDest = pField->flatOffset[ m_nDestOffsetIndex ];
fieldOffsetSrc = pField->flatOffset[ m_nSrcOffsetIndex ];
pOutputData = pDest + fieldOffsetDest;
PREFETCH360( pOutputData, 0 );
pInputData = pSrc + fieldOffsetSrc;
PREFETCH360( pInputData, 0 );
fieldSize = pField->fieldSize;
flags = pField->flags;
int nFieldType = pField->fieldType;
PREDICTIONCOPY_APPLY( ProcessField_Compare_Spew, nFieldType, pCurrentMap, pField, pOutputData, pInputData, fieldSize );
}
}
bool CPredictionCopy::PrepareDataMap( datamap_t *dmap )
{
bool bPerformedPrepare = false;
if ( dmap && !dmap->m_pOptimizedDataMap )
{
bPerformedPrepare = true;
BuildFlattenedChains( dmap );
dmap = dmap->baseMap;
}
return bPerformedPrepare;
}
CON_COMMAND( cl_predictioncopy_describe, "Describe datamap_t for entindex" )
{
if ( args.ArgC() <= 1 )
{
Msg( "Usage: %s <entindex>", args[ 0 ] );
return;
}
int entindex = Q_atoi( args[ 1 ] );
C_BaseEntity *ent = C_BaseEntity::Instance( entindex );
if ( !ent )
{
Msg( "cl_predictioncopy_describe: no such entity %d\n", entindex );
return;
}
datamap_t *dmap = ent->GetPredDescMap();
if ( !dmap )
{
return;
}
CPredictionCopy::PrepareDataMap( dmap );
for ( int nPredictionCopyType = 0; nPredictionCopyType < PC_COPYTYPE_COUNT; ++nPredictionCopyType )
{
//for ( int i = 0; i < TD_OFFSET_COUNT; ++i )
{
DescribeFlattenedList( dmap, nPredictionCopyType, 0 );
}
}
}
// 0 PC_NON_NETWORKED_ONLY = (1<<0) or (1)
// 1 PC_NETWORKED_ONLY = (1<<1) or (2)
// 2 PC_EVERYTHING = ( PC_NON_NETWORKED_ONLY | PC_NETWORKED_ONLY ) or 3
// So for these three options, we just take the type and add one!!!
FORCEINLINE int ComputeTypeMask( int nType )
{
return nType + 1;
}
#if 0 // Enable this for perf testing
static ConVar cl_predictioncopy_runs( "cl_predictioncopy_runs", "1" );
static ConVar cl_predictioncopy_repeats( "cl_predictioncopy_repeats", "1" );
void CPredictionCopy::TransferDataCopyOnly( datamap_t *dmap )
{
int repeat = cl_predictioncopy_repeats.GetInt();
for ( int k = 0; k < repeat; ++k )
{
int types = ComputeTypeMask( m_nType );
for ( int i = 0; i < PC_COPYTYPE_COUNT; ++i )
{
if ( types & (1<<i) )
{
if ( !cl_predictioncopy_runs.GetBool() )
{
CopyFlatFields( dmap, i );
}
else
{
CopyFlatFieldsUsingRuns( dmap, i );
}
}
}
}
}
#else
void CPredictionCopy::TransferDataCopyOnly( const datamap_t *dmap )
{
int types = ComputeTypeMask( m_nType );
for ( int i = 0; i < PC_COPYTYPE_COUNT; ++i )
{
if ( types & (1<<i) )
{
CopyFlatFieldsUsingRuns( dmap, i );
}
}
}
#endif
// Stop at first error
void CPredictionCopy::TransferDataErrorCheckNoSpew( char const *pchOperation, const datamap_t *dmap )
{
int types = ComputeTypeMask( m_nType );
for ( int i = 0; i < PC_COPYTYPE_COUNT && !m_nErrorCount; ++i )
{
if ( types & (1<<i) )
{
ErrorCheckFlatFields_NoSpew( dmap, i );
}
}
}
void CPredictionCopy::TransferDataErrorCheckSpew( char const *pchOperation, const datamap_t *dmap )
{
int types = ComputeTypeMask( m_nType );
for ( int i = 0; i < PC_COPYTYPE_COUNT; ++i )
{
if ( types & (1<<i) )
{
ErrorCheckFlatFields_Spew( dmap, i );
}
}
}
void CPredictionCopy::TransferDataDescribe( char const *pchOperation, const datamap_t *dmap )
{
// Copy from here first, then base classes
int types = ComputeTypeMask( m_nType );
for ( int i = 0; i < PC_COPYTYPE_COUNT; ++i )
{
if ( types & (1<<i) )
{
CUtlVector< const datamap_t * > vecGroups;
int nGroup = 0;
BuildGroupList_R( i, nGroup, dmap, vecGroups );
DescribeFields( vecGroups, dmap, i );
}
}
}
int CPredictionCopy::TransferData( const char *operation, int entindex, datamap_t *dmap )
{
m_nEntIndex = entindex;
PrepareDataMap( dmap );
switch ( m_OpType )
{
default:
Assert( 0 );
case TRANSFERDATA_COPYONLY: // Data copying only (uses runs)
{
// Watch is based on "destination" of any write operation
DetermineWatchField( operation, entindex, dmap );
TransferDataCopyOnly( dmap );
}
break;
case TRANSFERDATA_ERRORCHECK_NOSPEW: // Checks for errors, returns after first error found
{
TransferDataErrorCheckNoSpew( operation, dmap );
}
break;
case TRANSFERDATA_ERRORCHECK_SPEW: // checks for errors, reports all errors to console
{
TransferDataErrorCheckSpew( operation, dmap );
}
break;
case TRANSFERDATA_ERRORCHECK_DESCRIBE:
{
TransferDataDescribe( operation, dmap );
}
break;
}
if ( m_pWatchField )
{
// Watch is based on "destination" of any write operation
DumpWatchField( m_pWatchField, m_pDest + m_pWatchField->flatOffset[ m_nDestOffsetIndex ], m_pWatchField->fieldSize );
}
return m_nErrorCount;
}
#endif