本文整理汇总了C++中SendProp::SetOffset方法的典型用法代码示例。如果您正苦于以下问题:C++ SendProp::SetOffset方法的具体用法?C++ SendProp::SetOffset怎么用?C++ SendProp::SetOffset使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类SendProp
的用法示例。
在下文中一共展示了SendProp::SetOffset方法的10个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: SendPropDataTable
SendProp SendPropDataTable(
char *pVarName,
int offset,
SendTable *pTable,
SendTableProxyFn varProxy
)
{
SendProp ret;
ret.m_Type = DPT_DataTable;
ret.m_pVarName = pVarName;
ret.SetOffset( offset );
ret.SetDataTable( pTable );
ret.SetDataTableProxyFn( varProxy );
// Handle special proxy types where they always let all clients get the results.
if ( varProxy == SendProxy_DataTableToDataTable || varProxy == SendProxy_DataTablePtrToDataTable )
{
ret.SetFlags( SPROP_PROXY_ALWAYS_YES );
}
if ( varProxy == SendProxy_DataTableToDataTable && offset == 0 )
{
ret.SetFlags( SPROP_COLLAPSIBLE );
}
return ret;
}
示例2: SendPropQAngles
SendProp SendPropQAngles(
char *pVarName,
int offset,
int sizeofVar,
int nBits,
int flags,
SendVarProxyFn varProxy
)
{
SendProp ret;
if(varProxy == SendProxy_AngleToFloat)
{
Assert(sizeofVar == 4);
}
if ( nBits == 32 )
flags |= SPROP_NOSCALE;
ret.m_Type = DPT_Vector;
ret.m_pVarName = pVarName;
ret.SetOffset( offset );
ret.m_nBits = nBits;
ret.SetFlags( flags );
ret.m_fLowValue = 0.0f;
ret.m_fHighValue = 360.0f;
ret.m_fHighLowMul = AssignRangeMultiplier( ret.m_nBits, ret.m_fHighValue - ret.m_fLowValue );
ret.SetProxyFn( varProxy );
return ret;
}
示例3: SendPropQuaternion
SendProp SendPropQuaternion(
char *pVarName,
int offset,
int sizeofVar,
int nBits, // Number of bits to use when encoding.
int flags,
float fLowValue, // For floating point, low and high values.
float fHighValue, // High value. If HIGH_DEFAULT, it's (1<<nBits).
SendVarProxyFn varProxy
)
{
SendProp ret;
if(varProxy == SendProxy_QuaternionToQuaternion)
{
Assert(sizeofVar == sizeof(Quaternion));
}
if ( nBits == 32 )
flags |= SPROP_NOSCALE;
ret.m_Type = DPT_Quaternion;
ret.m_pVarName = pVarName;
ret.SetOffset( offset );
ret.m_nBits = nBits;
ret.SetFlags( flags );
ret.m_fLowValue = fLowValue;
ret.m_fHighValue = fHighValue;
ret.m_fHighLowMul = AssignRangeMultiplier( ret.m_nBits, ret.m_fHighValue - ret.m_fLowValue );
ret.SetProxyFn( varProxy );
if( ret.GetFlags() & (SPROP_COORD | SPROP_NOSCALE | SPROP_NORMAL) )
ret.m_nBits = 0;
return ret;
}
示例4: SendPropFloat
SendProp SendPropFloat(
const char *pVarName,
// Variable name.
int offset, // Offset into container structure.
int sizeofVar,
int nBits, // Number of bits to use when encoding.
int flags,
float fLowValue, // For floating point, low and high values.
float fHighValue, // High value. If HIGH_DEFAULT, it's (1<<nBits).
SendVarProxyFn varProxy
)
{
SendProp ret;
if ( varProxy == SendProxy_FloatToFloat )
{
Assert( sizeofVar == 0 || sizeofVar == 4 );
}
if ( nBits <= 0 || nBits == 32 )
{
flags |= SPROP_NOSCALE;
fLowValue = 0.f;
fHighValue = 0.f;
}
else
{
if(fHighValue == HIGH_DEFAULT)
fHighValue = (1 << nBits);
if (flags & SPROP_ROUNDDOWN)
fHighValue = fHighValue - ((fHighValue - fLowValue) / (1 << nBits));
else if (flags & SPROP_ROUNDUP)
fLowValue = fLowValue + ((fHighValue - fLowValue) / (1 << nBits));
}
ret.m_Type = DPT_Float;
ret.m_pVarName = pVarName;
ret.SetOffset( offset );
ret.m_nBits = nBits;
ret.SetFlags( flags );
ret.m_fLowValue = fLowValue;
ret.m_fHighValue = fHighValue;
ret.m_fHighLowMul = AssignRangeMultiplier( ret.m_nBits, ret.m_fHighValue - ret.m_fLowValue );
ret.SetProxyFn( varProxy );
if( ret.GetFlags() & (SPROP_COORD | SPROP_NOSCALE | SPROP_NORMAL | SPROP_COORD_MP | SPROP_COORD_MP_LOWPRECISION | SPROP_COORD_MP_INTEGRAL ) )
ret.m_nBits = 0;
return ret;
}
示例5: SendPropArray3
SendProp SendPropArray3(
char *pVarName,
int offset,
int sizeofVar,
int elements,
SendProp pArrayProp,
SendTableProxyFn varProxy
)
{
SendProp ret;
Assert( elements <= MAX_ARRAY_ELEMENTS );
ret.m_Type = DPT_DataTable;
ret.m_pVarName = pVarName;
ret.SetOffset( offset );
ret.SetDataTableProxyFn( varProxy );
SendProp *pArrayPropAllocated = new SendProp;
*pArrayPropAllocated = pArrayProp;
ret.SetArrayProp( pArrayPropAllocated );
// Handle special proxy types where they always let all clients get the results.
if ( varProxy == SendProxy_DataTableToDataTable || varProxy == SendProxy_DataTablePtrToDataTable )
{
ret.SetFlags( SPROP_PROXY_ALWAYS_YES );
}
SendProp *pProps = new SendProp[elements]; // TODO free that again
char *pParentArrayPropName = AllocateStringHelper( "%s", pVarName );
for ( int i = 0; i < elements; i++ )
{
pProps[i] = pArrayProp; // copy array element property setting
pProps[i].SetOffset( i*sizeofVar ); // adjust offset
pProps[i].m_pVarName = s_ElementNames[i]; // give unique name
pProps[i].SetParentArrayPropName( pParentArrayPropName ); // For debugging...
}
SendTable *pTable = new SendTable( pProps, elements, pVarName ); // TODO free that again
ret.SetDataTable( pTable );
return ret;
}
示例6: SendTable_CalcNextVectorElems
static void SendTable_CalcNextVectorElems( SendTable *pTable )
{
for ( int i=0; i < pTable->GetNumProps(); i++ )
{
SendProp *pProp = pTable->GetProp( i );
if ( pProp->GetType() == DPT_DataTable )
{
SendTable_CalcNextVectorElems( pProp->GetDataTable() );
}
else if ( pProp->GetOffset() < 0 )
{
pProp->SetOffset( -pProp->GetOffset() );
pProp->SetFlags( pProp->GetFlags() | SPROP_IS_A_VECTOR_ELEM );
}
}
}
示例7: SendPropString
SendProp SendPropString(
char *pVarName,
int offset,
int bufferLen,
int flags,
SendVarProxyFn varProxy)
{
SendProp ret;
Assert( bufferLen <= DT_MAX_STRING_BUFFERSIZE ); // You can only have strings with 8-bits worth of length.
ret.m_Type = DPT_String;
ret.m_pVarName = pVarName;
ret.SetOffset( offset );
ret.SetFlags( flags );
ret.SetProxyFn( varProxy );
return ret;
}
示例8: SendPropInt
SendProp SendPropInt(
char *pVarName,
int offset,
int sizeofVar,
int nBits,
int flags,
SendVarProxyFn varProxy
)
{
SendProp ret;
if ( !varProxy )
{
if ( sizeofVar == 1 )
{
varProxy = SendProxy_Int8ToInt32;
}
else if ( sizeofVar == 2 )
{
varProxy = SendProxy_Int16ToInt32;
}
else if ( sizeofVar == 4 )
{
varProxy = SendProxy_Int32ToInt32;
}
else
{
Assert(!"SendPropInt var has invalid size");
varProxy = SendProxy_Int8ToInt32; // safest one...
}
}
// Figure out # of bits if the want us to.
if ( nBits <= 0 )
{
Assert( sizeofVar == 1 || sizeofVar == 2 || sizeofVar == 4 );
nBits = sizeofVar * 8;
}
ret.m_Type = DPT_Int;
ret.m_pVarName = pVarName;
ret.SetOffset( offset );
ret.m_nBits = nBits;
ret.SetFlags( flags );
// Use UInt proxies if they want unsigned data. This isn't necessary to encode
// the values correctly, but it lets us check the ranges of the data to make sure
// they're valid.
ret.SetProxyFn( varProxy );
if( ret.GetFlags() & SPROP_UNSIGNED )
{
if( varProxy == SendProxy_Int8ToInt32 )
ret.SetProxyFn( SendProxy_UInt8ToInt32 );
else if( varProxy == SendProxy_Int16ToInt32 )
ret.SetProxyFn( SendProxy_UInt16ToInt32 );
else if( varProxy == SendProxy_Int32ToInt32 )
ret.SetProxyFn( SendProxy_UInt32ToInt32 );
}
return ret;
}
示例9: SendPropUtlVector
// Note: your pArrayProp will NOT get iElement set to anything other than 0, because this function installs its
// own proxy in front of yours. pStruct will point at the CUtlVector and pData will point at the element in the CUtlVector.It will pass you the direct pointer to the element inside the CUtlVector.
//
// You can skip the first 3 parameters in pArrayProp because they're ignored. So your array specification
// could look like this:
// SendPropUtlVector(
// SENDINFO_UTLVECTOR( m_FloatArray ),
// SendPropFloat( NULL, 0, 0, 0 [# bits], SPROP_NOSCALE [flags] ) );
//
// Note: you have to be DILIGENT about calling NetworkStateChanged whenever an element in your CUtlVector changes
// since CUtlVector doesn't do this automatically.
SendProp SendPropUtlVector(
const char *pVarName, // Use SENDINFO_UTLVECTOR to generate these 4.
int offset, // Used to generate pData in the function specified in varProxy.
int sizeofVar, // The size of each element in the utlvector.
EnsureCapacityFn ensureFn, // This is the value returned for elements out of the array's current range.
int nMaxElements, // Max # of elements in the array. Keep this as low as possible.
SendProp pArrayProp, // Describe the data inside of each element in the array.
SendTableProxyFn varProxy // This can be overridden to control who the array is sent to.
)
{
SendProp ret;
Assert( nMaxElements <= MAX_ARRAY_ELEMENTS );
ret.m_Type = DPT_DataTable;
ret.m_pVarName = pVarName;
ret.SetOffset( 0 );
ret.SetDataTableProxyFn( varProxy );
// Handle special proxy types where they always let all clients get the results.
if ( varProxy == SendProxy_DataTableToDataTable || varProxy == SendProxy_DataTablePtrToDataTable )
{
ret.SetFlags( SPROP_PROXY_ALWAYS_YES );
}
// Extra data bound to each of the properties.
CSendPropExtra_UtlVector *pExtraData = new CSendPropExtra_UtlVector;
pExtraData->m_nMaxElements = nMaxElements;
pExtraData->m_ElementStride = sizeofVar;
pExtraData->m_EnsureCapacityFn = ensureFn;
pExtraData->m_Offset = offset;
if ( pArrayProp.m_Type == DPT_DataTable )
pExtraData->m_DataTableProxyFn = pArrayProp.GetDataTableProxyFn();
else
pExtraData->m_ProxyFn = pArrayProp.GetProxyFn();
SendProp *pProps = new SendProp[nMaxElements+1]; // TODO free that again
// The first property is datatable with an int that tells the length of the array.
// It has to go in a datatable, otherwise if this array holds datatable properties, it will be received last.
SendProp *pLengthProp = new SendProp;
*pLengthProp = SendPropInt( AllocateStringHelper( "lengthprop%d", nMaxElements ), 0, 0, NumBitsForCount( nMaxElements ), SPROP_UNSIGNED, SendProxy_UtlVectorLength );
pLengthProp->SetExtraData( pExtraData );
char *pLengthProxyTableName = AllocateUniqueDataTableName( true, "_LPT_%s_%d", pVarName, nMaxElements );
SendTable *pLengthTable = new SendTable( pLengthProp, 1, pLengthProxyTableName );
pProps[0] = SendPropDataTable( "lengthproxy", 0, pLengthTable, SendProxy_LengthTable );
pProps[0].SetExtraData( pExtraData );
// The first element is a sub-datatable.
for ( int i = 1; i < nMaxElements+1; i++ )
{
pProps[i] = pArrayProp; // copy array element property setting
pProps[i].SetOffset( 0 ); // leave offset at 0 so pStructBase is always a pointer to the CUtlVector
pProps[i].m_pVarName = s_ElementNames[i-1]; // give unique name
pProps[i].SetExtraData( pExtraData );
pProps[i].m_ElementStride = i-1; // Kind of lame overloading element stride to hold the element index,
// but we can easily move it into its SetExtraData stuff if we need to.
// We provide our own proxy here.
if ( pArrayProp.m_Type == DPT_DataTable )
{
pProps[i].SetDataTableProxyFn( SendProxy_UtlVectorElement_DataTable );
pProps[i].SetFlags( SPROP_PROXY_ALWAYS_YES );
}
else
{
pProps[i].SetProxyFn( SendProxy_UtlVectorElement );
}
}
SendTable *pTable = new SendTable(
pProps,
nMaxElements+1,
AllocateUniqueDataTableName( true, "_ST_%s_%d", pVarName, nMaxElements )
);
ret.SetDataTable( pTable );
return ret;
}
示例10: DataTable_SetupReceiveTableFromSendTable
bool DataTable_SetupReceiveTableFromSendTable( SendTable *sendTable, bool bNeedsDecoder )
{
CClientSendTable *pClientSendTable = new CClientSendTable;
SendTable *pTable = &pClientSendTable->m_SendTable;
g_ClientSendTables.AddToTail( pClientSendTable );
// Read the name.
pTable->m_pNetTableName = COM_StringCopy( sendTable->m_pNetTableName );
// Create a decoder for it if necessary.
if ( bNeedsDecoder )
{
// Make a decoder for it.
CRecvDecoder *pDecoder = new CRecvDecoder;
g_RecvDecoders.AddToTail( pDecoder );
RecvTable *pRecvTable = FindRecvTable( pTable->m_pNetTableName );
if ( !pRecvTable )
{
DataTable_Warning( "No matching RecvTable for SendTable '%s'.\n", pTable->m_pNetTableName );
return false;
}
pRecvTable->m_pDecoder = pDecoder;
pDecoder->m_pTable = pRecvTable;
pDecoder->m_pClientSendTable = pClientSendTable;
pDecoder->m_Precalc.m_pSendTable = pClientSendTable->GetSendTable();
pClientSendTable->GetSendTable()->m_pPrecalc = &pDecoder->m_Precalc;
// Initialize array properties.
SetupArrayProps_R<RecvTable, RecvTable::PropType>( pRecvTable );
}
// Read the property list.
pTable->m_nProps = sendTable->m_nProps;
pTable->m_pProps = pTable->m_nProps ? new SendProp[ pTable->m_nProps ] : 0;
pClientSendTable->m_Props.SetSize( pTable->m_nProps );
for ( int iProp=0; iProp < pTable->m_nProps; iProp++ )
{
CClientSendProp *pClientProp = &pClientSendTable->m_Props[iProp];
SendProp *pProp = &pTable->m_pProps[iProp];
const SendProp *pSendTableProp = &sendTable->m_pProps[ iProp ];
pProp->m_Type = (SendPropType)pSendTableProp->m_Type;
pProp->m_pVarName = COM_StringCopy( pSendTableProp->GetName() );
pProp->SetFlags( pSendTableProp->GetFlags() );
if ( pProp->m_Type == DPT_DataTable )
{
char *pDTName = pSendTableProp->m_pExcludeDTName; // HACK
if ( pSendTableProp->GetDataTable() )
pDTName = pSendTableProp->GetDataTable()->m_pNetTableName;
Assert( pDTName && Q_strlen(pDTName) > 0 );
pClientProp->SetTableName( COM_StringCopy( pDTName ) );
// Normally we wouldn't care about this but we need to compare it against
// proxies in the server DLL in SendTable_BuildHierarchy.
pProp->SetDataTableProxyFn( pSendTableProp->GetDataTableProxyFn() );
pProp->SetOffset( pSendTableProp->GetOffset() );
}
else
{
if ( pProp->IsExcludeProp() )
{
pProp->m_pExcludeDTName = COM_StringCopy( pSendTableProp->GetExcludeDTName() );
}
else if ( pProp->GetType() == DPT_Array )
{
pProp->SetNumElements( pSendTableProp->GetNumElements() );
}
else
{
pProp->m_fLowValue = pSendTableProp->m_fLowValue;
pProp->m_fHighValue = pSendTableProp->m_fHighValue;
pProp->m_nBits = pSendTableProp->m_nBits;
}
}
}
return true;
}