670 lines
17 KiB
C++
670 lines
17 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
|
|
#include "dt.h"
|
|
#include "dt_recv_eng.h"
|
|
#include "dt_encode.h"
|
|
#include "dt_instrumentation.h"
|
|
#include "dt_stack.h"
|
|
#include "utllinkedlist.h"
|
|
#include "tier0/dbg.h"
|
|
#include "dt_recv_decoder.h"
|
|
#include "tier1/strtools.h"
|
|
#include "tier0/icommandline.h"
|
|
#include "dt_common_eng.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
|
|
class CClientSendTable;
|
|
|
|
|
|
// Testing out this pattern.. you can write simple code blocks inside of
|
|
// codeToRun. The thing that sucks is that you can't access your function's
|
|
// local variables inside of codeToRun.
|
|
//
|
|
// If it used an iterator class, it could access local function variables,
|
|
// but the iterator class might be more trouble than it's worth.
|
|
#define FOR_EACH_PROP_R( TableType, pTablePointer, tableCode, propCode ) \
|
|
class CPropVisitor \
|
|
{ \
|
|
public: \
|
|
static void Visit_R( TableType *pTable ) \
|
|
{ \
|
|
tableCode; \
|
|
\
|
|
for ( int i=0; i < pTable->GetNumProps(); i++ ) \
|
|
{ \
|
|
TableType::PropType *pProp = pTable->GetProp( i ); \
|
|
\
|
|
propCode; \
|
|
\
|
|
if ( pProp->GetType() == DPT_DataTable ) \
|
|
Visit_R( pProp->GetDataTable() ); \
|
|
} \
|
|
} \
|
|
}; \
|
|
CPropVisitor::Visit_R( pTablePointer );
|
|
|
|
#define SENDPROP_VISIT( pTablePointer, tableCode, propCode ) FOR_EACH_PROP_R( SendTable, pTablePointer, tableCode, propCode )
|
|
#define RECVPROP_VISIT( pTablePointer, tableCode, propCode ) FOR_EACH_PROP_R( RecvTable, pTablePointer, tableCode, propCode )
|
|
#define SETUP_VISIT() class CDummyClass {} // Workaround for parser bug in VC7.1
|
|
|
|
// ------------------------------------------------------------------------------------ //
|
|
// Globals.
|
|
// ------------------------------------------------------------------------------------ //
|
|
|
|
CUtlLinkedList< RecvTable*, unsigned short > g_RecvTables;
|
|
CUtlLinkedList< CRecvDecoder *, unsigned short > g_RecvDecoders;
|
|
CUtlLinkedList< CClientSendTable*, unsigned short > g_ClientSendTables;
|
|
|
|
int g_nPropsDecoded = 0;
|
|
|
|
|
|
// ------------------------------------------------------------------------------------ //
|
|
// Static helper functions.
|
|
// ------------------------------------------------------------------------------------ //
|
|
|
|
RecvTable* FindRecvTable( const char *pName )
|
|
{
|
|
FOR_EACH_LL( g_RecvTables, i )
|
|
{
|
|
if ( stricmp( g_RecvTables[i]->GetName(), pName ) == 0 )
|
|
return g_RecvTables[i];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
static CClientSendTable* FindClientSendTable( const char *pName )
|
|
{
|
|
FOR_EACH_LL( g_ClientSendTables, i )
|
|
{
|
|
CClientSendTable *pTable = g_ClientSendTables[i];
|
|
|
|
if ( stricmp( pTable->GetName(), pName ) == 0 )
|
|
return pTable;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
// Find all child datatable properties for the send tables.
|
|
bool SetupClientSendTableHierarchy()
|
|
{
|
|
FOR_EACH_LL( g_ClientSendTables, iClientTable )
|
|
{
|
|
CClientSendTable *pTable = g_ClientSendTables[iClientTable];
|
|
|
|
// For each datatable property, find the table it references.
|
|
for ( int iProp=0; iProp < pTable->GetNumProps(); iProp++ )
|
|
{
|
|
CClientSendProp *pClientProp = pTable->GetClientProp( iProp );
|
|
SendProp *pProp = &pTable->m_SendTable.m_pProps[iProp];
|
|
|
|
if ( pProp->m_Type == DPT_DataTable )
|
|
{
|
|
const char *pTableName = pClientProp->GetTableName();
|
|
ErrorIfNot( pTableName,
|
|
("SetupClientSendTableHierarchy: missing table name for prop '%s'.", pProp->GetName())
|
|
);
|
|
|
|
CClientSendTable *pChild = FindClientSendTable( pTableName );
|
|
if ( !pChild )
|
|
{
|
|
DataTable_Warning( "SetupClientSendTableHierarchy: missing SendTable '%s' (referenced by '%s').\n", pTableName, pTable->GetName() );
|
|
return false;
|
|
}
|
|
|
|
pProp->SetDataTable( &pChild->m_SendTable );
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
static RecvProp* FindRecvProp( RecvTable *pTable, const char *pName )
|
|
{
|
|
for ( int i=0; i < pTable->GetNumProps(); i++ )
|
|
{
|
|
RecvProp *pProp = pTable->GetProp( i );
|
|
|
|
if ( stricmp( pProp->GetName(), pName ) == 0 )
|
|
return pProp;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
// See if the RecvProp is fit to receive the SendProp's data.
|
|
bool CompareRecvPropToSendProp( const RecvProp *pRecvProp, const SendProp *pSendProp )
|
|
{
|
|
while ( 1 )
|
|
{
|
|
ErrorIfNot( pRecvProp && pSendProp,
|
|
("CompareRecvPropToSendProp: missing a property.")
|
|
);
|
|
|
|
if ( pRecvProp->GetType() != pSendProp->GetType() || pRecvProp->IsInsideArray() != pSendProp->IsInsideArray() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if ( pRecvProp->GetType() == DPT_Array )
|
|
{
|
|
if ( pRecvProp->GetNumElements() != pSendProp->GetNumElements() )
|
|
return false;
|
|
|
|
pRecvProp = pRecvProp->GetArrayProp();
|
|
pSendProp = pSendProp->GetArrayProp();
|
|
}
|
|
else
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
struct MatchingProp_t
|
|
{
|
|
SendProp *m_pProp;
|
|
RecvProp *m_pMatchingRecvProp;
|
|
|
|
static bool LessFunc( const MatchingProp_t& lhs, const MatchingProp_t& rhs )
|
|
{
|
|
return lhs.m_pProp < rhs.m_pProp;
|
|
}
|
|
};
|
|
|
|
static bool MatchRecvPropsToSendProps_R( CUtlRBTree< MatchingProp_t, unsigned short >& lookup, char const *sendTableName, SendTable *pSendTable, RecvTable *pRecvTable, bool bAllowMismatches, bool *pAnyMismatches )
|
|
{
|
|
for ( int i=0; i < pSendTable->m_nProps; i++ )
|
|
{
|
|
SendProp *pSendProp = &pSendTable->m_pProps[i];
|
|
|
|
if ( pSendProp->IsExcludeProp() || pSendProp->IsInsideArray() )
|
|
continue;
|
|
|
|
// Find a RecvProp by the same name and type.
|
|
RecvProp *pRecvProp = 0;
|
|
if ( pRecvTable )
|
|
pRecvProp = FindRecvProp( pRecvTable, pSendProp->GetName() );
|
|
|
|
if ( pRecvProp )
|
|
{
|
|
if ( !CompareRecvPropToSendProp( pRecvProp, pSendProp ) )
|
|
{
|
|
Warning( "RecvProp type doesn't match server type for %s/%s\n", pSendTable->GetName(), pSendProp->GetName() );
|
|
return false;
|
|
}
|
|
|
|
MatchingProp_t info;
|
|
info.m_pProp = pSendProp;
|
|
info.m_pMatchingRecvProp = pRecvProp;
|
|
|
|
lookup.Insert( info );
|
|
}
|
|
else
|
|
{
|
|
if ( pAnyMismatches )
|
|
{
|
|
*pAnyMismatches = true;
|
|
}
|
|
|
|
Warning( "Missing RecvProp for %s - %s/%s\n", sendTableName, pSendTable->GetName(), pSendProp->GetName() );
|
|
if ( !bAllowMismatches )
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Recurse.
|
|
if ( pSendProp->GetType() == DPT_DataTable )
|
|
{
|
|
if ( !MatchRecvPropsToSendProps_R( lookup, sendTableName, pSendProp->GetDataTable(), FindRecvTable( pSendProp->GetDataTable()->m_pNetTableName ), bAllowMismatches, pAnyMismatches ) )
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------------------------ //
|
|
// Interface functions.
|
|
// ------------------------------------------------------------------------------------ //
|
|
bool RecvTable_Init( RecvTable **pTables, int nTables )
|
|
{
|
|
SETUP_VISIT();
|
|
|
|
for ( int i=0; i < nTables; i++ )
|
|
{
|
|
RECVPROP_VISIT( pTables[i],
|
|
{
|
|
if ( pTable->IsInMainList() )
|
|
return;
|
|
|
|
// Shouldn't have a decoder yet.
|
|
ErrorIfNot( !pTable->m_pDecoder,
|
|
("RecvTable_Init: table '%s' has a decoder already.", pTable->GetName()));
|
|
|
|
pTable->SetInMainList( true );
|
|
g_RecvTables.AddToTail( pTable );
|
|
},
|
|
|
|
{}
|
|
);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void RecvTable_Term( bool clearall /*= true*/ )
|
|
{
|
|
DTI_Term();
|
|
|
|
SETUP_VISIT();
|
|
|
|
FOR_EACH_LL( g_RecvTables, i )
|
|
{
|
|
RECVPROP_VISIT( g_RecvTables[i],
|
|
{
|
|
if ( !pTable->IsInMainList() )
|
|
return;
|
|
|
|
pTable->SetInMainList( false );
|
|
pTable->m_pDecoder = 0;
|
|
},
|
|
|
|
{}
|
|
);
|
|
}
|
|
|
|
if ( clearall )
|
|
{
|
|
g_RecvTables.Purge();
|
|
}
|
|
g_RecvDecoders.PurgeAndDeleteElements();
|
|
g_ClientSendTables.PurgeAndDeleteElements();
|
|
}
|
|
|
|
void RecvTable_FreeSendTable( SendTable *pTable )
|
|
{
|
|
for ( int iProp=0; iProp < pTable->m_nProps; iProp++ )
|
|
{
|
|
SendProp *pProp = &pTable->m_pProps[iProp];
|
|
|
|
delete [] pProp->m_pVarName;
|
|
|
|
if ( pProp->m_pExcludeDTName )
|
|
delete [] pProp->m_pExcludeDTName;
|
|
}
|
|
|
|
if ( pTable->m_pProps )
|
|
delete [] pTable->m_pProps;
|
|
|
|
delete pTable;
|
|
}
|
|
|
|
|
|
SendTable *RecvTable_ReadInfos( bf_read *pBuf, int nDemoProtocol )
|
|
{
|
|
SendTable *pTable = new SendTable;
|
|
|
|
pTable->m_pNetTableName = pBuf->ReadAndAllocateString();
|
|
|
|
// Read the property list.
|
|
pTable->m_nProps = pBuf->ReadUBitLong( PROPINFOBITS_NUMPROPS );
|
|
pTable->m_pProps = pTable->m_nProps ? new SendProp[ pTable->m_nProps ] : NULL;
|
|
|
|
for ( int iProp=0; iProp < pTable->m_nProps; iProp++ )
|
|
{
|
|
SendProp *pProp = &pTable->m_pProps[iProp];
|
|
|
|
pProp->m_Type = (SendPropType)pBuf->ReadUBitLong( PROPINFOBITS_TYPE );
|
|
pProp->m_pVarName = pBuf->ReadAndAllocateString();
|
|
|
|
int nFlagsBits = PROPINFOBITS_FLAGS;
|
|
|
|
// HACK to playback old demos. SPROP_NUMFLAGBITS was 11, now 13
|
|
// old nDemoProtocol was 2
|
|
if ( nDemoProtocol == 2 )
|
|
{
|
|
nFlagsBits = 11;
|
|
}
|
|
|
|
pProp->SetFlags( pBuf->ReadUBitLong( nFlagsBits ) );
|
|
|
|
if ( pProp->m_Type == DPT_DataTable )
|
|
{
|
|
pProp->m_pExcludeDTName = pBuf->ReadAndAllocateString();
|
|
}
|
|
else
|
|
{
|
|
if ( pProp->IsExcludeProp() )
|
|
{
|
|
pProp->m_pExcludeDTName = pBuf->ReadAndAllocateString();
|
|
}
|
|
else if ( pProp->GetType() == DPT_Array )
|
|
{
|
|
pProp->SetNumElements( pBuf->ReadUBitLong( PROPINFOBITS_NUMELEMENTS ) );
|
|
}
|
|
else
|
|
{
|
|
pProp->m_fLowValue = pBuf->ReadBitFloat();
|
|
pProp->m_fHighValue = pBuf->ReadBitFloat();
|
|
pProp->m_nBits = pBuf->ReadUBitLong( PROPINFOBITS_NUMBITS );
|
|
}
|
|
}
|
|
}
|
|
|
|
return pTable;
|
|
}
|
|
|
|
bool RecvTable_RecvClassInfos( bf_read *pBuf, bool bNeedsDecoder, int nDemoProtocol )
|
|
{
|
|
SendTable *pSendTable = RecvTable_ReadInfos( pBuf, nDemoProtocol );
|
|
|
|
if ( !pSendTable )
|
|
return false;
|
|
|
|
bool ret = DataTable_SetupReceiveTableFromSendTable( pSendTable, bNeedsDecoder );
|
|
|
|
RecvTable_FreeSendTable( pSendTable );
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void CopySendPropsToRecvProps(
|
|
CUtlRBTree< MatchingProp_t, unsigned short >& lookup,
|
|
const CUtlVector<const SendProp*> &sendProps,
|
|
CUtlVector<const RecvProp*> &recvProps
|
|
)
|
|
{
|
|
recvProps.SetSize( sendProps.Count() );
|
|
for ( int iSendProp=0; iSendProp < sendProps.Count(); iSendProp++ )
|
|
{
|
|
const SendProp *pSendProp = sendProps[iSendProp];
|
|
MatchingProp_t search;
|
|
search.m_pProp = (SendProp *)pSendProp;
|
|
int idx = lookup.Find( search );
|
|
if ( idx == lookup.InvalidIndex() )
|
|
{
|
|
recvProps[iSendProp] = 0;
|
|
}
|
|
else
|
|
{
|
|
recvProps[iSendProp] = lookup[ idx ].m_pMatchingRecvProp;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool RecvTable_CreateDecoders( const CStandardSendProxies *pSendProxies, bool bAllowMismatches, bool *pAnyMismatches )
|
|
{
|
|
DTI_Init();
|
|
|
|
SETUP_VISIT();
|
|
|
|
if ( pAnyMismatches )
|
|
{
|
|
*pAnyMismatches = false;
|
|
}
|
|
|
|
// First, now that we've supposedly received all the SendTables that we need,
|
|
// set their datatable child pointers.
|
|
if ( !SetupClientSendTableHierarchy() )
|
|
return false;
|
|
|
|
FOR_EACH_LL( g_RecvDecoders, i )
|
|
{
|
|
CRecvDecoder *pDecoder = g_RecvDecoders[i];
|
|
|
|
|
|
// It should already have been linked to its ClientSendTable.
|
|
Assert( pDecoder->m_pClientSendTable );
|
|
if ( !pDecoder->m_pClientSendTable )
|
|
return false;
|
|
|
|
|
|
// For each decoder, precalculate the SendTable's flat property list.
|
|
if ( !pDecoder->m_Precalc.SetupFlatPropertyArray() )
|
|
return false;
|
|
|
|
CUtlRBTree< MatchingProp_t, unsigned short > PropLookup( 0, 0, MatchingProp_t::LessFunc );
|
|
|
|
// Now match RecvProp with SendProps.
|
|
if ( !MatchRecvPropsToSendProps_R( PropLookup, pDecoder->GetSendTable()->m_pNetTableName, pDecoder->GetSendTable(), FindRecvTable( pDecoder->GetSendTable()->m_pNetTableName ), bAllowMismatches, pAnyMismatches ) )
|
|
return false;
|
|
|
|
// Now fill out the matching RecvProp array.
|
|
CSendTablePrecalc *pPrecalc = &pDecoder->m_Precalc;
|
|
CopySendPropsToRecvProps( PropLookup, pPrecalc->m_Props, pDecoder->m_Props );
|
|
CopySendPropsToRecvProps( PropLookup, pPrecalc->m_DatatableProps, pDecoder->m_DatatableProps );
|
|
|
|
DTI_HookRecvDecoder( pDecoder );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool RecvTable_Decode(
|
|
RecvTable *pTable,
|
|
void *pStruct,
|
|
bf_read *pIn,
|
|
int objectID,
|
|
bool updateDTI
|
|
)
|
|
{
|
|
CRecvDecoder *pDecoder = pTable->m_pDecoder;
|
|
ErrorIfNot( pDecoder,
|
|
("RecvTable_Decode: table '%s' missing a decoder.", pTable->GetName())
|
|
);
|
|
|
|
// While there are properties, decode them.. walk the stack as you go.
|
|
CClientDatatableStack theStack( pDecoder, (unsigned char*)pStruct, objectID );
|
|
|
|
theStack.Init();
|
|
int iStartBit = 0, nIndexBits = 0, iLastBit = pIn->GetNumBitsRead();
|
|
unsigned int iProp;
|
|
CDeltaBitsReader deltaBitsReader( pIn );
|
|
while ( (iProp = deltaBitsReader.ReadNextPropIndex()) < MAX_DATATABLE_PROPS )
|
|
{
|
|
theStack.SeekToProp( iProp );
|
|
|
|
const RecvProp *pProp = pDecoder->GetProp( iProp );
|
|
|
|
// Instrumentation (store the # bits for the prop index).
|
|
if ( g_bDTIEnabled )
|
|
{
|
|
iStartBit = pIn->GetNumBitsRead();
|
|
nIndexBits = iStartBit - iLastBit;
|
|
}
|
|
|
|
DecodeInfo decodeInfo;
|
|
decodeInfo.m_pStruct = theStack.GetCurStructBase();
|
|
|
|
if ( pProp )
|
|
{
|
|
decodeInfo.m_pData = theStack.GetCurStructBase() + pProp->GetOffset();
|
|
}
|
|
else
|
|
{
|
|
// They're allowed to be missing props here if they're playing back a demo.
|
|
// This allows us to change the datatables and still preserve old demos.
|
|
decodeInfo.m_pData = NULL;
|
|
}
|
|
|
|
decodeInfo.m_pRecvProp = theStack.IsCurProxyValid() ? pProp : NULL; // Just skip the data if the proxies are screwed.
|
|
decodeInfo.m_pProp = pDecoder->GetSendProp( iProp );
|
|
decodeInfo.m_pIn = pIn;
|
|
decodeInfo.m_ObjectID = objectID;
|
|
|
|
g_PropTypeFns[ decodeInfo.m_pProp->GetType() ].Decode( &decodeInfo );
|
|
++g_nPropsDecoded;
|
|
|
|
// Instrumentation (store # bits for the encoded property).
|
|
if ( updateDTI && g_bDTIEnabled )
|
|
{
|
|
iLastBit = pIn->GetNumBitsRead();
|
|
DTI_HookDeltaBits( pDecoder, iProp, iLastBit - iStartBit, nIndexBits );
|
|
}
|
|
}
|
|
|
|
return !pIn->IsOverflowed();
|
|
}
|
|
|
|
|
|
void RecvTable_DecodeZeros( RecvTable *pTable, void *pStruct, int objectID )
|
|
{
|
|
CRecvDecoder *pDecoder = pTable->m_pDecoder;
|
|
ErrorIfNot( pDecoder,
|
|
("RecvTable_DecodeZeros: table '%s' missing a decoder.", pTable->GetName())
|
|
);
|
|
|
|
// While there are properties, decode them.. walk the stack as you go.
|
|
CClientDatatableStack theStack( pDecoder, (unsigned char*)pStruct, objectID );
|
|
|
|
theStack.Init();
|
|
|
|
for ( int iProp=0; iProp < pDecoder->GetNumProps(); iProp++ )
|
|
{
|
|
theStack.SeekToProp( iProp );
|
|
|
|
// They're allowed to be missing props here if they're playing back a demo.
|
|
// This allows us to change the datatables and still preserve old demos.
|
|
const RecvProp *pProp = pDecoder->GetProp( iProp );
|
|
if ( !pProp )
|
|
continue;
|
|
|
|
DecodeInfo decodeInfo;
|
|
decodeInfo.m_pStruct = theStack.GetCurStructBase();
|
|
decodeInfo.m_pData = theStack.GetCurStructBase() + pProp->GetOffset();
|
|
decodeInfo.m_pRecvProp = theStack.IsCurProxyValid() ? pProp : NULL; // Just skip the data if the proxies are screwed.
|
|
decodeInfo.m_pProp = pDecoder->GetSendProp( iProp );
|
|
decodeInfo.m_pIn = NULL;
|
|
decodeInfo.m_ObjectID = objectID;
|
|
|
|
g_PropTypeFns[pProp->GetType()].DecodeZero( &decodeInfo );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
int RecvTable_MergeDeltas(
|
|
RecvTable *pTable,
|
|
|
|
bf_read *pOldState, // this can be null
|
|
bf_read *pNewState,
|
|
|
|
bf_write *pOut,
|
|
|
|
int objectID,
|
|
int *pChangedProps,
|
|
bool updateDTI
|
|
)
|
|
{
|
|
ErrorIfNot( pTable && pNewState && pOut,
|
|
("RecvTable_MergeDeltas: invalid parameters passed.")
|
|
);
|
|
|
|
CRecvDecoder *pDecoder = pTable->m_pDecoder;
|
|
ErrorIfNot( pDecoder, ("RecvTable_MergeDeltas: table '%s' is missing its decoder.", pTable->GetName()) );
|
|
|
|
int nChanged = 0;
|
|
|
|
// Setup to read the delta bits from each buffer.
|
|
CDeltaBitsReader oldStateReader( pOldState );
|
|
CDeltaBitsReader newStateReader( pNewState );
|
|
|
|
// Setup to write delta bits into the output.
|
|
CDeltaBitsWriter deltaBitsWriter( pOut );
|
|
|
|
unsigned int iOldProp = ~0u;
|
|
if ( pOldState )
|
|
iOldProp = oldStateReader.ReadNextPropIndex();
|
|
|
|
int iStartBit = 0, nIndexBits = 0, iLastBit = pNewState->GetNumBitsRead();
|
|
|
|
unsigned int iNewProp = newStateReader.ReadNextPropIndex();
|
|
|
|
while ( 1 )
|
|
{
|
|
// Write any properties in the previous state that aren't in the new state.
|
|
while ( iOldProp < iNewProp )
|
|
{
|
|
deltaBitsWriter.WritePropIndex( iOldProp );
|
|
oldStateReader.CopyPropData( deltaBitsWriter.GetBitBuf(), pDecoder->GetSendProp( iOldProp ) );
|
|
iOldProp = oldStateReader.ReadNextPropIndex();
|
|
}
|
|
|
|
// Check if we're at the end here so the while() statement above can seek the old buffer
|
|
// to its end too.
|
|
if ( iNewProp >= MAX_DATATABLE_PROPS )
|
|
break;
|
|
|
|
// If the old state has this property too, then just skip over its data.
|
|
if ( iOldProp == iNewProp )
|
|
{
|
|
oldStateReader.SkipPropData( pDecoder->GetSendProp( iOldProp ) );
|
|
iOldProp = oldStateReader.ReadNextPropIndex();
|
|
}
|
|
|
|
// Instrumentation (store the # bits for the prop index).
|
|
if ( updateDTI && g_bDTIEnabled )
|
|
{
|
|
iStartBit = pNewState->GetNumBitsRead();
|
|
nIndexBits = iStartBit - iLastBit;
|
|
}
|
|
|
|
// Now write the new state's value.
|
|
deltaBitsWriter.WritePropIndex( iNewProp );
|
|
newStateReader.CopyPropData( deltaBitsWriter.GetBitBuf(), pDecoder->GetSendProp( iNewProp ) );
|
|
|
|
if ( pChangedProps )
|
|
{
|
|
pChangedProps[nChanged] = iNewProp;
|
|
}
|
|
|
|
nChanged++;
|
|
|
|
// Instrumentation (store # bits for the encoded property).
|
|
if ( updateDTI && g_bDTIEnabled )
|
|
{
|
|
iLastBit = pNewState->GetNumBitsRead();
|
|
DTI_HookDeltaBits( pDecoder, iNewProp, iLastBit - iStartBit, nIndexBits );
|
|
}
|
|
|
|
iNewProp = newStateReader.ReadNextPropIndex();
|
|
}
|
|
|
|
Assert( nChanged <= MAX_DATATABLE_PROPS );
|
|
|
|
ErrorIfNot(
|
|
!(pOldState && pOldState->IsOverflowed()) && !pNewState->IsOverflowed() && !pOut->IsOverflowed(),
|
|
("RecvTable_MergeDeltas: overflowed in RecvTable '%s'.", pTable->GetName())
|
|
);
|
|
|
|
return nChanged;
|
|
}
|
|
|
|
|
|
void RecvTable_CopyEncoding( RecvTable *pTable, bf_read *pIn, bf_write *pOut, int objectID )
|
|
{
|
|
RecvTable_MergeDeltas( pTable, NULL, pIn, pOut, objectID );
|
|
}
|
|
|
|
|
|
|