Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

387 lines
15 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#ifndef ISAVERESTORE_H
#define ISAVERESTORE_H
#include "string_t.h"
#include "datamap.h"
#include "mathlib/vmatrix.h"
#if defined( _WIN32 )
#pragma once
#endif
#ifndef CLIENT_DLL
class SINGLE_INHERITANCE CBaseEntity;
#endif
class Vector;
class VMatrix;
struct edict_t;
template< class T > class CHandle;
typedef CHandle<CBaseEntity> EHANDLE;
struct matrix3x4_t;
class CSaveRestoreData;
class CGameSaveRestoreInfo;
class ISave;
class IRestore;
//-----------------------------------------------------------------------------
#pragma pack(push,1)
struct SaveRestoreRecordHeader_t
{
unsigned short size;
unsigned short symbol;
};
#pragma pack(pop)
//-----------------------------------------------------------------------------
//
// ISaveRestoreBlockHandler
//
//-----------------------------------------------------------------------------
const int MAX_BLOCK_NAME_LEN = 31;
const int SIZE_BLOCK_NAME_BUF = 31 + 1;
//-------------------------------------
abstract_class ISaveRestoreBlockHandler
{
public:
virtual const char *GetBlockName() = 0;
virtual void PreSave( CSaveRestoreData * ) = 0; // Called immediately prior to save, generally used to set up any necessary tables
virtual void Save( ISave * ) = 0;
virtual void WriteSaveHeaders( ISave * ) = 0; // Called after save to allow the writing out of any dictionaries/tables/indexes generated during save
virtual void PostSave() = 0;
virtual void PreRestore() = 0;
virtual void ReadRestoreHeaders( IRestore * ) = 0; // Called prior to Restore()
virtual void Restore( IRestore *, bool fCreatePlayers ) = 0;
virtual void PostRestore() = 0;
};
//-------------------------------------
abstract_class ISaveRestoreBlockSet : public ISaveRestoreBlockHandler
{
public:
virtual void AddBlockHandler( ISaveRestoreBlockHandler *pHandler ) = 0;
virtual void RemoveBlockHandler( ISaveRestoreBlockHandler *pHandler ) = 0;
virtual void CallBlockHandlerRestore( ISaveRestoreBlockHandler *pHandler, int baseFilePos, IRestore *pRestore, bool fCreatePlayers ) = 0;
};
extern ISaveRestoreBlockSet *g_pGameSaveRestoreBlockSet;
//-------------------------------------
abstract_class CDefSaveRestoreBlockHandler : public ISaveRestoreBlockHandler
{
virtual const char *GetBlockName() = 0;
virtual void PreSave( CSaveRestoreData * ) {}
virtual void Save( ISave * ) {}
virtual void WriteSaveHeaders( ISave * ) {}
virtual void PostSave() {}
virtual void PreRestore() {}
virtual void ReadRestoreHeaders( IRestore * ) {}
virtual void Restore( IRestore *, bool fCreatePlayers ) {}
virtual void PostRestore() {}
};
//-----------------------------------------------------------------------------
//
// ISave
//
//-----------------------------------------------------------------------------
abstract_class ISave
{
public:
//---------------------------------
// Logging
virtual void StartLogging( const char *pszLogName ) = 0;
virtual void EndLogging( void ) = 0;
//---------------------------------
virtual bool IsAsync() = 0;
//---------------------------------
virtual int GetWritePos() const = 0;
virtual void SetWritePos(int pos) = 0;
//---------------------------------
// Datamap based writing
//
virtual int WriteAll( const void *pLeafObject, datamap_t *pLeafMap ) = 0;
virtual int WriteFields( const char *pname, const void *pBaseData, datamap_t *pMap, typedescription_t *pFields, int fieldCount ) = 0;
template <typename T>
int WriteAll( const T *pLeafObject )
{
return WriteAll( pLeafObject, &pLeafObject->m_DataMap );
}
//---------------------------------
// Block support
//
// Using these, one doesn't have to worry about queuing up the read pointer on restore if only
// a subset of the data is read
//
virtual void StartBlock( const char *pszBlockName ) = 0;
virtual void StartBlock() = 0;
virtual void EndBlock() = 0;
//---------------------------------
// Primitive types
//
virtual void WriteShort( const short *value, int count = 1 ) = 0;
virtual void WriteInt( const int *value, int count = 1 ) = 0; // Save an int
inline void WriteInt( const unsigned *value, int count = 1 ) { WriteInt( (int *)value, count ); }
virtual void WriteBool( const bool *value, int count = 1 ) = 0; // Save a bool
virtual void WriteFloat( const float *value, int count = 1 ) = 0; // Save a float
virtual void WriteData( const char *pdata, int size ) = 0; // Save a binary data block
virtual void WriteString( const char *pstring ) = 0; // Save a null-terminated string
virtual void WriteString( const string_t *stringId, int count = 1 ) = 0; // Save a null-terminated string (engine string)
virtual void WriteVector( const Vector &value ) = 0; // Save a vector
virtual void WriteVector( const Vector *value, int count = 1 ) = 0; // Save a vector array
virtual void WriteQuaternion( const Quaternion &value ) = 0; // Save a Quaternion
virtual void WriteQuaternion( const Quaternion *value, int count = 1 ) = 0; // Save a Quaternion array
// Note: All of the following will write out both a header and the data. On restore,
// this needs to be cracked
virtual void WriteShort( const char *pname, const short *value, int count = 1 ) = 0;
virtual void WriteInt( const char *pname, const int *value, int count = 1 ) = 0; // Save an int
virtual void WriteBool( const char *pname, const bool *value, int count = 1 ) = 0; // Save a bool
virtual void WriteFloat( const char *pname, const float *value, int count = 1 ) = 0; // Save a float
virtual void WriteData( const char *pname, int size, const char *pdata ) = 0; // Save a binary data block
virtual void WriteString( const char *pname, const char *pstring ) = 0; // Save a null-terminated string
virtual void WriteString( const char *pname, const string_t *stringId, int count = 1 ) = 0; // Save a null-terminated string (engine string)
virtual void WriteVector( const char *pname, const Vector &value ) = 0; // Save a vector
virtual void WriteVector( const char *pname, const Vector *value, int count = 1 ) = 0; // Save a vector array
virtual void WriteQuaternion( const char *pname, const Quaternion &value ) = 0; // Save a Quaternion
virtual void WriteQuaternion( const char *pname, const Quaternion *value, int count = 1 ) = 0; // Save a Quaternion array
//---------------------------------
// Game types
//
virtual void WriteTime( const char *pname, const float *value, int count = 1 ) = 0; // Save a float (timevalue)
virtual void WriteTick( const char *pname, const int *value, int count = 1 ) = 0; // Save a tick (timevalue)
virtual void WritePositionVector( const char *pname, const Vector &value ) = 0; // Offset for landmark if necessary
virtual void WritePositionVector( const char *pname, const Vector *value, int count = 1 ) = 0; // array of pos vectors
virtual void WriteFunction( datamap_t *pMap, const char *pname, inputfunc_t **value, int count = 1 ) = 0; // Save a function pointer
virtual void WriteTime( const float *value, int count = 1 ) = 0; // Save a float (timevalue)
virtual void WriteTick( const int *value, int count = 1 ) = 0; // Save a tick (timevalue)
virtual void WritePositionVector( const Vector &value ) = 0; // Offset for landmark if necessary
virtual void WritePositionVector( const Vector *value, int count = 1 ) = 0; // array of pos vectors
virtual void WriteEntityPtr( const char *pname, CBaseEntity **ppEntity, int count = 1 ) = 0;
virtual void WriteEdictPtr( const char *pname, edict_t **ppEdict, int count = 1 ) = 0;
virtual void WriteEHandle( const char *pname, const EHANDLE *pEHandle, int count = 1 ) = 0;
virtual void WriteEntityPtr( CBaseEntity **ppEntity, int count = 1 ) = 0;
virtual void WriteEdictPtr( edict_t **ppEdict, int count = 1 ) = 0;
virtual void WriteEHandle( const EHANDLE *pEHandle, int count = 1 ) = 0;
//---------------------------------
// Back door to support somewhat awkward ownership of game save/restore data
virtual CGameSaveRestoreInfo *GetGameSaveRestoreInfo() = 0;
protected:
virtual ~ISave() {};
};
//-----------------------------------------------------------------------------
//
// IRestore
//
//-----------------------------------------------------------------------------
abstract_class IRestore
{
public:
//---------------------------------
virtual int GetReadPos() const = 0;
virtual void SetReadPos( int pos ) = 0;
//---------------------------------
// Datamap based reading
//
virtual int ReadAll( void *pLeafObject, datamap_t *pLeafMap ) = 0;
virtual int ReadFields( const char *pname, void *pBaseData, datamap_t *pMap, typedescription_t *pFields, int fieldcount = 1 ) = 0;
virtual void EmptyFields( void *pBaseData, typedescription_t *pFields, int fieldcount = 1 ) = 0;
template <typename T>
int ReadAll( T *pLeafObject )
{
return ReadAll( pLeafObject, &pLeafObject->m_DataMap );
}
//---------------------------------
// Block support
//
virtual void StartBlock( SaveRestoreRecordHeader_t *pHeader ) = 0;
virtual void StartBlock( char szBlockName[SIZE_BLOCK_NAME_BUF] ) = 0;
virtual void StartBlock() = 0;
virtual void EndBlock() = 0;
//---------------------------------
// Field header cracking
//
virtual void ReadHeader( SaveRestoreRecordHeader_t *pheader ) = 0;
virtual int SkipHeader() = 0; // skips the header, but returns the size of the field
virtual const char *StringFromHeaderSymbol( int symbol ) = 0;
//---------------------------------
// Primitive types
//
virtual short ReadShort( void ) = 0;
virtual int ReadShort( short *pValue, int count = 1, int nBytesAvailable = 0 ) = 0;
virtual int ReadInt( int *pValue, int count = 1, int nBytesAvailable = 0 ) = 0;
inline int ReadInt( unsigned *pValue, int count = 1, int nBytesAvailable = 0 ) { return ReadInt( (int *)pValue, count, nBytesAvailable ); }
virtual int ReadInt( void ) = 0;
virtual int ReadBool( bool *pValue, int count = 1, int nBytesAvailable = 0 ) = 0;
virtual int ReadFloat( float *pValue, int count = 1, int nBytesAvailable = 0 ) = 0;
virtual int ReadData( char *pData, int size, int nBytesAvailable ) = 0;
virtual void ReadString( char *pDest, int nSizeDest, int nBytesAvailable ) = 0; // A null-terminated string
virtual int ReadString( string_t *pString, int count = 1, int nBytesAvailable = 0 ) = 0;
virtual int ReadVector( Vector *pValue ) = 0;
virtual int ReadVector( Vector *pValue, int count = 1, int nBytesAvailable = 0 ) = 0;
virtual int ReadQuaternion( Quaternion *pValue ) = 0;
virtual int ReadQuaternion( Quaternion *pValue, int count = 1, int nBytesAvailable = 0 ) = 0;
//---------------------------------
// Game types
//
virtual int ReadTime( float *pValue, int count = 1, int nBytesAvailable = 0 ) = 0;
virtual int ReadTick( int *pValue, int count = 1, int nBytesAvailable = 0 ) = 0;
virtual int ReadPositionVector( Vector *pValue ) = 0;
virtual int ReadPositionVector( Vector *pValue, int count = 1, int nBytesAvailable = 0 ) = 0;
virtual int ReadFunction( datamap_t *pMap, inputfunc_t **pValue, int count = 1, int nBytesAvailable = 0) = 0;
virtual int ReadEntityPtr( CBaseEntity **ppEntity, int count = 1, int nBytesAvailable = 0 ) = 0;
virtual int ReadEdictPtr( edict_t **ppEdict, int count = 1, int nBytesAvailable = 0 ) = 0;
virtual int ReadEHandle( EHANDLE *pEHandle, int count = 1, int nBytesAvailable = 0 ) = 0;
virtual int ReadVMatrix( VMatrix *pValue, int count = 1, int nBytesAvailable = 0) = 0;
virtual int ReadVMatrixWorldspace( VMatrix *pValue, int count = 1, int nBytesAvailable = 0) = 0;
virtual int ReadMatrix3x4Worldspace( matrix3x4_t *pValue, int nElems = 1, int nBytesAvailable = 0 ) = 0;
//---------------------------------
virtual bool GetPrecacheMode( void ) = 0;
//---------------------------------
// Back door to support somewhat awkward ownership of game save/restore data
virtual CGameSaveRestoreInfo *GetGameSaveRestoreInfo() = 0;
protected:
virtual ~IRestore() {};
};
//-----------------------------------------------------------------------------
// Purpose: The operations necessary to save and restore custom types (FIELD_CUSTOM)
//
//
struct SaveRestoreFieldInfo_t
{
void * pField;
// Note that it is legal for the following two fields to be NULL,
// though it may be disallowed by implementors of ISaveRestoreOps
void * pOwner;
typedescription_t *pTypeDesc;
};
abstract_class ISaveRestoreOps
{
public:
// save data type interface
virtual void Save( const SaveRestoreFieldInfo_t &fieldInfo, ISave *pSave ) = 0;
virtual void Restore( const SaveRestoreFieldInfo_t &fieldInfo, IRestore *pRestore ) = 0;
virtual bool IsEmpty( const SaveRestoreFieldInfo_t &fieldInfo ) = 0;
virtual void MakeEmpty( const SaveRestoreFieldInfo_t &fieldInfo ) = 0;
virtual bool Parse( const SaveRestoreFieldInfo_t &fieldInfo, char const* szValue ) = 0;
//---------------------------------
void Save( void *pField, ISave *pSave ) { SaveRestoreFieldInfo_t fieldInfo = { pField, NULL, NULL }; Save( fieldInfo, pSave ); }
void Restore( void *pField, IRestore *pRestore ) { SaveRestoreFieldInfo_t fieldInfo = { pField, NULL, NULL }; Restore( fieldInfo, pRestore ); }
bool IsEmpty( void *pField) { SaveRestoreFieldInfo_t fieldInfo = { pField, NULL, NULL }; return IsEmpty( fieldInfo ); }
void MakeEmpty( void *pField) { SaveRestoreFieldInfo_t fieldInfo = { pField, NULL, NULL }; MakeEmpty( fieldInfo ); }
bool Parse( void *pField, char const *pszValue ) { SaveRestoreFieldInfo_t fieldInfo = { pField, NULL, NULL }; return Parse( fieldInfo, pszValue ); }
};
//-------------------------------------
class CDefSaveRestoreOps : public ISaveRestoreOps
{
public:
// save data type interface
virtual void Save( const SaveRestoreFieldInfo_t &fieldInfo, ISave *pSave ) {}
virtual void Restore( const SaveRestoreFieldInfo_t &fieldInfo, IRestore *pRestore ) {}
virtual bool IsEmpty( const SaveRestoreFieldInfo_t &fieldInfo ) { return false; }
virtual void MakeEmpty( const SaveRestoreFieldInfo_t &fieldInfo ) {}
virtual bool Parse( const SaveRestoreFieldInfo_t &fieldInfo, char const* szValue ) { return false; }
};
//-----------------------------------------------------------------------------
// Used by ops that deal with pointers
//-----------------------------------------------------------------------------
class CClassPtrSaveRestoreOps : public CDefSaveRestoreOps
{
public:
virtual bool IsEmpty( const SaveRestoreFieldInfo_t &fieldInfo )
{
void **ppClassPtr = (void **)fieldInfo.pField;
int nObjects = fieldInfo.pTypeDesc->fieldSize;
for ( int i = 0; i < nObjects; i++ )
{
if ( ppClassPtr[i] != NULL )
return false;
}
return true;
}
virtual void MakeEmpty( const SaveRestoreFieldInfo_t &fieldInfo )
{
memset( fieldInfo.pField, 0, fieldInfo.pTypeDesc->fieldSize * sizeof( void * ) );
}
};
//=============================================================================
#endif // ISAVERESTORE_H