//-----------------------------------------------------------------------------
// Purpose:
// Input : buf -
//-----------------------------------------------------------------------------
void CSentence::CacheRestoreFromBuffer( CUtlBuffer& buf )
{
Assert( !buf.IsText() );
Reset();
m_bIsCached = true;
int version = buf.GetChar();
if ( version != CACHED_SENTENCE_VERSION )
{
// Uh oh, version changed...
m_bIsValid = false;
return;
}
unsigned short pcount = (unsigned short)buf.GetShort();
CPhonemeTag pt;
int i;
for ( i = 0; i < pcount; ++i )
{
unsigned short code = buf.GetShort();
float st = buf.GetFloat();
float et = buf.GetFloat();
pt.SetPhonemeCode( code );
pt.SetStartTime( st );
pt.SetEndTime( et );
AddRuntimePhoneme( &pt );
}
// Now read emphasis samples
int c = buf.GetShort();
for ( i = 0; i < c; i++ )
{
CEmphasisSample sample;
sample.SetSelected( false );
sample.time = buf.GetFloat();
sample.value = (float)buf.GetShort() / 32767.0f;
m_EmphasisSamples.AddToTail( sample );
}
// And voice duck
SetVoiceDuck( buf.GetChar() == 0 ? false : true );
m_bIsValid = true;
}
bool Unserialize( CUtlBuffer &buf, QAngle &dest )
{
if ( buf.IsText() )
{
// FIXME: Print this in a way that we never lose precision
int nRetVal = buf.Scanf( "%f %f %f", &dest.x, &dest.y, &dest.z );
return (nRetVal == 3) && buf.IsValid();
}
dest.x = buf.GetFloat( );
dest.y = buf.GetFloat( );
dest.z = buf.GetFloat( );
return buf.IsValid();
}
bool AStar::Load(IFileSystem *filesystem, const char *Filename)
{
CUtlBuffer buf;
if(!filesystem->ReadFile(Filename, "MOD", buf))
{
return false;
}
buf.SeekGet(CUtlBuffer::SEEK_HEAD, 0);
int SrcID, DestID;
//////////////////////////////////////////////
// Nodes
int NodeTotal = buf.GetInt();
for(int i = 0; i < NodeTotal; i++)
{
Vector origin;
origin.x = buf.GetFloat();
origin.y = buf.GetFloat();
origin.z = buf.GetFloat();
AddNode(new AStarNode(origin));
}
//////////////////////////////////////////////
//////////////////////////////////////////////
// Links
int TotalNumLinks = buf.GetInt();
for(int i = 0; i < TotalNumLinks; i++)
{
SrcID = buf.GetInt();
DestID = buf.GetInt();
Nodes[SrcID]->AddLink(Nodes[DestID]);
}
//////////////////////////////////////////////
return true;
}
bool Unserialize( CUtlBuffer &buf, float &dest )
{
if ( buf.IsText() )
{
// FIXME: Print this in a way that we never lose precision
int nRetVal = buf.Scanf( "%f", &dest );
return (nRetVal == 1) && buf.IsValid();
}
dest = buf.GetFloat( );
return buf.IsValid();
}
void CMomRunStats::Deserialize(CUtlBuffer &reader)
{
SetTotalZones(reader.GetUnsignedChar());
// NOTE: This range checking might result in unread data.
if (m_iTotalZones > MAX_ZONES)
SetTotalZones(MAX_ZONES);
for (int i = 0; i < m_iTotalZones + 1; ++i)
{
SetZoneJumps(i, reader.GetUnsignedInt());
SetZoneStrafes(i, reader.GetUnsignedInt());
SetZoneStrafeSyncAvg(i, reader.GetFloat());
SetZoneStrafeSync2Avg(i, reader.GetFloat());
SetZoneEnterTick(i, reader.GetUnsignedInt());
SetZoneTicks(i, reader.GetUnsignedInt());
float vel3D = 0.0f, vel2D = 0.0f;
vel3D = reader.GetFloat();
vel2D = reader.GetFloat();
SetZoneVelocityMax(i, vel3D, vel2D);
vel3D = reader.GetFloat();
vel2D = reader.GetFloat();
SetZoneVelocityAvg(i, vel3D, vel2D);
vel3D = reader.GetFloat();
vel2D = reader.GetFloat();
SetZoneEnterSpeed(i, vel3D, vel2D);
vel3D = reader.GetFloat();
vel2D = reader.GetFloat();
SetZoneExitSpeed(i, vel3D, vel2D);
}
}
bool KeyValues::ReadAsBinary(CUtlBuffer &buffer)
{
if (buffer.IsText())
return false;
if (!buffer.IsValid())
return false;
RemoveEverything();
Init();
char token[KEYVALUES_TOKEN_SIZE];
KeyValues *dat = this;
types_t type = (types_t)buffer.GetUnsignedChar();
while (true)
{
if (type == TYPE_NUMTYPES)
break;
dat->m_iDataType = type;
buffer.GetString(token, KEYVALUES_TOKEN_SIZE - 1);
token[KEYVALUES_TOKEN_SIZE - 1] = 0;
dat->SetName(token);
switch (type)
{
case TYPE_NONE:
{
dat->m_pSub = new KeyValues("");
dat->m_pSub->ReadAsBinary(buffer);
break;
}
case TYPE_STRING:
{
buffer.GetString(token, KEYVALUES_TOKEN_SIZE - 1);
token[KEYVALUES_TOKEN_SIZE - 1] = 0;
int len = Q_strlen(token);
dat->m_sValue = new char[len + 1];
Q_memcpy(dat->m_sValue, token, len + 1);
break;
}
case TYPE_WSTRING:
{
Assert(!"TYPE_WSTRING");
break;
}
case TYPE_INT:
{
dat->m_iValue = buffer.GetInt();
break;
}
case TYPE_UINT64:
{
dat->m_sValue = new char[sizeof(uint64)];
*((double *)dat->m_sValue) = buffer.GetDouble();
}
case TYPE_FLOAT:
{
dat->m_flValue = buffer.GetFloat();
break;
}
case TYPE_COLOR:
{
dat->m_Color[0] = buffer.GetUnsignedChar();
dat->m_Color[1] = buffer.GetUnsignedChar();
dat->m_Color[2] = buffer.GetUnsignedChar();
dat->m_Color[3] = buffer.GetUnsignedChar();
break;
}
case TYPE_PTR:
{
dat->m_pValue = (void *)buffer.GetUnsignedInt();
}
default:
{
break;
}
}
if (!buffer.IsValid())
return false;
type = (types_t)buffer.GetUnsignedChar();
if (type == TYPE_NUMTYPES)
break;
dat->m_pPeer = new KeyValues("");
dat = dat->m_pPeer;
}
return buffer.IsValid();
}
