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.
568 lines
24 KiB
568 lines
24 KiB
/*==LICENSE==* |
|
|
|
CyanWorlds.com Engine - MMOG client, server and tools |
|
Copyright (C) 2011 Cyan Worlds, Inc. |
|
|
|
This program is free software: you can redistribute it and/or modify |
|
it under the terms of the GNU General Public License as published by |
|
the Free Software Foundation, either version 3 of the License, or |
|
(at your option) any later version. |
|
|
|
This program is distributed in the hope that it will be useful, |
|
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
GNU General Public License for more details. |
|
|
|
You should have received a copy of the GNU General Public License |
|
along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
|
|
Additional permissions under GNU GPL version 3 section 7 |
|
|
|
If you modify this Program, or any covered work, by linking or |
|
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK, |
|
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent |
|
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK |
|
(or a modified version of those libraries), |
|
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA, |
|
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG |
|
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the |
|
licensors of this Program grant you additional |
|
permission to convey the resulting work. Corresponding Source for a |
|
non-source form of such a combination shall include the source code for |
|
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered |
|
work. |
|
|
|
You can contact Cyan Worlds, Inc. by email legal@cyan.com |
|
or by snail mail at: |
|
Cyan Worlds, Inc. |
|
14617 N Newport Hwy |
|
Mead, WA 99021 |
|
|
|
*==LICENSE==*/ |
|
#ifndef PL_SDL_inc |
|
#define PL_SDL_inc |
|
|
|
// |
|
// Code for the State Description Language (SDL) |
|
// |
|
|
|
#include "plSDLDescriptor.h" |
|
#include "hsUtils.h" |
|
#include "hsStlUtils.h" |
|
|
|
#include "pnFactory/plCreatable.h" |
|
#include "pnKeyedObject/plKey.h" |
|
#include "pnKeyedObject/plUoid.h" |
|
|
|
#include "plUnifiedTime/plUnifiedTime.h" |
|
|
|
namespace plSDL |
|
{ |
|
typedef std::list<plStateDescriptor*> DescriptorList; |
|
enum GeneralPurpose |
|
{ |
|
kLatestVersion = -1, // used when requesting the latest version of a state descriptor |
|
kMaxListSize = 9999 // maximum size of var lists |
|
}; |
|
|
|
enum ContentsFlags // or saveFlags, 16 bits |
|
{ |
|
kHasUoid = 0x1, |
|
kHasNotificationInfo = 0x2, |
|
kHasTimeStamp = 0x4, |
|
kSameAsDefault = 0x8, |
|
kHasDirtyFlag = 0x10, |
|
kWantTimeStamp = 0x20, |
|
|
|
kAddedVarLengthIO = 0x8000, // using to establish a new version in the header, can delete in 8/03 |
|
|
|
kHasMaximumValue= 0xffff, |
|
}; |
|
|
|
enum RWOptions |
|
{ |
|
kDirtyOnly = 1<< 0, // write option |
|
kSkipNotificationInfo = 1<< 1, // read/write option |
|
kBroadcast = 1<< 2, // send option |
|
kWriteTimeStamps = 1<< 3, // write out time stamps |
|
kTimeStampOnRead = 1<< 4, // read: timestamp each var when it gets read. write: request that the reader timestamp the dirty vars. |
|
kTimeStampOnWrite = 1<< 5, // read: n/a. write: timestamp each var when it gets written. |
|
kKeepDirty = 1<< 6, // don't clear dirty flag on read |
|
kDontWriteDirtyFlag = 1<< 7, // write option. don't write var dirty flag. |
|
kMakeDirty = 1<< 8, // read/write: set dirty flag on var read/write. |
|
kDirtyNonDefaults = 1<< 9, // dirty the var if non default value. |
|
kForceConvert = 1<<10, // always try to convert rec to latest on read |
|
}; |
|
|
|
enum BehaviorFlags |
|
{ |
|
kDisallowTimeStamping = 0x1, |
|
}; |
|
|
|
extern const char* kAgeSDLObjectName; |
|
void VariableLengthRead(hsStream* s, int size, int* val); |
|
void VariableLengthWrite(hsStream* s, int size, int val); |
|
}; |
|
|
|
class plStateVarNotificationInfo |
|
{ |
|
private: |
|
std::string fHintString; |
|
public: |
|
void SetHintString(const char* c) { fHintString=c; } |
|
const char* GetHintString() const { return fHintString.c_str(); } |
|
|
|
void Read(hsStream* s, UInt32 readOptions); |
|
void Write(hsStream* s, UInt32 writeOptions) const; |
|
}; |
|
|
|
// |
|
// Base class for a state variable. |
|
// A state var is a var descriptor and it's value (contents) |
|
// |
|
class plSimpleStateVariable; |
|
class plSDStateVariable; |
|
class plStateVariable |
|
{ |
|
public: |
|
enum Flags |
|
{ |
|
kDirty = 0x1, // true when someone sets the value using Set(...), can be cleared after writing |
|
kUsed = 0x2 // true when it contains some value (either by Set(...) or Read() ) |
|
}; |
|
protected: |
|
UInt32 fFlags; |
|
plStateVarNotificationInfo fNotificationInfo; |
|
public: |
|
plStateVariable() : fFlags(0) {} |
|
virtual ~plStateVariable() {} |
|
|
|
const char* GetName() const { return GetVarDescriptor()->GetName(); } |
|
bool IsNamed(const char* n) const { return (n && !stricmp(GetName(), n)); } |
|
virtual int GetCount() const = 0; |
|
|
|
// conversion ops |
|
virtual plSimpleStateVariable* GetAsSimpleStateVar() = 0; |
|
virtual plSDStateVariable* GetAsSDStateVar() = 0; |
|
virtual plVarDescriptor* GetVarDescriptor() = 0; |
|
virtual const plVarDescriptor* GetVarDescriptor() const = 0; |
|
virtual void Alloc(int cnt=-1 /* -1 means don't change count */) = 0; |
|
|
|
virtual bool IsDirty() const { return (fFlags & kDirty) != 0; } |
|
virtual bool IsUsed() const { return (fFlags & kUsed) != 0; } |
|
|
|
void SetDirty(bool d) { if (d) fFlags |= kDirty; else fFlags &= ~kDirty; } |
|
void SetUsed(bool d) { if (d) fFlags |= kUsed; else fFlags &= ~kUsed; } |
|
virtual void SetFromDefaults(bool timeStampNow) = 0; |
|
virtual void TimeStamp( const plUnifiedTime & ut=plUnifiedTime::GetCurrentTime() ) = 0; |
|
virtual const plUnifiedTime& GetTimeStamp() const = 0; |
|
|
|
plStateVarNotificationInfo& GetNotificationInfo() { return fNotificationInfo; } |
|
const plStateVarNotificationInfo& GetNotificationInfo() const { return fNotificationInfo; } |
|
|
|
virtual void DumpToObjectDebugger(bool dirtyOnly, int level) const {} |
|
virtual void DumpToStream(hsStream* stream, bool dirtyOnly, int level) const {} |
|
|
|
// IO |
|
virtual bool ReadData(hsStream* s, float timeConvert, UInt32 readOptions); |
|
virtual bool WriteData(hsStream* s, float timeConvert, UInt32 writeOptions) const; |
|
}; |
|
|
|
// |
|
// Change Notifier. |
|
// When a plSimpleStateVariable changes it's value by more than the given delta value, |
|
// a notification msg will be sent to the objects that registered interest. |
|
// |
|
class plStateChangeNotifier |
|
{ |
|
friend class plSimpleStateVariable; |
|
private: |
|
float fDelta; |
|
typedef std::vector<plKey> KeyList; |
|
KeyList fKeys; // the objects to notify on change>delta |
|
static UInt32 fCurrentPlayerID; |
|
|
|
void IAddKey(plKey k); |
|
int IRemoveKey(plKey k); |
|
public: |
|
plStateChangeNotifier(); |
|
plStateChangeNotifier(float i, plKey k); |
|
|
|
void AddNotificationKey(plKey k) { IAddKey(k); } |
|
void AddNotificationKeys(KeyList keys); |
|
int RemoveNotificationKey(plKey k); // returns number of keys left after removal |
|
int RemoveNotificationKeys(KeyList keys); // returns number of keys left after removal |
|
|
|
void SendNotificationMsg(const plSimpleStateVariable* srcVar, const plSimpleStateVariable* dstVar, const char* sdlName); |
|
|
|
bool GetValue(float* i) const; |
|
bool SetValue(float i); |
|
|
|
static UInt32 GetCurrentPlayerID() { return fCurrentPlayerID; } |
|
static void SetCurrentPlayerID(UInt32 p) { fCurrentPlayerID=p; } |
|
|
|
bool operator==(const plStateChangeNotifier &) const; |
|
}; |
|
|
|
// |
|
// A (non-nested) variable descriptor and its data contents. |
|
// |
|
class plUoid; |
|
class plKey; |
|
class plClientUnifiedTime; |
|
typedef unsigned char byte; |
|
class plSimpleStateVariable : public plStateVariable |
|
{ |
|
protected: |
|
union |
|
{ |
|
int* fI; // array of int |
|
short* fS; // array of short |
|
byte* fBy; // array of byte |
|
float* fF; // array of float |
|
double* fD; // array of double |
|
bool* fB; // array of bool |
|
plUoid* fU; // array of uoid |
|
plCreatable** fC; // array of plCreatable ptrs |
|
plVarDescriptor::String32* fS32; // array of strings |
|
plClientUnifiedTime* fT; // array of Times |
|
}; |
|
mutable plUnifiedTime fTimeStamp; // the last time the var was changed |
|
plSimpleVarDescriptor fVar; |
|
|
|
typedef std::vector<plStateChangeNotifier> StateChangeNotifiers; |
|
StateChangeNotifiers fChangeNotifiers; |
|
|
|
void IDeAlloc(); |
|
void IInit(); // initize vars |
|
void IVarSet(bool timeStampNow=false); |
|
|
|
// converter fxns |
|
bool IConvertFromBool(plVarDescriptor::Type newType); |
|
bool IConvertFromInt(plVarDescriptor::Type newType); |
|
bool IConvertFromByte(plVarDescriptor::Type newType); |
|
bool IConvertFromShort(plVarDescriptor::Type newType); |
|
bool IConvertFromFloat(plVarDescriptor::Type newType); |
|
bool IConvertFromDouble(plVarDescriptor::Type newType); |
|
bool IConvertFromString(plVarDescriptor::Type newType); |
|
bool IConvertFromRGB(plVarDescriptor::Type newType); |
|
bool IConvertFromRGBA(plVarDescriptor::Type newType); |
|
bool IConvertFromRGB8(plVarDescriptor::Type newType); |
|
bool IConvertFromRGBA8(plVarDescriptor::Type newType); |
|
|
|
bool IReadData(hsStream* s, float timeConvert, int idx, UInt32 readOptions); |
|
bool IWriteData(hsStream* s, float timeConvert, int idx, UInt32 writeOptions) const; |
|
|
|
public: |
|
|
|
plSimpleStateVariable() { IInit(); } |
|
plSimpleStateVariable(plVarDescriptor* vd) { IInit(); CopyFrom(vd); } |
|
~plSimpleStateVariable() { IDeAlloc(); } |
|
|
|
// conversion ops |
|
plSimpleStateVariable* GetAsSimpleStateVar() { return this; } |
|
plSDStateVariable* GetAsSDStateVar() { return nil; } |
|
bool operator==(const plSimpleStateVariable &other) const; // assumes matching var descriptors |
|
|
|
void TimeStamp( const plUnifiedTime & ut=plUnifiedTime::GetCurrentTime() ); |
|
void CopyFrom(plVarDescriptor* v); |
|
void CopyData(const plSimpleStateVariable* other, UInt32 writeOptions=0); |
|
bool SetFromString(const char* value, int idx, bool timeStampNow); // set value from string, type. return false on err |
|
char* GetAsString(int idx) const; |
|
bool ConvertTo(plSimpleVarDescriptor* toVar, bool force=false); // return false on err |
|
void Alloc(int cnt=-1 /* -1 means don't change count */); // alloc memory after setting type |
|
void Reset(); |
|
|
|
// setters |
|
bool Set(float v, int idx=0); |
|
bool Set(float* v, int idx=0); // floatVector |
|
bool Set(double v, int idx=0); |
|
bool Set(double* v, int idx=0); // doubleVector |
|
bool Set(int v, int idx=0); |
|
bool Set(int* v, int idx=0) { return Set(*v, idx); } // helper since there is no int vec type |
|
bool Set(byte v, int idx=0); |
|
bool Set(byte* v, int idx=0); // byteVector |
|
bool Set(short v, int idx=0); |
|
bool Set(short* v, int idx=0) { return Set(*v, idx); } // helper since there is no short vec type |
|
bool Set(bool v, int idx=0); |
|
bool Set(bool* v, int idx=0) { return Set(*v, idx); } // helper since there is no bool vec type |
|
bool Set(const char* v, int idx=0); // string |
|
bool Set(const plKey& v, int idx=0); |
|
bool Set(plCreatable*, int idx=0); // only SDL generated by the server is allowed to use this type. |
|
void SetFromDefaults(bool timeStampNow); |
|
|
|
// getters |
|
bool Get(int* value, int idx=0) const; |
|
bool Get(short* value, int idx=0) const; |
|
bool Get(byte* value, int idx=0) const; // returns byte or byteVector |
|
bool Get(float* value, int idx=0) const; // returns float or floatVector |
|
bool Get(double* value, int idx=0) const; // returns double or doubleVector |
|
bool Get(bool* value, int idx=0) const; |
|
bool Get(char value[], int idx=0) const; |
|
bool Get(plKey* value, int idx=0) const; |
|
bool Get(plCreatable** value, int idx=0) const; |
|
const plUnifiedTime& GetTimeStamp() const { return fTimeStamp; } |
|
|
|
// Special backdoor so the KI Manager can get the key name without having a ResMgr |
|
const char* GetKeyName(int idx=0) const; |
|
|
|
int GetCount() const { return fVar.GetCount(); } // helper |
|
plVarDescriptor* GetVarDescriptor() { return &fVar; } |
|
plSimpleVarDescriptor* GetSimpleVarDescriptor() { return fVar.GetAsSimpleVarDescriptor(); } |
|
const plVarDescriptor* GetVarDescriptor() const { return &fVar; } |
|
const plSimpleVarDescriptor* GetSimpleVarDescriptor() const { return fVar.GetAsSimpleVarDescriptor(); } |
|
|
|
// State Change Notification |
|
void AddStateChangeNotification(plStateChangeNotifier& n); |
|
void RemoveStateChangeNotification(plKey notificationObj); // remove all with this key |
|
void RemoveStateChangeNotification(plStateChangeNotifier n); // remove ones which match |
|
void NotifyStateChange(const plSimpleStateVariable* other, const char* sdlName); // send notification msg if necessary, internal use |
|
|
|
void DumpToObjectDebugger(bool dirtyOnly, int level) const; |
|
void DumpToStream(hsStream* stream, bool dirtyOnly, int level) const; |
|
|
|
// IO |
|
bool ReadData(hsStream* s, float timeConvert, UInt32 readOptions); |
|
bool WriteData(hsStream* s, float timeConvert, UInt32 writeOptions) const; |
|
}; |
|
|
|
// |
|
// A list of state data records, all of which are the same kind. |
|
// Corresponds to a SD var descriptor. |
|
// |
|
class plStateDataRecord; |
|
class plSDStateVariable : public plStateVariable |
|
{ |
|
public: |
|
typedef std::vector<const plStateDataRecord*> ConstDataRecList; |
|
protected: |
|
typedef std::vector<plStateDataRecord*> DataRecList; |
|
DataRecList fDataRecList; |
|
plSDVarDescriptor* fVarDescriptor; |
|
|
|
void IDeInit(); |
|
public: |
|
plSDStateVariable(plSDVarDescriptor* sdvd); |
|
~plSDStateVariable(); // delete all records |
|
|
|
// conversion ops |
|
plSimpleStateVariable* GetAsSimpleStateVar() { return nil; } |
|
plSDStateVariable* GetAsSDStateVar() { return this; } |
|
bool operator==(const plSDStateVariable &other) const; // assumes matching var descriptors |
|
|
|
void ConvertTo(plSDStateVariable* otherSDVar, bool force=false); |
|
void CopyFrom(plSDStateVariable* other, UInt32 writeOptions=0); |
|
void UpdateFrom(plSDStateVariable* other, UInt32 writeOptions=0); |
|
void AddStateDataRecord(plStateDataRecord *sdr) { fDataRecList.push_back(sdr); SetDirty(true); SetUsed(true); } |
|
void InsertStateDataRecord(plStateDataRecord *sdr, int i) { fDataRecList[i] = sdr; SetDirty(true); SetUsed(true);} |
|
void SetFromDefaults(bool timeStampNow); |
|
void TimeStamp( const plUnifiedTime & ut=plUnifiedTime::GetCurrentTime() ); |
|
const plUnifiedTime& GetTimeStamp() const { static plUnifiedTime foo; return foo; } |
|
|
|
void Alloc(int cnt=-1 /* -1 means don't change count */); // wipe and re-create |
|
void Alloc(plSDVarDescriptor* sdvd, int cnt=-1); // wipe and re-create |
|
void Resize(int cnt); |
|
|
|
bool IsDirty() const; |
|
bool IsUsed() const; |
|
|
|
// getters |
|
plStateDataRecord* GetStateDataRecord(int i) { return fDataRecList[i]; } |
|
const plStateDataRecord* GetStateDataRecord(int i) const { return fDataRecList[i]; } |
|
int GetCount() const { return fDataRecList.size(); } |
|
int GetUsedCount() const; |
|
int GetDirtyCount() const; |
|
void GetUsedDataRecords(ConstDataRecList*) const; |
|
void GetDirtyDataRecords(ConstDataRecList*) const; |
|
plVarDescriptor* GetVarDescriptor() { return fVarDescriptor; } |
|
plSDVarDescriptor* GetSDVarDescriptor() { return fVarDescriptor->GetAsSDVarDescriptor(); } |
|
const plVarDescriptor* GetVarDescriptor() const { return fVarDescriptor; } |
|
const plSDVarDescriptor* GetSDVarDescriptor() const { return fVarDescriptor->GetAsSDVarDescriptor(); } |
|
void FlagNewerState(const plSDStateVariable&, bool respectAlwaysNew); |
|
void FlagAlwaysNewState(); |
|
void DumpToObjectDebugger(bool dirtyOnly, int level) const; |
|
void DumpToStream(hsStream* stream, bool dirtyOnly, int level) const; |
|
|
|
// IO |
|
bool ReadData(hsStream* s, float timeConvert, UInt32 readOptions); |
|
bool WriteData(hsStream* s, float timeConvert, UInt32 writeOptions) const; |
|
}; |
|
|
|
// |
|
// Contains the actual data contents and points to its associated descriptor |
|
// |
|
class plNetMsgSDLState; |
|
class plStateDataRecord : public plCreatable |
|
{ |
|
public: |
|
typedef std::vector<plSimpleStateVariable*> SimpleVarsList; |
|
typedef std::vector<plSDStateVariable*> SDVarsList; |
|
enum Flags |
|
{ |
|
kVolatile = 0x1 |
|
}; |
|
protected: |
|
typedef std::vector<plStateVariable*> VarsList; |
|
|
|
const plStateDescriptor* fDescriptor; |
|
plUoid fAssocObject; // optional |
|
VarsList fVarsList; // list of variables |
|
VarsList fSDVarsList; // list of nested data records |
|
UInt32 fFlags; |
|
static const UInt8 kIOVersion; // I/O Version |
|
|
|
void IDeleteVarsList(VarsList& vars); |
|
void IInitDescriptor(const char* name, int version); // or plSDL::kLatestVersion |
|
void IInitDescriptor(const plStateDescriptor* sd); |
|
|
|
void IReadHeader(hsStream* s); |
|
void IWriteHeader(hsStream* s) const; |
|
bool IConvertVar(plSimpleStateVariable* fromVar, plSimpleStateVariable* toVar, bool force); |
|
|
|
plStateVariable* IFindVar(const VarsList& vars, const char* name) const; |
|
int IGetNumUsedVars(const VarsList& vars) const; |
|
int IGetUsedVars(const VarsList& varsOut, VarsList *varsIn) const; // build a list of vars that have data |
|
bool IHasUsedVars(const VarsList& vars) const; |
|
|
|
int IGetNumDirtyVars(const VarsList& vars) const; |
|
int IGetDirtyVars(const VarsList& varsOut, VarsList *varsIn) const; // build a list of vars that are dirty |
|
bool IHasDirtyVars(const VarsList& vars) const; |
|
public: |
|
CLASSNAME_REGISTER( plStateDataRecord ); |
|
GETINTERFACE_ANY( plStateDataRecord, plCreatable); |
|
|
|
plStateDataRecord(const char* sdName, int version=plSDL::kLatestVersion); |
|
plStateDataRecord(plStateDescriptor* sd); |
|
plStateDataRecord(const plStateDataRecord &other, UInt32 writeOptions=0 ):fFlags(0) { CopyFrom(other, writeOptions); } |
|
plStateDataRecord():fFlags(0) {} |
|
~plStateDataRecord(); |
|
|
|
bool ConvertTo(plStateDescriptor* other, bool force=false ); |
|
bool operator==(const plStateDataRecord &other) const; // assumes matching state descriptors |
|
|
|
UInt32 GetFlags() const { return fFlags; } |
|
void SetFlags(UInt32 f) { fFlags =f; } |
|
|
|
plSimpleStateVariable* FindVar(const char* name) const { return (plSimpleStateVariable*)IFindVar(fVarsList, name); } |
|
plSDStateVariable* FindSDVar(const char* name) const { return (plSDStateVariable*)IFindVar(fSDVarsList, name); } |
|
|
|
plStateDataRecord& operator=(const plStateDataRecord& other) { CopyFrom(other); return *this; } |
|
void CopyFrom(const plStateDataRecord& other, UInt32 writeOptions=0); |
|
void UpdateFrom(const plStateDataRecord& other, UInt32 writeOptions=0); |
|
void SetFromDefaults(bool timeStampNow); |
|
void TimeStampDirtyVars(); |
|
|
|
int GetNumVars() const { return fVarsList.size(); } |
|
plSimpleStateVariable* GetVar(int i) const { return (plSimpleStateVariable*)fVarsList[i]; } |
|
int GetNumSDVars() const { return fSDVarsList.size(); } |
|
plSDStateVariable* GetSDVar(int i) const { return (plSDStateVariable*)fSDVarsList[i]; } |
|
|
|
// Used vars |
|
bool IsUsed() const { return (HasUsedVars() || HasUsedSDVars()); } |
|
|
|
int GetNumUsedVars() const { return IGetNumUsedVars(fVarsList); } |
|
int GetUsedVars(SimpleVarsList *vars) const { return IGetUsedVars(fVarsList, (VarsList*)vars); } // build a list of vars that have data |
|
bool HasUsedVars() const { return IHasUsedVars(fVarsList); } |
|
|
|
int GetNumUsedSDVars() const { return IGetNumUsedVars(fSDVarsList); } |
|
int GetUsedSDVars(SDVarsList *vars) const { return IGetUsedVars(fSDVarsList, (VarsList*)vars); } // build a list of SD vars that have data |
|
bool HasUsedSDVars() const { return IHasUsedVars(fSDVarsList); } |
|
|
|
// Dirty Vars |
|
bool IsDirty() const { return (HasDirtyVars() || HasDirtySDVars()); } |
|
|
|
int GetNumDirtyVars() const { return IGetNumDirtyVars(fVarsList); } |
|
int GetDirtyVars(SimpleVarsList *vars) const { return IGetDirtyVars(fVarsList, (VarsList*)vars); } // build a list of vars that are dirty |
|
bool HasDirtyVars() const { return IHasDirtyVars(fVarsList); } |
|
|
|
int GetNumDirtySDVars() const { return IGetNumDirtyVars(fSDVarsList); } |
|
int GetDirtySDVars(SDVarsList *vars) const { return IGetDirtyVars(fSDVarsList, (VarsList*)vars); }; // build a list of Sdvars that are dirty |
|
bool HasDirtySDVars() const { return IHasDirtyVars(fSDVarsList); } |
|
|
|
const plStateDescriptor* GetDescriptor() const { return fDescriptor; } |
|
void SetDescriptor(const char* sdName, int version); |
|
|
|
plNetMsgSDLState* PrepNetMsg(float timeConvert, UInt32 writeOptions) const; // create/prep a net msg with this data |
|
|
|
void SetAssocObject(const plUoid& u) { fAssocObject=u; } // optional |
|
plUoid* GetAssocObject() { return &fAssocObject; } // optional |
|
const plUoid* GetAssocObject() const { return &fAssocObject; } // optional |
|
|
|
// utils |
|
void FlagDifferentState(const plStateDataRecord& other); // mark items which differ from 'other' as dirty |
|
void FlagNewerState(const plStateDataRecord& other, bool respectAlwaysNew=false); // mark items which are newer than 'other' as dirty |
|
void FlagAlwaysNewState(); // mark 'alwaysNew' items as dirty |
|
void DumpToObjectDebugger(const char* msg, bool dirtyOnly=false, int level=0) const; |
|
void DumpToStream(hsStream* stream, const char* msg, bool dirtyOnly=false, int level=0) const; |
|
|
|
// IO |
|
bool Read(hsStream* s, float timeConvert, UInt32 readOptions=0); |
|
void Write(hsStream* s, float timeConvert, UInt32 writeOptions=0) const; |
|
|
|
static bool ReadStreamHeader(hsStream* s, char** name, int* version, plUoid* objUoid=nil); |
|
void WriteStreamHeader(hsStream* s, plUoid* objUoid=nil) const; |
|
}; |
|
|
|
// |
|
// Simple SDL parser |
|
// |
|
class plSDLMgr; |
|
class plSDLParser |
|
{ |
|
private: |
|
bool IReadDescriptors() const; |
|
bool ILoadSDLFile(const char* fileName) const; |
|
bool IParseVarDesc(const char* fileName, hsStream* stream, char token[], plStateDescriptor*& curDesc, |
|
plVarDescriptor*& curVar) const; |
|
bool IParseStateDesc(const char* fileName, hsStream* stream, char token[], plStateDescriptor*& curDesc) const; |
|
|
|
void DebugMsg(const char* fmt, ...) const; |
|
void DebugMsgV(const char* fmt, va_list args) const; |
|
|
|
public: |
|
|
|
bool Parse() const; // reads sdl folder, creates descriptor list |
|
}; |
|
|
|
// |
|
// Holds, loads and unloads all state descriptors from sdl files. |
|
// Singleton. |
|
// |
|
class plNetApp; |
|
class plSDLMgr |
|
{ |
|
friend class plSDLParser; |
|
private: |
|
std::string fSDLDir; |
|
plSDL::DescriptorList fDescriptors; |
|
plNetApp* fNetApp; |
|
UInt32 fBehaviorFlags; |
|
|
|
void IDeleteDescriptors(plSDL::DescriptorList* dl); |
|
public: |
|
plSDLMgr(); |
|
~plSDLMgr(); |
|
|
|
static plSDLMgr* GetInstance(); |
|
plStateDescriptor* FindDescriptor(const char* name, int version, const plSDL::DescriptorList * dl=nil) const; // version or kLatestVersion |
|
|
|
const plSDL::DescriptorList * GetDescriptors( void ) const { return &fDescriptors;} |
|
|
|
void SetSDLDir(const char* s) { fSDLDir=s; } |
|
const char* GetSDLDir() const { return fSDLDir.c_str(); } |
|
|
|
void SetNetApp(plNetApp* a) { fNetApp=a; } |
|
plNetApp* GetNetApp() const { return fNetApp; } |
|
|
|
bool Init( UInt32 behaviorFlags=0 ); // parse sdl folder |
|
void DeInit(); |
|
UInt32 GetBehaviorFlags() const { return fBehaviorFlags; } |
|
void SetBehaviorFlags(UInt32 v) { fBehaviorFlags=v; } |
|
bool AllowTimeStamping() const { return ! ( fBehaviorFlags&plSDL::kDisallowTimeStamping ); } |
|
|
|
// I/O - return # of bytes read/written |
|
int Write(hsStream* s, const plSDL::DescriptorList* dl=nil); // write descriptors to a stream |
|
int Read(hsStream* s, plSDL::DescriptorList* dl=nil); // read descriptors into provided list (use legacyList if nil) |
|
}; |
|
|
|
#endif // PL_SDL_inc
|
|
|