mirror of
https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
synced 2025-07-19 19:59:09 +00:00
Hoist MOULOpenSourceClientPlugin/Plasma20/* to top level
to match H'uru layout and make patching/cherry-picking easier.
This commit is contained in:
rarified
616
Sources/Plasma/NucleusLib/pnNetCommon/plSynchedObject.cpp
Normal file
616
Sources/Plasma/NucleusLib/pnNetCommon/plSynchedObject.cpp
Normal file
@ -0,0 +1,616 @@
|
||||
/*==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==*/
|
||||
#include "plSynchedObject.h"
|
||||
#include "plSynchedValue.h"
|
||||
#include "plNetApp.h"
|
||||
#include "plNetGroup.h"
|
||||
#include "hsResMgr.h"
|
||||
#include "../pnSceneObject/plSceneObject.h"
|
||||
#include "../pnKeyedObject/plKey.h"
|
||||
#include "../pnMessage/plSDLModifierMsg.h"
|
||||
#include "../pnMessage/plSetNetGroupIDMsg.h"
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
// statics
|
||||
plSynchedObject* plSynchedObject::fStaticSynchedObj=nil;
|
||||
std::vector<plSynchedObject::StateDefn> plSynchedObject::fDirtyStates;
|
||||
std::vector<hsBool> plSynchedObject::fSynchStateStack;
|
||||
|
||||
plSynchedObject::plSynchedObject() :
|
||||
fSynchFlags(0),
|
||||
#ifdef USE_SYNCHED_VALUES
|
||||
fSynchedValueAddrOffsets(nil),
|
||||
fNumSynchedValues(0),
|
||||
fSynchedValueFriends(nil),
|
||||
fNumSynchedValueFriends(0),
|
||||
#endif
|
||||
fNetGroup(plNetGroup::kNetGroupUnknown)
|
||||
{
|
||||
fStaticSynchedObj=this;
|
||||
}
|
||||
|
||||
plSynchedObject::~plSynchedObject()
|
||||
{
|
||||
#ifdef USE_SYNCHED_VALUES
|
||||
delete [] fSynchedValueAddrOffsets;
|
||||
delete [] fSynchedValueFriends;
|
||||
#endif
|
||||
}
|
||||
|
||||
hsBool plSynchedObject::MsgReceive(plMessage* msg)
|
||||
{
|
||||
plSetNetGroupIDMsg* setNetGroupID = plSetNetGroupIDMsg::ConvertNoRef(msg);
|
||||
if (setNetGroupID)
|
||||
{
|
||||
SetNetGroupConstant(setNetGroupID->fId);
|
||||
return true;
|
||||
}
|
||||
|
||||
return hsKeyedObject::MsgReceive(msg);
|
||||
}
|
||||
|
||||
#ifdef USE_SYNCHED_VALUES
|
||||
plSynchedValueBase* plSynchedObject::GetSynchedValue(int i) const
|
||||
{
|
||||
if (i<fNumSynchedValues)
|
||||
return IGetSynchedValue((NumSynchedValuesType)i);
|
||||
return IGetSynchedValueFriend((NumSynchedValuesType)(i-fNumSynchedValues));
|
||||
}
|
||||
|
||||
// realloc and add
|
||||
void plSynchedObject::IAppendSynchedValueAddrOffset(AddrOffsetType synchedValueAddrOffset)
|
||||
{
|
||||
// copy to new larger array
|
||||
AddrOffsetType* tmp = TRACKED_NEW AddrOffsetType[fNumSynchedValues+1];
|
||||
Int32 i;
|
||||
for(i=0;i<fNumSynchedValues;i++)
|
||||
tmp[i] = fSynchedValueAddrOffsets[i];
|
||||
|
||||
// delete old one
|
||||
delete [] fSynchedValueAddrOffsets;
|
||||
|
||||
// point to new array and append value
|
||||
fSynchedValueAddrOffsets=tmp;
|
||||
tmp[fNumSynchedValues++]=synchedValueAddrOffset;
|
||||
}
|
||||
|
||||
void plSynchedObject::IAppendSynchedValueFriend(plSynchedValueBase* v)
|
||||
{
|
||||
// copy to new larger array
|
||||
plSynchedValueBase** tmp = TRACKED_NEW plSynchedValueBase*[fNumSynchedValueFriends+1];
|
||||
Int32 i;
|
||||
for(i=0;i<fNumSynchedValueFriends;i++)
|
||||
tmp[i] = fSynchedValueFriends[i];
|
||||
|
||||
// delete old one
|
||||
delete [] fSynchedValueFriends;
|
||||
|
||||
// point to new array and append value
|
||||
fSynchedValueFriends=tmp;
|
||||
tmp[fNumSynchedValueFriends++]=v;
|
||||
}
|
||||
|
||||
// adds synchedValue and returns index
|
||||
UInt8 plSynchedObject::RegisterSynchedValue(plSynchedValueBase* v)
|
||||
{
|
||||
Int32 addrOff = ((Int32)v - (Int32)this)>>2;
|
||||
hsAssert(hsABS(addrOff) < (UInt32)(1<<(sizeof(AddrOffsetType)<<3)), "address offset overflow");
|
||||
IAppendSynchedValueAddrOffset((AddrOffsetType)addrOff);
|
||||
Int32 idx = fNumSynchedValues-1;
|
||||
hsAssert(idx<256, "index too big");
|
||||
return (UInt8)idx;
|
||||
}
|
||||
|
||||
hsBool plSynchedObject::RemoveSynchedValue(plSynchedValueBase* v)
|
||||
{
|
||||
int i;
|
||||
for(i=0;i<GetNumSynchedValues(); i++)
|
||||
if (GetSynchedValue(i)==v)
|
||||
break;
|
||||
|
||||
// couldn't find it
|
||||
if (i==GetNumSynchedValues())
|
||||
return false;
|
||||
|
||||
int idx=i;
|
||||
if (idx<fNumSynchedValues)
|
||||
{
|
||||
AddrOffsetType* tmp = TRACKED_NEW AddrOffsetType[fNumSynchedValues-1];
|
||||
for(i=0;i<idx;i++)
|
||||
tmp[i] = fSynchedValueAddrOffsets[i];
|
||||
for(i=idx+1;i<fNumSynchedValues;i++)
|
||||
tmp[i-1] = fSynchedValueAddrOffsets[i];
|
||||
delete [] fSynchedValueAddrOffsets;
|
||||
fSynchedValueAddrOffsets=tmp;
|
||||
fNumSynchedValues--;
|
||||
}
|
||||
else
|
||||
{
|
||||
idx -= fNumSynchedValues;
|
||||
plSynchedValueBase** tmp = TRACKED_NEW plSynchedValueBase*[fNumSynchedValueFriends-1];
|
||||
for(i=0;i<idx;i++)
|
||||
tmp[i] = fSynchedValueFriends[i];
|
||||
for(i=idx+1;i<fNumSynchedValueFriends;i++)
|
||||
tmp[i-1] = fSynchedValueFriends[i];
|
||||
delete [] fSynchedValueFriends;
|
||||
fSynchedValueFriends=tmp;
|
||||
fNumSynchedValueFriends--;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// adds synchedValueFriend
|
||||
void plSynchedObject::RegisterSynchedValueFriend(plSynchedValueBase* v)
|
||||
{
|
||||
IAppendSynchedValueFriend(v);
|
||||
}
|
||||
#endif
|
||||
|
||||
//
|
||||
// send sdl state msg immediately
|
||||
//
|
||||
void plSynchedObject::SendSDLStateMsg(const char* SDLStateName, UInt32 synchFlags /*SendSDLStateFlags*/)
|
||||
{
|
||||
plSDLModifierMsg* sdlMsg = TRACKED_NEW plSDLModifierMsg(SDLStateName,
|
||||
(synchFlags & kBCastToClients) ? plSDLModifierMsg::kSendToServerAndClients : plSDLModifierMsg::kSendToServer /* action */);
|
||||
sdlMsg->SetFlags(synchFlags);
|
||||
hsAssert(GetKey(), "nil key on synchedObject?");
|
||||
sdlMsg->Send(GetKey());
|
||||
}
|
||||
|
||||
//
|
||||
// Tell an object to send an sdl state update.
|
||||
// The request will get queued (returns true)
|
||||
//
|
||||
hsBool plSynchedObject::DirtySynchState(const char* SDLStateName, UInt32 synchFlags /*SendSDLStateFlags*/)
|
||||
{
|
||||
if (!IOKToDirty(SDLStateName))
|
||||
{
|
||||
#if 0
|
||||
if (plNetClientApp::GetInstance())
|
||||
plNetClientApp::GetInstance()->DebugMsg("NotOKToDirty - Not queueing SDL state, obj %s, sdl %s",
|
||||
GetKeyName(), SDLStateName);
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!IOKToNetwork(SDLStateName, &synchFlags))
|
||||
{
|
||||
#if 0
|
||||
if (plNetClientApp::GetInstance())
|
||||
plNetClientApp::GetInstance()->DebugMsg("LocalOnly Object - Not queueing SDL msg, obj %s, sdl %s",
|
||||
GetKeyName(), SDLStateName);
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!(synchFlags & kSkipLocalOwnershipCheck))
|
||||
{
|
||||
int localOwned=IsLocallyOwned();
|
||||
if (localOwned==plSynchedObject::kNo)
|
||||
return false;
|
||||
if (localOwned==plSynchedObject::kYes)
|
||||
synchFlags |= kSkipLocalOwnershipCheck; // don't have to check again
|
||||
else
|
||||
{
|
||||
if (plNetClientApp::GetInstance())
|
||||
plNetClientApp::GetInstance()->DebugMsg("Queueing SDL state with 'maybe' ownership, obj %s, sdl %s",
|
||||
GetKeyName(), SDLStateName);
|
||||
}
|
||||
}
|
||||
|
||||
if (synchFlags & kSendImmediately)
|
||||
{
|
||||
SendSDLStateMsg(SDLStateName, synchFlags);
|
||||
}
|
||||
else
|
||||
{
|
||||
IAddDirtyState(GetKey(), SDLStateName, synchFlags);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
//
|
||||
// STATIC
|
||||
// add state defn if not already there.
|
||||
// if there adjust flags if necessary
|
||||
//
|
||||
void plSynchedObject::IAddDirtyState(plKey objKey, const char* sdlName, UInt32 sendFlags)
|
||||
{
|
||||
bool found=false;
|
||||
std::vector<StateDefn>::iterator it=fDirtyStates.begin();
|
||||
for( ; it != fDirtyStates.end(); it++)
|
||||
{
|
||||
if ((*it).fObjKey==objKey && !stricmp((*it).fSDLName.c_str(), sdlName))
|
||||
{
|
||||
if (sendFlags & kForceFullSend)
|
||||
(*it).fSendFlags |= kForceFullSend;
|
||||
if (sendFlags & kBCastToClients)
|
||||
(*it).fSendFlags |= kBCastToClients;
|
||||
found=true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!found)
|
||||
{
|
||||
StateDefn state(objKey, sendFlags, sdlName);
|
||||
fDirtyStates.push_back(state);
|
||||
}
|
||||
else
|
||||
{
|
||||
#if 0
|
||||
plNetClientApp::GetInstance()->DebugMsg("Not queueing diplicate request for SDL state, obj %s, sdl %s",
|
||||
objKey->GetName(), sdlName);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// STATIC
|
||||
//
|
||||
void plSynchedObject::IRemoveDirtyState(plKey objKey, const char* sdlName)
|
||||
{
|
||||
std::vector<StateDefn>::iterator it=fDirtyStates.begin();
|
||||
for( ; it != fDirtyStates.end(); it++)
|
||||
{
|
||||
if ((*it).fObjKey==objKey && !stricmp((*it).fSDLName.c_str(), sdlName))
|
||||
{
|
||||
fDirtyStates.erase(it);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void plSynchedObject::SetNetGroupConstant(plNetGroupId netGroup)
|
||||
{
|
||||
ClearSynchFlagsBit(kHasConstantNetGroup);
|
||||
SetNetGroup(netGroup); // may recurse
|
||||
SetSynchFlagsBit(kHasConstantNetGroup);
|
||||
}
|
||||
|
||||
plNetGroupId plSynchedObject::SelectNetGroup(plKey rmKey)
|
||||
{
|
||||
return plNetClientApp::GetInstance() ?
|
||||
plNetClientApp::GetInstance()->SelectNetGroup(this, rmKey) : plNetGroup::kNetGroupUnknown;
|
||||
}
|
||||
|
||||
plNetGroupId plSynchedObject::GetEffectiveNetGroup() const
|
||||
{
|
||||
return plNetClientApp::GetInstance() ?
|
||||
plNetClientApp::GetInstance()->GetEffectiveNetGroup(this) : plNetGroup::kNetGroupLocalPlayer;
|
||||
}
|
||||
|
||||
int plSynchedObject::IsLocallyOwned() const
|
||||
{
|
||||
return plNetClientApp::GetInstance() ?
|
||||
plNetClientApp::GetInstance()->IsLocallyOwned(this) : kYes;
|
||||
}
|
||||
|
||||
void plSynchedObject::Read(hsStream* stream, hsResMgr* mgr)
|
||||
{
|
||||
hsKeyedObject::Read(stream, mgr);
|
||||
fNetGroup = GetKey()->GetUoid().GetLocation();
|
||||
|
||||
stream->ReadSwap(&fSynchFlags);
|
||||
if (fSynchFlags & kExcludePersistentState)
|
||||
{
|
||||
Int16 num;
|
||||
stream->ReadSwap(&num);
|
||||
fSDLExcludeList.clear();
|
||||
int i;
|
||||
for(i=0;i<num;i++)
|
||||
{
|
||||
std::string s;
|
||||
plMsgStdStringHelper::Peek(s, stream);
|
||||
fSDLExcludeList.push_back(s);
|
||||
}
|
||||
}
|
||||
|
||||
if (fSynchFlags & kHasVolatileState)
|
||||
{
|
||||
Int16 num;
|
||||
stream->ReadSwap(&num);
|
||||
fSDLVolatileList.clear();
|
||||
int i;
|
||||
for(i=0;i<num;i++)
|
||||
{
|
||||
std::string s;
|
||||
plMsgStdStringHelper::Peek(s, stream);
|
||||
fSDLVolatileList.push_back(s);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void plSynchedObject::Write(hsStream* stream, hsResMgr* mgr)
|
||||
{
|
||||
hsKeyedObject::Write(stream, mgr);
|
||||
stream->WriteSwap(fSynchFlags);
|
||||
|
||||
if (fSynchFlags & kExcludePersistentState)
|
||||
{
|
||||
Int16 num=fSDLExcludeList.size();
|
||||
stream->WriteSwap(num);
|
||||
|
||||
SDLStateList::iterator it=fSDLExcludeList.begin();
|
||||
for(; it != fSDLExcludeList.end(); it++)
|
||||
{
|
||||
plMsgStdStringHelper::Poke(*it, stream);
|
||||
}
|
||||
}
|
||||
|
||||
if (fSynchFlags & kHasVolatileState)
|
||||
{
|
||||
Int16 num=fSDLVolatileList.size();
|
||||
stream->WriteSwap(num);
|
||||
|
||||
SDLStateList::iterator it=fSDLVolatileList.begin();
|
||||
for(; it != fSDLVolatileList.end(); it++)
|
||||
{
|
||||
plMsgStdStringHelper::Poke(*it, stream);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// static
|
||||
//
|
||||
hsBool plSynchedObject::PopSynchDisabled()
|
||||
{
|
||||
if (fSynchStateStack.size())
|
||||
{
|
||||
hsBool ret=fSynchStateStack.back();
|
||||
fSynchStateStack.pop_back();
|
||||
return ret;
|
||||
}
|
||||
else
|
||||
{
|
||||
hsAssert(false, "invalid stack size?");
|
||||
}
|
||||
return true; // disabled
|
||||
}
|
||||
|
||||
#ifdef USE_DIRTY_NOTIFIERS
|
||||
void plSynchedObject::AddDirtyNotifier(plDirtyNotifier* dn)
|
||||
{
|
||||
if (dn)
|
||||
{
|
||||
std::vector<plDirtyNotifier*>::iterator it=std::find(fDirtyNotifiers.begin(), fDirtyNotifiers.end(), dn);
|
||||
if (it == fDirtyNotifiers.end()) // not there
|
||||
{
|
||||
dn->SetSynchedObjKey(GetKey());
|
||||
fDirtyNotifiers.push_back(dn);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void plSynchedObject::RemoveDirtyNotifier(plDirtyNotifier* dn)
|
||||
{
|
||||
if (dn)
|
||||
{
|
||||
std::vector<plDirtyNotifier*>::iterator it=std::find(fDirtyNotifiers.begin(), fDirtyNotifiers.end(), dn);
|
||||
if (it != fDirtyNotifiers.end()) // its there
|
||||
fDirtyNotifiers.erase(it);
|
||||
}
|
||||
}
|
||||
|
||||
void plSynchedObject::CallDirtyNotifiers()
|
||||
{
|
||||
int i;
|
||||
for(i=0;i<fDirtyNotifiers.size();i++)
|
||||
fDirtyNotifiers[i]->Callback();
|
||||
}
|
||||
#else
|
||||
void plSynchedObject::CallDirtyNotifiers() {}
|
||||
#endif
|
||||
|
||||
//
|
||||
// return true if it's ok to dirty this object
|
||||
//
|
||||
bool plSynchedObject::IOKToDirty(const char* SDLStateName) const
|
||||
{
|
||||
// is synching disabled?
|
||||
bool synchDisabled = (GetSynchDisabled()!=0);
|
||||
if (synchDisabled)
|
||||
return false;
|
||||
|
||||
// is object dirtyAble?
|
||||
bool dontDirty = (fSynchFlags & kDontDirty) != 0;
|
||||
if (dontDirty)
|
||||
return false;
|
||||
|
||||
// is object in a LocalOnly age?
|
||||
if (plNetClientApp::GetConstInstance() && plNetClientApp::GetConstInstance()->ObjectInLocalAge(this))
|
||||
return false;
|
||||
|
||||
return true; // OK to dirty
|
||||
}
|
||||
|
||||
//
|
||||
// return true if this object should send his SDL msg (for persistence or synch) over the net
|
||||
//
|
||||
bool plSynchedObject::IOKToNetwork(const char* sdlName, UInt32* synchFlags) const
|
||||
{
|
||||
// determine destination
|
||||
bool dstServerOnly=false, dstClientsOnly=false, dstClientsAndServer=false;
|
||||
|
||||
if ((*synchFlags) & kBCastToClients)
|
||||
{ // bcasting to clients and server
|
||||
if ((*synchFlags) & kDontPersistOnServer)
|
||||
dstClientsOnly=true;
|
||||
else
|
||||
dstClientsAndServer=true;
|
||||
}
|
||||
else
|
||||
{ // not bcasting, must be sending to server only
|
||||
hsAssert( ((*synchFlags) & kDontPersistOnServer)==0, "invalid synchedObject msg flag");
|
||||
dstServerOnly=true;
|
||||
}
|
||||
|
||||
bool netSynched = IsNetSynched();
|
||||
bool inExcludeList = IsInSDLExcludeList(sdlName);
|
||||
|
||||
//
|
||||
// check if ok to network based on destination
|
||||
//
|
||||
if (dstClientsOnly)
|
||||
{
|
||||
return netSynched;
|
||||
}
|
||||
|
||||
if (dstClientsAndServer)
|
||||
{
|
||||
if ( !netSynched )
|
||||
{
|
||||
*synchFlags &= ~kBCastToClients; // don't send to clients
|
||||
}
|
||||
if ( inExcludeList )
|
||||
{
|
||||
*synchFlags |= kDontPersistOnServer; // don't store on server
|
||||
}
|
||||
|
||||
return !inExcludeList || netSynched;
|
||||
}
|
||||
|
||||
if (dstServerOnly)
|
||||
{
|
||||
return !inExcludeList;
|
||||
}
|
||||
|
||||
hsAssert(false, "how did I get here");
|
||||
return false;
|
||||
}
|
||||
|
||||
plSynchedObject::SDLStateList::const_iterator plSynchedObject::IFindInSDLStateList(const SDLStateList& list, const char* sdlName) const
|
||||
{
|
||||
if (!sdlName)
|
||||
return list.end(); // false
|
||||
|
||||
SDLStateList::const_iterator it = list.begin();
|
||||
for(; it != list.end(); it++)
|
||||
if (!_stricmp((*it).c_str(), sdlName))
|
||||
return it;
|
||||
|
||||
return it; // .end(), false
|
||||
}
|
||||
|
||||
///////////////////////////
|
||||
// EXCLUDE LIST
|
||||
///////////////////////////
|
||||
|
||||
void plSynchedObject::AddToSDLExcludeList(const char* sdlName)
|
||||
{
|
||||
if (sdlName)
|
||||
{
|
||||
if (IFindInSDLStateList(fSDLExcludeList, sdlName)==fSDLExcludeList.end())
|
||||
{
|
||||
fSDLExcludeList.push_back(sdlName); // Don't dupe sdlName, std::string will copy
|
||||
fSynchFlags |= kExcludePersistentState;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void plSynchedObject::RemoveFromSDLExcludeList(const char* sdlName)
|
||||
{
|
||||
SDLStateList::const_iterator it=IFindInSDLStateList(fSDLExcludeList, sdlName);
|
||||
if (it != fSDLExcludeList.end())
|
||||
{
|
||||
fSDLExcludeList.erase(fSDLExcludeList.begin()+(it-fSDLExcludeList.begin()));
|
||||
if (fSDLExcludeList.size()==0)
|
||||
fSynchFlags &= ~kExcludePersistentState;
|
||||
}
|
||||
}
|
||||
|
||||
bool plSynchedObject::IsInSDLExcludeList(const char* sdlName) const
|
||||
{
|
||||
if ((fSynchFlags & kExcludeAllPersistentState) != 0)
|
||||
return true;
|
||||
|
||||
if ((fSynchFlags & kExcludePersistentState) == 0)
|
||||
return false;
|
||||
|
||||
SDLStateList::const_iterator it=IFindInSDLStateList(fSDLExcludeList, sdlName);
|
||||
return (it != fSDLExcludeList.end());
|
||||
}
|
||||
|
||||
///////////////////////////
|
||||
// VOLATILE LIST
|
||||
///////////////////////////
|
||||
|
||||
void plSynchedObject::AddToSDLVolatileList(const char* sdlName)
|
||||
{
|
||||
if (sdlName)
|
||||
{
|
||||
if (IFindInSDLStateList(fSDLVolatileList,sdlName)==fSDLVolatileList.end())
|
||||
{
|
||||
fSDLVolatileList.push_back(sdlName); // Don't dupe sdlName, std::string will copy
|
||||
fSynchFlags |= kHasVolatileState;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void plSynchedObject::RemoveFromSDLVolatileList(const char* sdlName)
|
||||
{
|
||||
SDLStateList::const_iterator it=IFindInSDLStateList(fSDLVolatileList,sdlName);
|
||||
if (it != fSDLVolatileList.end())
|
||||
{
|
||||
fSDLVolatileList.erase(fSDLVolatileList.begin()+(it-fSDLVolatileList.begin()));
|
||||
if (fSDLVolatileList.size()==0)
|
||||
fSynchFlags &= ~kHasVolatileState;
|
||||
}
|
||||
}
|
||||
|
||||
bool plSynchedObject::IsInSDLVolatileList(const char* sdlName) const
|
||||
{
|
||||
if ((fSynchFlags & kAllStateIsVolatile) != 0)
|
||||
return true;
|
||||
|
||||
if ((fSynchFlags & kHasVolatileState) == 0)
|
||||
return false;
|
||||
|
||||
SDLStateList::const_iterator it=IFindInSDLStateList(fSDLVolatileList,sdlName);
|
||||
return (it != fSDLVolatileList.end());
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user