467 lines
17 KiB
C++
467 lines
17 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#ifndef ISAVERESTORE_H
|
|
#define ISAVERESTORE_H
|
|
|
|
#include "datamap.h"
|
|
#include "mathlib/vmatrix.h"
|
|
#include "string_t.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
|