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.
1827 lines
54 KiB
1827 lines
54 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/>. |
|
|
|
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 "plResManager.h" |
|
#include "plRegistryNode.h" |
|
#include "plResManagerHelper.h" |
|
#include "plResMgrSettings.h" |
|
#include "plLocalization.h" |
|
#include "hsSTLStream.h" |
|
|
|
#include "hsTimer.h" |
|
#include "pnTimer/plTimerCallbackManager.h" |
|
#include "hsStlUtils.h" |
|
|
|
#include "plScene/plSceneNode.h" |
|
#include "pnKeyedObject/hsKeyedObject.h" |
|
#include "pnKeyedObject/plFixedKey.h" |
|
#include "pnKeyedObject/plKeyImp.h" |
|
#include "pnDispatch/plDispatch.h" |
|
#include "plStatusLog/plStatusLog.h" |
|
#include "pnMessage/plRefMsg.h" |
|
#include "pnMessage/plObjRefMsg.h" |
|
#include "plMessage/plAgeLoadedMsg.h" |
|
#include "pnMessage/plClientMsg.h" |
|
#include "plFile/hsFiles.h" |
|
#include "plFile/plFileUtils.h" |
|
#include "pnFactory/plCreator.h" |
|
#include "pnNetCommon/plSynchedObject.h" |
|
#include "pnNetCommon/plNetApp.h" |
|
|
|
hsBool gDataServerLocal = false; |
|
|
|
/// Logging #define for easier use |
|
#define kResMgrLog(level, log) if (plResMgrSettings::Get().GetLoggingLevel() >= level) log |
|
|
|
static void ILog(UInt8 level, const char* format, ...) |
|
{ |
|
static plStatusLog* log = plStatusLogMgr::GetInstance().CreateStatusLog |
|
( |
|
plStatusLogMgr::kDefaultNumLines, |
|
"resources.log", |
|
plStatusLog::kFilledBackground | plStatusLog::kDeleteForMe |
|
); |
|
|
|
va_list arguments; |
|
va_start(arguments, format); |
|
|
|
UInt32 color = 0; |
|
switch (level) |
|
{ |
|
case 1: color = 0xffffffff; break; |
|
case 2: color = 0xff8080ff; break; |
|
case 3: color = 0xffffff80; break; |
|
case 4: color = 0xff8080ff; break; |
|
} |
|
|
|
log->AddLineV(color, format, arguments); |
|
} |
|
|
|
plResManager::plResManager(): |
|
fInited(false), |
|
fPageOutHint(0), |
|
fDispatch(nil), |
|
fReadingObject( false ), |
|
fCurCloneID(0), |
|
fCurClonePlayerID(0), |
|
fCloningCounter(0), |
|
fProgressProc(nil), |
|
fMyHelper(nil), |
|
fLogReadTimes(false), |
|
fPageListLock(0), |
|
fPagesNeedCleanup(false), |
|
fLastFoundPage(nil) |
|
{ |
|
#ifdef HS_DEBUGGING |
|
plFactory::Validate(hsKeyedObject::Index()); |
|
#endif |
|
} |
|
|
|
plResManager::~plResManager() |
|
{ |
|
// verify shutDown |
|
hsAssert(!fInited,"ResMgr not shutdown"); |
|
} |
|
|
|
hsBool plResManager::IInit() |
|
{ |
|
if (fInited) |
|
return true; |
|
fInited = true; |
|
|
|
kResMgrLog(1, ILog(1, "Initializing resManager...")); |
|
|
|
if (plResMgrSettings::Get().GetLoadPagesOnInit()) |
|
{ |
|
// We want to go through all the data files in our data path and add new |
|
// plRegistryPageNodes to the regTree for each |
|
hsFolderIterator pathIterator(fDataPath.c_str()); |
|
while (pathIterator.NextFileSuffix(".prp")) |
|
{ |
|
char fileName[kFolderIterator_MaxPath]; |
|
pathIterator.GetPathAndName(fileName); |
|
|
|
plRegistryPageNode* node = TRACKED_NEW plRegistryPageNode(fileName); |
|
fAllPages.insert(node); |
|
} |
|
} |
|
|
|
// Special case: we always create pages for the predefined pages |
|
CreatePage(plLocation::kGlobalFixedLoc, "Global", "FixedKeys"); |
|
|
|
hsAssert(!fDispatch, "Dispatch already set"); |
|
fDispatch = TRACKED_NEW plDispatch; |
|
|
|
plgTimerCallbackMgr::Init(); |
|
|
|
// Init our helper |
|
fMyHelper = TRACKED_NEW plResManagerHelper(this); |
|
fMyHelper->Init(); |
|
hsAssert(fMyHelper->GetKey() != nil, "ResManager helper didn't init properly!" ); |
|
|
|
kResMgrLog(1, ILog(1, " ...Init was successful!")); |
|
|
|
return true; |
|
} |
|
|
|
hsBool plResManager::IReset() // Used to Re-Export (number of times) |
|
{ |
|
BeginShutdown(); |
|
IShutdown(); |
|
return IInit(); |
|
} |
|
|
|
void plResManager::BeginShutdown() |
|
{ |
|
if (fMyHelper) |
|
fMyHelper->SetInShutdown(true); |
|
} |
|
|
|
void plResManager::IShutdown() |
|
{ |
|
if (!fInited) |
|
return; |
|
|
|
kResMgrLog(1, ILog(1, "Shutting down resManager...")); |
|
|
|
// Make sure we're not holding on to any ages for load optimization |
|
IDropAllAgeKeys(); |
|
|
|
// At this point, we may have an undelivered future time stamped message |
|
// in the Dispatch, which is reffing a bunch of keys we "temporarily" loaded. |
|
// The obvious problems with that solution to avoid loading and unloading |
|
// and reloading keys aside, those keys will continue to exist until the |
|
// dispatch is destroyed, so they will show up as key leaks in the report. |
|
// But they won't show up as memory leaks, because they'll be destroyed |
|
// when the Dispatch is destructed. |
|
// Update - now we call BeginShutdown, well, at the beginning of Shutdown. |
|
// We pass that on to the Helper, so it knows to immediately dump the keys |
|
// for any pages it loads, cuz there's no tomorrow. |
|
|
|
IPageOutSceneNodes(false); |
|
|
|
// Shut down our helper |
|
fMyHelper->Shutdown(); // This will call UnregisterAs(), which will delete itself |
|
fMyHelper = nil; |
|
|
|
// TimerCallbackMgr is a fixed-keyed object, so needs to shut down before the registry |
|
plgTimerCallbackMgr::Shutdown(); |
|
|
|
// Destroy the dispatch. Note that we do this before the registry so that any lingering messages |
|
// can free up keys properly |
|
hsRefCnt_SafeUnRef(fDispatch); |
|
fDispatch = nil; |
|
|
|
// Just before we shut down the registry, page out any keys that still exist. |
|
// (They shouldn't... they're baaaaaad.) |
|
IPageOutSceneNodes(true); |
|
|
|
// Shut down the registry (finally!) |
|
ILockPages(); |
|
|
|
PageSet::const_iterator it; |
|
for (it = fAllPages.begin(); it != fAllPages.end(); it++) |
|
delete *it; |
|
fAllPages.clear(); |
|
fLoadedPages.clear(); |
|
|
|
IUnlockPages(); |
|
|
|
fLastFoundPage = nil; |
|
|
|
kResMgrLog(1, ILog(1, " ...Shutdown successful!")); |
|
|
|
fInited = false; |
|
} |
|
|
|
void plResManager::AddSinglePage(const char* pagePath) |
|
{ |
|
plRegistryPageNode* node = TRACKED_NEW plRegistryPageNode(pagePath); |
|
AddPage(node); |
|
} |
|
|
|
plRegistryPageNode* plResManager::FindSinglePage(const char* path) const |
|
{ |
|
PageSet::const_iterator it; |
|
for (it = fAllPages.begin(); it != fAllPages.end(); it++) |
|
{ |
|
if (hsStrCaseEQ((*it)->GetPagePath(), path)) |
|
return *it; |
|
} |
|
|
|
return nil; |
|
} |
|
|
|
void plResManager::RemoveSinglePage(const char* path) |
|
{ |
|
plRegistryPageNode* node = FindSinglePage(path); |
|
if (node) |
|
{ |
|
fAllPages.erase(node); |
|
delete node; |
|
} |
|
} |
|
|
|
plDispatchBase *plResManager::Dispatch() |
|
{ |
|
return fDispatch; |
|
} |
|
|
|
|
|
void plResManager::LogReadTimes(hsBool logReadTimes) |
|
{ |
|
fLogReadTimes = logReadTimes; |
|
if (fLogReadTimes) |
|
{ |
|
plStatusLog::AddLineS("readtimings.log", plStatusLog::kWhite, "Created readtimings log"); |
|
} |
|
} |
|
|
|
hsKeyedObject* plResManager::IGetSharedObject(plKeyImp* pKey) |
|
{ |
|
plKeyImp* origKey = (plKeyImp*)pKey->GetCloneOwner(); |
|
|
|
// Find the first non-nil key and ask it to clone itself |
|
UInt32 count = origKey->GetNumClones(); |
|
for (UInt32 i = 0; i < count; i++) |
|
{ |
|
plKey cloneKey = origKey->GetCloneByIdx(i); |
|
if (cloneKey) |
|
{ |
|
hsKeyedObject* obj = cloneKey->ObjectIsLoaded(); |
|
if (obj) |
|
{ |
|
hsKeyedObject* sharedObj = obj->GetSharedObject(); |
|
if (sharedObj) |
|
return sharedObj; |
|
} |
|
} |
|
} |
|
|
|
return nil; |
|
} |
|
|
|
//// ReadObject ///////////////////////////////////////////////////////////// |
|
// Given a key, goes off and reads in the actual object from its source |
|
hsBool plResManager::ReadObject(plKeyImp* key) |
|
{ |
|
// Read in the object. If while we are doing this something else requests a |
|
// load (through AddViaNotify or ReadKeyNotifyMe) we consider it a child load |
|
// and put it in a queue. This keeps us from jumping over to another object's |
|
// data while we're still reading in its parent (which is bad because that |
|
// trashes our file buffering) |
|
// |
|
// Also, we find the pageNode and open its stream here. We close the |
|
// stream when child reads are done. If a child load is using the same stream, |
|
// it will just inc/dec the open/close count during its read, and not actually |
|
// close the stream, so we don't lose our place, lose our file handle, and thrash. |
|
|
|
char locstr[64]; |
|
kResMgrLog(4, ILog(4, " ...Opening page data stream for location %s...", key->GetUoid().GetLocation().StringIze(locstr))); |
|
plRegistryPageNode *pageNode = FindPage(key->GetUoid().GetLocation()); |
|
if (!pageNode) |
|
{ |
|
kResMgrLog(3, ILog(3, " ...Data stream failed to open on read!")); |
|
return false; |
|
} |
|
fReadingObject = true; |
|
bool ret = IReadObject(key, pageNode->OpenStream()); |
|
fReadingObject = false; |
|
|
|
if (!fQueuedReads.empty()) |
|
{ |
|
// Now that the parent object is completely read in, we can do the child |
|
// loads. We copy off all the children that were queued during our load so |
|
// that we won't get our children's child loads mixed in (a parent only loads |
|
// its immediate children) |
|
std::vector<plKey> children = fQueuedReads; |
|
fQueuedReads.clear(); |
|
|
|
for (int i = 0; i < children.size(); i++) |
|
{ |
|
plKey childKey = children[i]; |
|
childKey->VerifyLoaded(); |
|
} |
|
} |
|
|
|
// we're done loading, and all our children are too, so send the notify |
|
key->NotifyCreated(); |
|
|
|
pageNode->CloseStream(); |
|
|
|
return ret; |
|
} |
|
|
|
hsBool plResManager::IReadObject(plKeyImp* pKey, hsStream *stream) |
|
{ |
|
static UInt64 totalTime = 0; |
|
|
|
UInt64 startTotalTime = totalTime; |
|
UInt64 startTime = 0; |
|
if (fLogReadTimes) |
|
startTime = hsTimer::GetFullTickCount(); |
|
|
|
hsKeyedObject* ko = nil; |
|
|
|
hsAssert(pKey, "Null Key"); |
|
if (pKey->GetUoid().GetLoadMask().DontLoad()) |
|
return nil; |
|
|
|
hsAssert(pKey->GetStartPos() != UInt32(-1), "Missing StartPos"); |
|
hsAssert(pKey->GetDataLen() != UInt32(-1), "Missing Data Length"); |
|
|
|
if (pKey->GetStartPos() == UInt32(-1) || pKey->GetDataLen() == UInt32(-1)) |
|
return false; // Try to recover from this by just not reading an object |
|
|
|
kResMgrLog(3, ILog(3, " Reading object %s::%s", plFactory::GetNameOfClass(pKey->GetUoid().GetClassType()), pKey->GetUoid().GetObjectName())); |
|
|
|
const plUoid& uoid = pKey->GetUoid(); |
|
|
|
bool isClone = uoid.IsClone(); |
|
|
|
kResMgrLog(4, ILog(4, " ...is%s a clone", isClone ? "" : " not")); |
|
|
|
// If we're loading the root object of a clone (the object for the key that |
|
// was actually cloned), set up the global cloning flags so any child objects |
|
// read in will get them. Also turn off synching until the object is fully |
|
// loaded, so we don't send out any partially loaded state. |
|
bool setClone = false; |
|
if (isClone && fCurCloneID != uoid.GetCloneID()) |
|
{ |
|
kResMgrLog(4, ILog(4, " ...fCurCloneID = %d, uoid's cloneID = %d", fCurCloneID, uoid.GetCloneID())); |
|
|
|
if (fCurCloneID != 0) |
|
{ |
|
hsAssert(false, "Recursive clone"); |
|
kResMgrLog(3, ILog(3, " ...RECURSIVE CLONE DETECTED. ABORTING READ...")); |
|
return false; |
|
} |
|
fCurClonePlayerID = uoid.GetClonePlayerID(); |
|
fCurCloneID = uoid.GetCloneID(); |
|
setClone = true; |
|
|
|
kResMgrLog(4, ILog(4, " ...now fCurCloneID = %d, fCurClonePlayerID = %d", fCurCloneID, fCurClonePlayerID)); |
|
} |
|
|
|
// If this is a clone key, try and get the original object to give us a clone |
|
if (isClone) |
|
{ |
|
kResMgrLog(4, ILog(4, " ...Trying to get shared object...")); |
|
ko = IGetSharedObject(pKey); |
|
kResMgrLog(4, ILog(4, " ...IGetSharedObject() %s", (ko != nil) ? "succeeded" : "failed")); |
|
} |
|
|
|
// If we couldn't share the object, read in a fresh copy |
|
if (!ko) |
|
{ |
|
stream->SetPosition(pKey->GetStartPos()); |
|
kResMgrLog(4, ILog(4, " ...Reading from position %d bytes...", pKey->GetStartPos())); |
|
|
|
plCreatable* cre = ReadCreatable(stream); |
|
hsAssert(cre, "Could not Create Object"); |
|
if (cre) |
|
{ |
|
ko = hsKeyedObject::ConvertNoRef(cre); |
|
|
|
if (ko != nil) |
|
kResMgrLog(4, ILog(4, " ...Creatable read and valid")); |
|
else |
|
kResMgrLog(3, ILog(3, " ...Creatable read from stream not keyed object!")); |
|
|
|
if (fProgressProc != nil) |
|
fProgressProc(plKey::Make(pKey)); |
|
} |
|
else |
|
{ |
|
kResMgrLog(3, ILog(3, " ...ERROR: Unable to read creatable from stream!")); |
|
} |
|
} |
|
|
|
if (isClone && setClone) |
|
{ |
|
fCurClonePlayerID = 0; |
|
fCurCloneID = 0; |
|
} |
|
|
|
kResMgrLog(4, ILog(4, " ...Read complete for object %s::%s", plFactory::GetNameOfClass(pKey->GetUoid().GetClassType()), pKey->GetUoid().GetObjectName())); |
|
|
|
if (fLogReadTimes) |
|
{ |
|
UInt64 ourTime = hsTimer::GetFullTickCount() - startTime; |
|
UInt64 childTime = totalTime - startTotalTime; |
|
ourTime -= childTime; |
|
|
|
plStatusLog::AddLineS("readtimings.log", plStatusLog::kWhite, "%s, %s, %u, %.1f", |
|
pKey->GetUoid().GetObjectName(), |
|
plFactory::GetNameOfClass(pKey->GetUoid().GetClassType()), |
|
pKey->GetDataLen(), |
|
hsTimer::FullTicksToMs(ourTime)); |
|
|
|
totalTime += (hsTimer::GetFullTickCount() - startTime) - childTime; |
|
} |
|
|
|
return (ko != nil); |
|
} |
|
|
|
//// plPageOutIterator /////////////////////////////////////////////////////// |
|
// See below function |
|
class plPageOutIterator : public plRegistryPageIterator |
|
{ |
|
protected: |
|
plResManager* fResMgr; |
|
UInt16 fHint; |
|
|
|
public: |
|
plPageOutIterator(plResManager* resMgr, UInt16 hint) : fResMgr(resMgr), fHint(hint) |
|
{ |
|
fResMgr->IterateAllPages(this); |
|
} |
|
|
|
virtual hsBool EatPage(plRegistryPageNode* page) |
|
{ |
|
fResMgr->UnloadPageObjects(page, fHint); |
|
return true; |
|
} |
|
}; |
|
|
|
#if HS_BUILD_FOR_UNIX |
|
static void sLeakReportRedirectFn( const char message[] ) |
|
{ |
|
hsUNIXStream stream; |
|
stream.Open( "resMgrMemLeaks.txt", "at" ); |
|
stream.WriteString( message ); |
|
stream.Close(); |
|
} |
|
static bool sFirstTime = true; |
|
#endif |
|
|
|
// Just the scene nodes (and objects referenced by the node... and so on) |
|
void plResManager::IPageOutSceneNodes(hsBool forceAll) |
|
{ |
|
plSynchEnabler ps(false); // disable dirty tracking while paging out |
|
|
|
#if HS_BUILD_FOR_UNIX |
|
if (sFirstTime) |
|
{ |
|
hsUNIXStream stream; |
|
stream.Open("resMgrMemLeaks.txt", "wt"); |
|
stream.Close(); |
|
sFirstTime = false; |
|
} |
|
hsDebugMessageProc oldProc = hsSetStatusMessageProc(sLeakReportRedirectFn); |
|
#endif |
|
|
|
if (forceAll) |
|
{ |
|
hsStatusMessage( "--- plResManager Object Leak Report (BEGIN) ---" ); |
|
plPageOutIterator iter(this, UInt16(-1)); |
|
hsStatusMessage( "--- plResManager Object Leak Report (END) ---" ); |
|
} |
|
else |
|
{ |
|
plPageOutIterator iter(this, fPageOutHint); |
|
} |
|
|
|
#if HS_BUILD_FOR_UNIX |
|
hsSetStatusMessageProc( oldProc ); |
|
#endif |
|
} |
|
|
|
//// FindKey ///////////////////////////////////////////////////////////////// |
|
|
|
inline plKeyImp* IFindKeyLocalized(const plUoid& uoid, plRegistryPageNode* page) |
|
{ |
|
const char* objectName = uoid.GetObjectName(); |
|
|
|
// If we're running localized, try to find a localized version first |
|
if (plLocalization::IsLocalized()) |
|
{ |
|
char localName[256]; |
|
if (plLocalization::GetLocalized(objectName, localName)) |
|
{ |
|
plKeyImp* localKey = page->FindKey(uoid.GetClassType(), localName); |
|
if (localKey != nil) |
|
return localKey; |
|
} |
|
} |
|
|
|
// Try to find the non-localized version |
|
return page->FindKey(uoid); |
|
} |
|
|
|
plKey plResManager::FindOriginalKey(const plUoid& uoid) |
|
{ |
|
plKey key; |
|
plKeyImp* foundKey = nil; |
|
|
|
plRegistryPageNode* page = FindPage(uoid.GetLocation()); |
|
if (page == nil) |
|
return key; |
|
|
|
// Try our find first, without loading |
|
foundKey = IFindKeyLocalized(uoid, page); |
|
if (foundKey != nil) |
|
key = plKey::Make(foundKey); |
|
|
|
if (!key && plResMgrSettings::Get().GetPassiveKeyRead()) |
|
{ |
|
// Passive key read mode is where we read keys in and attempt to match |
|
// them to keys in the registry, but we will NOT force a load on the page |
|
// to find the keys. If the key isn't already in the registry to match, |
|
// we create what we call a "passive key", i.e. it's a key with no real |
|
// info apart from the uoid. Used when you want to read in a object that |
|
// contains keys but don't want to actually use those keys (only write |
|
// them back out). |
|
|
|
// Note: startPos of -1 means we didn't read it from disk, but 0 length |
|
// is our special key that we're a passively created key |
|
foundKey = TRACKED_NEW plKeyImp(uoid, UInt32(-1), UInt32(0)); |
|
key = plKey::Make(foundKey); |
|
} |
|
|
|
// OK, find didn't work. Can we load and try again? |
|
if (!key && !page->IsFullyLoaded()) |
|
{ |
|
// Tell the resManager's helper to load and hold our page keys temporarily |
|
plResManagerHelper::GetInstance()->LoadAndHoldPageKeys(page); |
|
|
|
// Try again |
|
foundKey = IFindKeyLocalized(uoid, page); |
|
if (foundKey != nil) |
|
key = plKey::Make(foundKey); |
|
} |
|
return key; |
|
} |
|
|
|
plKey plResManager::FindKey(const plUoid& uoid) |
|
{ |
|
plKey key = FindOriginalKey(uoid); |
|
|
|
// If we're looking for a clone, get the clone instead of the original |
|
if (key && uoid.IsClone()) |
|
key = ((plKeyImp*)key)->GetClone(uoid.GetClonePlayerID(), uoid.GetCloneID()); |
|
|
|
return key; |
|
} |
|
|
|
const plLocation& plResManager::FindLocation(const char* age, const char* page) const |
|
{ |
|
static plLocation invalidLoc; |
|
|
|
plRegistryPageNode* pageNode = FindPage(age, page); |
|
if (pageNode) |
|
return pageNode->GetPageInfo().GetLocation(); |
|
|
|
return invalidLoc; |
|
} |
|
|
|
const void plResManager::GetLocationStrings(const plLocation& loc, char* ageBuffer, char* pageBuffer) const |
|
{ |
|
plRegistryPageNode* page = FindPage(loc); |
|
const plPageInfo& info = page->GetPageInfo(); |
|
|
|
// Those buffers better be big enough... |
|
if (ageBuffer) |
|
hsStrcpy(ageBuffer, info.GetAge()); |
|
if (pageBuffer) |
|
hsStrcpy(pageBuffer, info.GetPage()); |
|
} |
|
|
|
hsBool plResManager::AddViaNotify(plRefMsg* msg, plRefFlags::Type flags) |
|
{ |
|
hsAssert(msg && msg->GetRef() && msg->GetRef()->GetKey(), "Improperly filled out ref message"); |
|
plKey key = msg->GetRef()->GetKey(); // for linux build |
|
return AddViaNotify(key, msg, flags); |
|
} |
|
|
|
hsBool plResManager::AddViaNotify(const plKey &key, plRefMsg* msg, plRefFlags::Type flags) |
|
{ |
|
hsAssert(key, "Can't add without a Key"); |
|
if (!key) |
|
{ |
|
hsRefCnt_SafeUnRef(msg); |
|
return false; |
|
} |
|
|
|
((plKeyImp*)key)->SetupNotify(msg,flags); |
|
|
|
if (flags != plRefFlags::kPassiveRef) |
|
{ |
|
hsKeyedObject* ko = key->ObjectIsLoaded(); |
|
if (!ko) |
|
Load(key); |
|
} |
|
|
|
return true; |
|
} |
|
|
|
hsBool plResManager::SendRef(hsKeyedObject* ko, plRefMsg* refMsg, plRefFlags::Type flags) |
|
{ |
|
if (!ko) |
|
return false; |
|
plKey key = ko->GetKey(); |
|
return SendRef(key, refMsg, flags); |
|
} |
|
|
|
////////////////////////// |
|
// This one does the dirty. Calls, the protected ISetupNotify on the key being reffed. |
|
// That will setup the notifications on the key, but not send any. If the object is |
|
// currently not loaded, we're done (and this behaves exactly like AddViaNotify(). |
|
// If it is in memory, and the one making the reference is in memory (it presumably |
|
// is in the absence of strange doings), we bypass the Dispatch system and call |
|
// the object making the reference's MsgReceive directly, so the object will have |
|
// received the reference via its normal message processing without the message |
|
// having to wait in the queue, and more importantly, before the SendRef call returns. |
|
// This doesn't mean you are guaranteed to have your ref at the return of SendRef, |
|
// because if it's not in memory, we don't wait around while we load it, we just |
|
// return false. |
|
hsBool plResManager::SendRef(const plKey& key, plRefMsg* refMsg, plRefFlags::Type flags) |
|
{ |
|
if (!key) |
|
{ |
|
hsRefCnt_SafeUnRef(refMsg); |
|
return false; |
|
} |
|
|
|
plKeyImp* iKey = (plKeyImp*)key; |
|
iKey->ISetupNotify(refMsg, flags); |
|
hsRefCnt_SafeUnRef(refMsg); |
|
|
|
if (flags != plRefFlags::kPassiveRef) |
|
iKey->VerifyLoaded(); |
|
|
|
hsKeyedObject* ko = key->ObjectIsLoaded(); |
|
if (!ko) |
|
return false; |
|
|
|
refMsg->SetRef(ko); |
|
refMsg->SetTimeStamp(hsTimer::GetSysSeconds()); |
|
|
|
for (int i = 0; i < refMsg->GetNumReceivers(); i++) |
|
{ |
|
hsKeyedObject* rcv = refMsg->GetReceiver(i)->ObjectIsLoaded(); |
|
if (rcv) |
|
rcv->MsgReceive(refMsg); |
|
} |
|
return true; |
|
} |
|
|
|
void plResManager::Load(const plKey &key) // places on list to be loaded |
|
{ |
|
if (fReadingObject) |
|
fQueuedReads.push_back(key); |
|
else |
|
key->VerifyLoaded(); // force Load |
|
} |
|
|
|
plKey plResManager::ReadKeyNotifyMe(hsStream* stream, plRefMsg* msg, plRefFlags::Type flags) |
|
{ |
|
plKey key = ReadKey(stream); |
|
|
|
if (!key) |
|
{ |
|
hsRefCnt_SafeUnRef(msg); |
|
return nil; |
|
} |
|
if(key->GetUoid().GetLoadMask().DontLoad()) |
|
{ |
|
hsStatusMessageF("%s being skipped because of load mask", key->GetName()); |
|
hsRefCnt_SafeUnRef(msg); |
|
return nil; |
|
} |
|
|
|
((plKeyImp*)key)->SetupNotify(msg,flags); |
|
|
|
hsKeyedObject* ko = key->ObjectIsLoaded(); |
|
|
|
if (!ko) |
|
{ |
|
Load(key); |
|
} |
|
|
|
return key; |
|
} |
|
|
|
//// NewKey ////////////////////////////////////////////////////////////////// |
|
// Creates a new key and assigns it to the given keyed object, also placing |
|
// it into the registry. |
|
|
|
plKey plResManager::NewKey(const char* name, hsKeyedObject* object, const plLocation& loc, const plLoadMask& m ) |
|
{ |
|
hsAssert(name && name[0] != '\0', "No name for new key"); |
|
plUoid newUoid(loc, object->ClassIndex(), name, m); |
|
return NewKey(newUoid, object); |
|
} |
|
|
|
plKey plResManager::NewKey(plUoid& newUoid, hsKeyedObject* object) |
|
{ |
|
hsAssert(fInited, "Attempting to create a new key before we're inited!"); |
|
|
|
plKeyImp* newKey = TRACKED_NEW plKeyImp; |
|
newKey->SetUoid(newUoid); |
|
AddKey(newKey); |
|
|
|
plKey keyPtr = plKey::Make(newKey); |
|
object->SetKey(keyPtr); |
|
|
|
return keyPtr; |
|
} |
|
|
|
plKey plResManager::ReRegister(const char* nm, const plUoid& oid) |
|
{ |
|
hsAssert(fInited, "Attempting to reregister a key before we're inited!"); |
|
|
|
bool canClone = false; |
|
if (fCurCloneID != 0) |
|
{ |
|
// Not allowed to clone these things |
|
int oidType = oid.GetClassType(); |
|
if (oidType != CLASS_INDEX_SCOPED(plSceneNode) && |
|
oidType != CLASS_INDEX_SCOPED(plLOSDispatch) && |
|
oidType != CLASS_INDEX_SCOPED(plTimerCallbackManager) && |
|
oidType != CLASS_INDEX_SCOPED(pfConsole) && |
|
oidType != CLASS_INDEX_SCOPED(plAudioSystem) && |
|
oidType != CLASS_INDEX_SCOPED(plInputManager) && |
|
oidType != CLASS_INDEX_SCOPED(plClient) && |
|
oidType != CLASS_INDEX_SCOPED(plNetClientMgr) && |
|
oidType != CLASS_INDEX_SCOPED(plAvatarAnimMgr) && |
|
oidType != CLASS_INDEX_SCOPED(plSoundBuffer) && |
|
oidType != CLASS_INDEX_SCOPED(plResManagerHelper) && |
|
oidType != CLASS_INDEX_SCOPED(plSharedMesh)) |
|
canClone = true; |
|
|
|
// Can't clone fixed keys |
|
if (oid.GetLocation() == plLocation::kGlobalFixedLoc) |
|
canClone = false; |
|
} |
|
|
|
plKey pOrigKey = FindOriginalKey(oid); |
|
if (!canClone) |
|
{ |
|
if (pOrigKey) |
|
{ |
|
return pOrigKey; |
|
} |
|
// the clone doesn't exist |
|
else if (oid.IsClone()) |
|
{ |
|
return nil; |
|
} |
|
} |
|
else //we are cloning |
|
{ |
|
if (pOrigKey) |
|
{ |
|
plKey cloneKey = ((plKeyImp*)pOrigKey)->GetClone(fCurClonePlayerID, fCurCloneID); |
|
if (cloneKey) |
|
return cloneKey; |
|
} |
|
} |
|
|
|
plKeyImp* pKey = TRACKED_NEW plKeyImp; |
|
if (canClone && pOrigKey) |
|
{ |
|
pKey->CopyForClone((plKeyImp*)pOrigKey, fCurClonePlayerID, fCurCloneID); |
|
((plKeyImp*)pOrigKey)->AddClone(pKey); |
|
} |
|
else |
|
{ |
|
// Make sure key doesn't already exist |
|
if (pOrigKey) |
|
{ |
|
hsAssert(false, "Attempting to add duplicate key"); |
|
delete pKey; |
|
return nil; |
|
} |
|
|
|
pKey->SetUoid(oid); // Tell the Key its ID |
|
AddKey(pKey); |
|
} |
|
|
|
hsAssert(pKey, "ReRegister: returning nil key?"); |
|
return plKey::Make(pKey); |
|
} |
|
|
|
//// ReadKey ///////////////////////////////////////////////////////////////// |
|
// Reads a "key" from the given stream. What we secretly do is read in the |
|
// plUoid for a key and look up to find the key. Nobody else will know :) |
|
|
|
plKey plResManager::ReadKey(hsStream* s) |
|
{ |
|
hsBool nonNil = s->ReadBool(); |
|
if (!nonNil) |
|
return nil; |
|
|
|
plUoid uoid; |
|
uoid.Read(s); |
|
|
|
plKey key; |
|
|
|
if (fCurCloneID != 0) |
|
{ |
|
// We're reading child of a clone object, it needs to be cloned too |
|
key = ReRegister(uoid.GetObjectName(), uoid); |
|
} |
|
else if (uoid.GetCloneID() != 0) |
|
{ |
|
// We're reading a clone key. first see if we already have that key around.... |
|
key = FindKey(uoid); |
|
if (key == nil) |
|
{ |
|
fCurClonePlayerID = uoid.GetClonePlayerID(); |
|
fCurCloneID = uoid.GetCloneID(); |
|
key = ReRegister(uoid.GetObjectName(), uoid); |
|
fCurClonePlayerID = 0; |
|
fCurCloneID = 0; |
|
} |
|
} |
|
else |
|
{ |
|
// We're reading a regular, non-clone object |
|
key = FindKey(uoid); |
|
} |
|
|
|
return key; |
|
} |
|
|
|
//// WriteKey //////////////////////////////////////////////////////////////// |
|
|
|
void plResManager::WriteKey(hsStream* s, hsKeyedObject* obj) |
|
{ |
|
if (obj) |
|
WriteKey(s, obj->GetKey()); |
|
else |
|
WriteKey(s, plKey(nil)); |
|
} |
|
|
|
void plResManager::WriteKey(hsStream *s, const plKey &key) |
|
{ |
|
s->WriteBool(key != nil); |
|
if (key) |
|
key->GetUoid().Write(s); |
|
} |
|
|
|
// |
|
// Create cloned key but don't load yet |
|
// |
|
plKey plResManager::CloneKey(const plKey& objKey) |
|
{ |
|
if (!objKey) |
|
{ |
|
hsStatusMessage("CloneKey: nil key, returning nil"); |
|
return nil; |
|
} |
|
|
|
fCloningCounter++; |
|
return ICloneKey(objKey->GetUoid(), plNetClientApp::GetInstance()->GetPlayerID(), fCloningCounter); |
|
} |
|
|
|
plKey plResManager::ICloneKey(const plUoid& objUoid, UInt32 playerID, UInt32 cloneID) |
|
{ |
|
hsAssert(fCurCloneID == 0, "Recursive clone"); |
|
fCurCloneID = cloneID; |
|
fCurClonePlayerID = playerID; |
|
|
|
plKey cloneKey = ReRegister("", objUoid); |
|
|
|
fCurClonePlayerID = 0; |
|
fCurCloneID = 0; |
|
|
|
// Then notify NetClientMgr when object loads |
|
plObjRefMsg* refMsg = TRACKED_NEW plObjRefMsg(plNetClientApp::GetInstance()->GetKey(), plRefMsg::kOnCreate, 0, 0); |
|
AddViaNotify(cloneKey, refMsg, plRefFlags::kPassiveRef); |
|
|
|
return cloneKey; |
|
} |
|
|
|
// |
|
// Unregisters (deletes) an object. |
|
// Currently, this means the object is going away permanently. |
|
// When support for paging is added, key->UnRegister() should not clear its notify lists. |
|
// Return true if successful. |
|
// |
|
hsBool plResManager::Unload(const plKey& objKey) |
|
{ |
|
if (objKey) |
|
{ |
|
((plKeyImp*)objKey)->UnRegister(); |
|
fDispatch->UnRegisterAll(objKey); |
|
return true; |
|
} |
|
return false; |
|
} |
|
|
|
plCreatable* plResManager::IReadCreatable(hsStream* s) const |
|
{ |
|
UInt16 hClass = s->ReadSwap16(); |
|
plCreatable* pCre = plFactory::Create(hClass); |
|
if (!pCre) |
|
hsAssert( hClass == 0x8000, "Invalid creatable index" ); |
|
|
|
return pCre; |
|
} |
|
|
|
plCreatable* plResManager::ReadCreatable(hsStream* s) |
|
{ |
|
plCreatable *pCre = IReadCreatable(s); |
|
if (pCre) |
|
pCre->Read(s, this); |
|
return pCre; |
|
} |
|
|
|
plCreatable* plResManager::ReadCreatableVersion(hsStream* s) |
|
{ |
|
plCreatable *pCre = IReadCreatable(s); |
|
if (pCre) |
|
pCre->ReadVersion(s, this); |
|
return pCre; |
|
} |
|
|
|
inline void IWriteCreatable(hsStream* s, plCreatable* pCre) |
|
{ |
|
Int16 hClass = pCre ? pCre->ClassIndex() : 0x8000; |
|
hsAssert(pCre == nil || plFactory::IsValidClassIndex(hClass), "Invalid class index on write"); |
|
s->WriteSwap16(hClass); |
|
} |
|
|
|
void plResManager::WriteCreatable(hsStream* s, plCreatable* pCre) |
|
{ |
|
IWriteCreatable(s, pCre); |
|
if (pCre) |
|
pCre->Write(s, this); |
|
} |
|
|
|
void plResManager::WriteCreatableVersion(hsStream* s, plCreatable* pCre) |
|
{ |
|
IWriteCreatable(s, pCre); |
|
if (pCre) |
|
pCre->WriteVersion(s, this); |
|
} |
|
|
|
void plResManager::SetProgressBarProc(plProgressProc proc) |
|
{ |
|
fProgressProc = proc; |
|
} |
|
|
|
////////////////////////////////////////////////////////////////////////////// |
|
//// Paging Functions //////////////////////////////////////////////////////// |
|
////////////////////////////////////////////////////////////////////////////// |
|
|
|
//// plResAgeHolder ////////////////////////////////////////////////////////// |
|
// Helper object that stores all the keys for an age, to optimize the load |
|
// process. |
|
|
|
class plResAgeHolder : public hsRefCnt |
|
{ |
|
public: |
|
hsTArray<plKey> fKeys; |
|
std::string fAge; |
|
|
|
plResAgeHolder() {} |
|
plResAgeHolder( const char* age ) : fAge( age ) {} |
|
~plResAgeHolder() { fKeys.Reset(); } |
|
}; |
|
|
|
//// plResHolderIterator ///////////////////////////////////////////////////// |
|
|
|
class plResHolderIterator : public plRegistryPageIterator |
|
{ |
|
protected: |
|
hsTArray<plKey>& fKeys; |
|
const char* fAgeName; |
|
plResManager* fResMgr; |
|
|
|
public: |
|
plResHolderIterator(const char* age, hsTArray<plKey>& keys, plResManager* resMgr) |
|
: fAgeName(age), fKeys(keys), fResMgr(resMgr) {} |
|
|
|
virtual hsBool EatPage(plRegistryPageNode* page) |
|
{ |
|
if (stricmp(page->GetPageInfo().GetAge(), fAgeName) == 0) |
|
{ |
|
fResMgr->LoadPageKeys(page); |
|
plKeyCollector collector(fKeys); |
|
page->IterateKeys(&collector); |
|
} |
|
|
|
return true; |
|
} |
|
}; |
|
|
|
//// LoadAndHoldAgeKeys ////////////////////////////////////////////////////// |
|
|
|
void plResManager::LoadAgeKeys(const char* age) |
|
{ |
|
hsAssert(age && age[0] != '\0', "age is nil"); |
|
HeldAgeKeyMap::const_iterator it = fHeldAgeKeys.find(age); |
|
if (it != fHeldAgeKeys.end()) |
|
{ |
|
kResMgrLog(1, ILog(1, "Reffing age keys for age %s", age)); |
|
hsStatusMessageF("*** Reffing age keys for age %s ***\n", age); |
|
plResAgeHolder* holder = it->second; |
|
holder->Ref(); |
|
} |
|
else |
|
{ |
|
kResMgrLog(1, ILog(1, "Loading age keys for age %s", age)); |
|
hsStatusMessageF("*** Loading age keys for age %s ***\n", age); |
|
|
|
plResAgeHolder* holder = TRACKED_NEW plResAgeHolder(age); |
|
fHeldAgeKeys[age] = holder; |
|
// Go find pages that match this age, load the keys, and ref them all |
|
plResHolderIterator iter(age, holder->fKeys, this); |
|
IterateAllPages(&iter); |
|
} |
|
} |
|
|
|
//// DropAgeKeys ///////////////////////////////////////////////////////////// |
|
|
|
void plResManager::DropAgeKeys(const char* age) |
|
{ |
|
HeldAgeKeyMap::iterator it = fHeldAgeKeys.find(age); |
|
if (it != fHeldAgeKeys.end()) |
|
{ |
|
plResAgeHolder* holder = it->second; |
|
if (holder->RefCnt() == 1) |
|
{ |
|
// Found it! |
|
kResMgrLog(1, ILog(1, "Dropping held age keys for age %s", age)); |
|
fHeldAgeKeys.erase(it); |
|
} |
|
else |
|
{ |
|
kResMgrLog(1, ILog(1, "Unreffing age keys for age %s", age)); |
|
} |
|
|
|
holder->UnRef(); |
|
} |
|
} |
|
|
|
//// IDropAllAgeKeys ///////////////////////////////////////////////////////// |
|
|
|
void plResManager::IDropAllAgeKeys() |
|
{ |
|
kResMgrLog(1, ILog(1, "Dropping any remaining age keys")); |
|
for (HeldAgeKeyMap::iterator it = fHeldAgeKeys.begin(); it != fHeldAgeKeys.end(); ++it) |
|
{ |
|
plResAgeHolder* holder = it->second; |
|
kResMgrLog(1, ILog(1, "Dropping age keys for age %s", holder->fAge.c_str())); |
|
while (holder->RefCnt() > 1) |
|
holder->UnRef(); |
|
holder->UnRef(); // deletes holder |
|
} |
|
} |
|
|
|
//// PageInRoom ////////////////////////////////////////////////////////////// |
|
// Normal finds will have to potentially reload all the keys for a page, but |
|
// paging in this way will avoid having to reload keys every single find |
|
// during a load--we load all the keys once, ref them so they're in, then |
|
// do the entire load and unref when we're done. |
|
// |
|
// The objClassToRef parameter is a bit tricky. Basically, you assume that |
|
// there's one object in the page that you're loading based off of (say, a |
|
// sceneNode). That's the object that'll get reffed by the refMsg passed in. |
|
// The only reason we abstract it is so we can keep plResManager from being |
|
// dependent on any particular class type. |
|
// |
|
// This function is not guaranteed to be synchronous, so you better wait for |
|
// the refMsg to be sent before you assume it's done. |
|
|
|
class plOurRefferAndFinder : public plRegistryKeyIterator |
|
{ |
|
hsTArray<plKey> &fRefArray; |
|
UInt16 fClassToFind; |
|
plKey &fFoundKey; |
|
|
|
public: |
|
|
|
plOurRefferAndFinder( hsTArray<plKey> &refArray, UInt16 classToFind, plKey &foundKey ) |
|
: fRefArray( refArray ), fClassToFind( classToFind ), fFoundKey( foundKey ) { } |
|
|
|
virtual hsBool EatKey( const plKey& key ) |
|
{ |
|
// This is cute. Thanks to our new plKey smart pointers, all we have to |
|
// do is append the key to our ref array. This automatically guarantees us |
|
// an extra ref on the key, which is what we're trying to do. Go figure. |
|
fRefArray.Append( key ); |
|
|
|
// Also do our find |
|
if( key->GetUoid().GetClassType() == fClassToFind ) |
|
fFoundKey = key; |
|
|
|
return true; |
|
} |
|
}; |
|
|
|
void plResManager::PageInRoom(const plLocation& page, UInt16 objClassToRef, plRefMsg* refMsg) |
|
{ |
|
UInt64 readRoomTime = 0; |
|
if (fLogReadTimes) |
|
readRoomTime = hsTimer::GetFullTickCount(); |
|
|
|
plSynchEnabler ps(false); // disable dirty tracking while paging in |
|
|
|
kResMgrLog(1, ILog(1, "Paging in room 0x%x...", page.GetSequenceNumber())); |
|
|
|
// Step 0: Find the pageNode |
|
plRegistryPageNode* pageNode = FindPage(page); |
|
if (pageNode == nil) |
|
{ |
|
kResMgrLog(1, ILog(1, "...Page not found!")); |
|
hsAssert(false, "Invalid location given to PageInRoom()"); |
|
return; |
|
} |
|
|
|
kResMgrLog(2, ILog(2, "...Found, page is ID'd as %s>%s", pageNode->GetPageInfo().GetAge(), pageNode->GetPageInfo().GetPage())); |
|
|
|
// Step 0.5: Verify the page, just to make sure we really should be loading it |
|
PageCond cond = pageNode->GetPageCondition(); |
|
if (cond != kPageOk) |
|
{ |
|
std::string condStr ="Checksum invalid"; |
|
if (cond == kPageTooNew) |
|
condStr = "Page Version too new"; |
|
else |
|
if (cond == kPageOutOfDate) |
|
condStr = "Page Version out of date"; |
|
|
|
kResMgrLog(1, ILog(1, "...IGNORING pageIn request; verification failed! (%s)", condStr.c_str())); |
|
|
|
std::string msg = xtl::format("Data Problem: Age:%s Page:%s Error:%s", |
|
pageNode->GetPageInfo().GetAge(), pageNode->GetPageInfo().GetPage(), condStr.c_str()); |
|
hsMessageBox(msg.c_str(), "Error", hsMessageBoxNormal, hsMessageBoxIconError); |
|
|
|
hsRefCnt_SafeUnRef(refMsg); |
|
return; |
|
} |
|
|
|
// Step 1: We force a load on all the keys in the given page |
|
kResMgrLog(2, ILog(2, "...Loading page keys...")); |
|
LoadPageKeys(pageNode); |
|
|
|
// Step 2: Now ref all the keys in that page, every single one. This lets us unref |
|
// (and thus potentially delete) them later. Note that we also use this for our find. |
|
kResMgrLog(2, ILog(2, "...Reffing keys...")); |
|
plKey objKey; |
|
hsTArray<plKey> keyRefList; |
|
plOurRefferAndFinder reffer(keyRefList, objClassToRef, objKey); |
|
pageNode->IterateKeys(&reffer); |
|
|
|
// Step 3: Do our load |
|
if (objKey == nil) |
|
{ |
|
kResMgrLog(1, ILog(1, "...SceneNode not found to base page-in op on. Aborting...")); |
|
// This is coming up a lot lately; too intrusive to be an assert. |
|
// hsAssert( false, "No object found on which to base our PageInRoom()" ); |
|
return; |
|
} |
|
|
|
// Forces a load |
|
kResMgrLog(2, ILog(2, "...Forcing load via sceneNode...")); |
|
objKey->VerifyLoaded(); |
|
|
|
// Step 4: Unref the keys. This'll make the unused ones go away again. And guess what, |
|
// since we just have an array of keys, all we have to do to do this is clear the array. |
|
// Note that since objKey is a plKey, our object that we loaded will have an extra ref... |
|
// Scary, huh? |
|
kResMgrLog(2, ILog(2, "...Dumping extra key refs...")); |
|
keyRefList.Reset(); |
|
|
|
// Step 5: Ref the object |
|
kResMgrLog(2, ILog(2, "...Dispatching refMessage...")); |
|
AddViaNotify(objKey, refMsg, plRefFlags::kActiveRef); |
|
|
|
// All done! |
|
kResMgrLog(1, ILog(1, "...Page in complete!")); |
|
|
|
if (fLogReadTimes) |
|
{ |
|
readRoomTime = hsTimer::GetFullTickCount() - readRoomTime; |
|
|
|
plStatusLog::AddLineS("readtimings.log", plStatusLog::kWhite, "----- Reading page %s>%s took %.1f ms", |
|
pageNode->GetPageInfo().GetAge(), pageNode->GetPageInfo().GetPage(), |
|
hsTimer::FullTicksToMs(readRoomTime)); |
|
} |
|
} |
|
|
|
class plPageInAgeIter : public plRegistryPageIterator |
|
{ |
|
private: |
|
plKey fDestKey; |
|
const char* fAgeName; |
|
std::vector<plLocation> fLocations; |
|
|
|
public: |
|
plPageInAgeIter(plKey destKey, const char *ageName) : fDestKey(destKey), fAgeName(ageName) {} |
|
~plPageInAgeIter() |
|
{ |
|
plClientMsg* pMsg1 = TRACKED_NEW plClientMsg(plClientMsg::kLoadRoomHold); |
|
for (int i = 0; i < fLocations.size(); i++) |
|
{ |
|
pMsg1->AddRoomLoc(fLocations[i]); |
|
} |
|
pMsg1->Send(fDestKey); |
|
} |
|
virtual hsBool EatPage(plRegistryPageNode* page) |
|
{ |
|
if (stricmp(page->GetPageInfo().GetAge(), fAgeName) == 0) |
|
{ |
|
plUoid uoid(page->GetPageInfo().GetLocation(), 0, ""); |
|
fLocations.push_back(uoid.GetLocation()); |
|
} |
|
return true; |
|
} |
|
}; |
|
|
|
// PageInAge is intended for bulk global ages, like GlobalAnimations or GlobalClothing |
|
// that store a lot of data we always want available. (Used to be known as PageInHold) |
|
void plResManager::PageInAge(const char *age) |
|
{ |
|
plSynchEnabler ps(false); // disable dirty tracking while paging in |
|
plUoid lu(kClient_KEY); |
|
plKey clientKey = hsgResMgr::ResMgr()->FindKey(lu); |
|
|
|
// Tell the client to load all the keys for this age, to make the loading process work better |
|
plClientMsg *loadAgeKeysMsg = TRACKED_NEW plClientMsg(plClientMsg::kLoadAgeKeys); |
|
loadAgeKeysMsg->SetAgeName(age); |
|
loadAgeKeysMsg->Send(clientKey); |
|
|
|
// Then iterate through each room in the age. The iterator will send the load message |
|
// off on destruction. |
|
plPageInAgeIter iter(clientKey, age); |
|
IterateAllPages(&iter); |
|
} |
|
|
|
//// VerifyPages ///////////////////////////////////////////////////////////// |
|
// Runs through all the pages and ensures they are all up-to-date in version |
|
// numbers and that no out-of-date objects exist in them |
|
|
|
hsBool plResManager::VerifyPages() |
|
{ |
|
hsTArray<plRegistryPageNode*> invalidPages, newerPages; |
|
|
|
// Step 1: verify major/minor version changes |
|
if (plResMgrSettings::Get().GetFilterNewerPageVersions() || |
|
plResMgrSettings::Get().GetFilterOlderPageVersions()) |
|
{ |
|
PageSet::iterator it = fAllPages.begin(); |
|
while (it != fAllPages.end()) |
|
{ |
|
plRegistryPageNode* page = *it; |
|
it++; |
|
|
|
if (page->GetPageCondition() == kPageTooNew && plResMgrSettings::Get().GetFilterNewerPageVersions()) |
|
{ |
|
newerPages.Append(page); |
|
fAllPages.erase(page); |
|
} |
|
else if ( |
|
(page->GetPageCondition() == kPageCorrupt || |
|
page->GetPageCondition() == kPageOutOfDate) |
|
&& plResMgrSettings::Get().GetFilterOlderPageVersions()) |
|
{ |
|
invalidPages.Append(page); |
|
fAllPages.erase(page); |
|
} |
|
} |
|
} |
|
|
|
// Handle all our invalid pages now |
|
if (invalidPages.GetCount() > 0) |
|
{ |
|
if (!IDeleteBadPages(invalidPages, false)) |
|
return false; |
|
} |
|
|
|
// Warn about newer pages |
|
if (newerPages.GetCount() > 0) |
|
{ |
|
if (!IWarnNewerPages(newerPages)) |
|
return false; |
|
} |
|
|
|
// Step 2 of verification: make sure no sequence numbers conflict |
|
PageSet::iterator it = fAllPages.begin(); |
|
for (; it != fAllPages.end(); it++) |
|
{ |
|
plRegistryPageNode* page = *it; |
|
|
|
PageSet::iterator itUp = it; |
|
itUp++; |
|
for (; itUp != fAllPages.end(); itUp++) |
|
{ |
|
plRegistryPageNode* upPage = *itUp; |
|
if (page->GetPageInfo().GetLocation() == upPage->GetPageInfo().GetLocation()) |
|
{ |
|
invalidPages.Append(upPage); |
|
fAllPages.erase(itUp); |
|
break; |
|
} |
|
} |
|
} |
|
|
|
// Redo our loaded pages list, since Verify() might force the page's keys to load or unload |
|
fLoadedPages.clear(); |
|
it = fAllPages.begin(); |
|
while (it != fAllPages.end()) |
|
{ |
|
plRegistryPageNode* page = *it; |
|
it++; |
|
|
|
if (page->IsLoaded()) |
|
fLoadedPages.insert(page); |
|
} |
|
|
|
// Handle all our conflicting pages now |
|
if (invalidPages.GetCount() > 0) |
|
return IDeleteBadPages(invalidPages, true); |
|
|
|
return true; |
|
} |
|
|
|
//// IDeleteBadPages ///////////////////////////////////////////////////////// |
|
// Given an array of pages that are invalid (major version out-of-date or |
|
// whatnot), asks the user what we should do about them. |
|
|
|
static void ICatPageNames(hsTArray<plRegistryPageNode*>& pages, char* buf, int bufSize) |
|
{ |
|
for (int i = 0; i < pages.GetCount(); i++) |
|
{ |
|
if (i >= 25) |
|
{ |
|
strcat(buf, "...\n"); |
|
break; |
|
} |
|
|
|
const char* pagePath = pages[i]->GetPagePath(); |
|
const char* pageFile = plFileUtils::GetFileName(pagePath); |
|
|
|
if (strlen(buf) + strlen(pageFile) > bufSize - 5) |
|
{ |
|
strcat(buf, "...\n"); |
|
break; |
|
} |
|
|
|
strcat(buf, pageFile); |
|
strcat(buf, "\n"); |
|
} |
|
} |
|
|
|
hsBool plResManager::IDeleteBadPages(hsTArray<plRegistryPageNode*>& invalidPages, hsBool conflictingSeqNums) |
|
{ |
|
#ifndef PLASMA_EXTERNAL_RELEASE |
|
if (!hsMessageBox_SuppressPrompts) |
|
{ |
|
char msg[4096]; |
|
|
|
// Prompt what to do |
|
if (conflictingSeqNums) |
|
strcpy(msg, "The following pages have conflicting sequence numbers. This usually happens when " |
|
"you copy data files between machines that had random sequence numbers assigned at " |
|
"export. To avoid crashing, these pages will be deleted:\n\n"); |
|
else |
|
strcpy(msg, "The following pages are out of date and will be deleted:\n\n"); |
|
|
|
ICatPageNames(invalidPages, msg, sizeof(msg)); |
|
|
|
hsMessageBox(msg, "Warning", hsMessageBoxNormal); |
|
} |
|
#endif // PLASMA_EXTERNAL_RELEASE |
|
|
|
// Delete 'em |
|
for (int i = 0; i < invalidPages.GetCount(); i++) |
|
{ |
|
invalidPages[i]->DeleteSource(); |
|
delete invalidPages[i]; |
|
} |
|
invalidPages.Reset(); |
|
|
|
fLastFoundPage = nil; |
|
|
|
return true; |
|
} |
|
|
|
//// IWarnNewerPages ///////////////////////////////////////////////////////// |
|
// Given an array of pages that are newer (minor or major version are newer |
|
// than the "current" one), warns the user about them but does nothing to |
|
// them. |
|
|
|
hsBool plResManager::IWarnNewerPages(hsTArray<plRegistryPageNode*> &newerPages) |
|
{ |
|
#ifndef PLASMA_EXTERNAL_RELEASE |
|
if (!hsMessageBox_SuppressPrompts) |
|
{ |
|
char msg[4096]; |
|
// Prompt what to do |
|
strcpy(msg, "The following pages have newer version numbers than this client and cannot be \nloaded. " |
|
"They will be ignored but their files will NOT be deleted:\n\n"); |
|
|
|
ICatPageNames(newerPages, msg, sizeof(msg)); |
|
|
|
hsMessageBox(msg, "Warning", hsMessageBoxNormal); |
|
} |
|
#endif // PLASMA_EXTERNAL_RELEASE |
|
|
|
|
|
// Not deleting the files, just delete them from memory |
|
for (int i = 0; i < newerPages.GetCount(); i++) |
|
delete newerPages[i]; |
|
newerPages.Reset(); |
|
|
|
fLastFoundPage = nil; |
|
|
|
return true; |
|
} |
|
|
|
//// plOurReffer ///////////////////////////////////////////////////////////// |
|
// Our little reffer key iterator |
|
|
|
class plOurReffer : public plRegistryKeyIterator |
|
{ |
|
protected: |
|
hsTArray<plKey> fRefArray; |
|
|
|
public: |
|
plOurReffer() {} |
|
virtual ~plOurReffer() { UnRef(); } |
|
|
|
void UnRef() { fRefArray.Reset(); } |
|
|
|
virtual hsBool EatKey(const plKey& key) |
|
{ |
|
// This is cute. Thanks to our new plKey smart pointers, all we have to |
|
// do is append the key to our ref array. This automatically guarantees us |
|
// an extra ref on the key, which is what we're trying to do. Go figure. |
|
fRefArray.Append(key); |
|
|
|
return true; |
|
} |
|
}; |
|
|
|
void plResManager::DumpUnusedKeys(plRegistryPageNode* page) const |
|
{ |
|
plOurReffer reffer; |
|
page->IterateKeys(&reffer); |
|
} |
|
|
|
plRegistryPageNode* plResManager::CreatePage(const plLocation& location, const char* age, const char* page) |
|
{ |
|
plRegistryPageNode* pageNode = TRACKED_NEW plRegistryPageNode(location, age, page, fDataPath.c_str()); |
|
fAllPages.insert(pageNode); |
|
|
|
return pageNode; |
|
} |
|
|
|
//// AddPage ///////////////////////////////////////////////////////////////// |
|
|
|
void plResManager::AddPage(plRegistryPageNode* page) |
|
{ |
|
fAllPages.insert(page); |
|
if (page->IsLoaded()) |
|
fLoadedPages.insert(page); |
|
} |
|
|
|
//// LoadPageKeys /////////////////////////////////////////////////////////// |
|
|
|
void plResManager::LoadPageKeys(plRegistryPageNode* pageNode) |
|
{ |
|
if (pageNode->IsFullyLoaded()) |
|
return; |
|
|
|
// Load it and add it to the loaded list |
|
pageNode->LoadKeys(); |
|
|
|
if (fPageListLock == 0) |
|
fLoadedPages.insert(pageNode); |
|
else |
|
fPagesNeedCleanup = true; |
|
} |
|
|
|
//// sIReportLeak //////////////////////////////////////////////////////////// |
|
// Handy tiny function here |
|
|
|
static void sIReportLeak(plKeyImp* key, plRegistryPageNode* page) |
|
{ |
|
class plKeyImpRef : public plKeyImp |
|
{ |
|
public: |
|
UInt16 GetRefCnt() const { return fRefCount; } |
|
}; |
|
|
|
static bool alreadyDone = false; |
|
static plRegistryPageNode* lastPage; |
|
|
|
if (page != nil) |
|
lastPage = page; |
|
|
|
if (key == nil) |
|
{ |
|
alreadyDone = false; |
|
return; |
|
} |
|
|
|
if (!alreadyDone) |
|
{ |
|
// Print out page header |
|
hsStatusMessageF(" Leaks in page %s>%s[%08x]:\n", lastPage->GetPageInfo().GetAge(), lastPage->GetPageInfo().GetPage(), lastPage->GetPageInfo().GetLocation().GetSequenceNumber()); |
|
alreadyDone = true; |
|
} |
|
|
|
int refsLeft = ((plKeyImpRef*)key)->GetRefCnt() - 1; |
|
if (refsLeft == 0) |
|
return; |
|
|
|
char tempStr[256], tempStr2[128]; |
|
if (key->ObjectIsLoaded() == nil) |
|
sprintf(tempStr2, "(key only, %d refs left)", refsLeft); |
|
else |
|
sprintf(tempStr2, "- %d bytes - %d refs left", key->GetDataLen(), refsLeft); |
|
|
|
hsStatusMessageF(" %s: %s %s\n", plFactory::GetNameOfClass(key->GetUoid().GetClassType()), |
|
key->GetUoid().StringIze(tempStr), tempStr2); |
|
} |
|
|
|
//// UnloadPageObjects /////////////////////////////////////////////////////// |
|
// Unloads all the objects in a given page. Once this is complete, all |
|
// object pointers for every key in the page *should* be nil. Note that we're |
|
// given a hint class index to start with (like plSceneNode) that should do |
|
// most of the work for us via unreffing. |
|
// |
|
// Update 5.20: since there are so many problems with doing this, don't |
|
// delete the objects, just print out a memleak report. -mcn |
|
|
|
void plResManager::UnloadPageObjects(plRegistryPageNode* pageNode, UInt16 classIndexHint) |
|
{ |
|
if (!pageNode->IsLoaded()) |
|
return; |
|
|
|
class plUnloadObjectsIterator : public plRegistryKeyIterator |
|
{ |
|
public: |
|
virtual hsBool EatKey(const plKey& key) |
|
{ |
|
sIReportLeak((plKeyImp*)key, nil); |
|
return true; |
|
} |
|
}; |
|
|
|
sIReportLeak(nil, pageNode); |
|
|
|
plUnloadObjectsIterator iterator; |
|
|
|
if (classIndexHint != UInt16(-1)) |
|
pageNode->IterateKeys(&iterator, classIndexHint); |
|
else |
|
pageNode->IterateKeys(&iterator); |
|
} |
|
|
|
//// FindPage //////////////////////////////////////////////////////////////// |
|
|
|
plRegistryPageNode* plResManager::FindPage(const plLocation& location) const |
|
{ |
|
// Quick optimization |
|
if (fLastFoundPage != nil && fLastFoundPage->GetPageInfo().GetLocation() == location) |
|
return fLastFoundPage; |
|
|
|
PageSet::const_iterator it; |
|
for (it = fAllPages.begin(); it != fAllPages.end(); it++) |
|
{ |
|
const plLocation& pageloc = (*it)->GetPageInfo().GetLocation(); |
|
if (pageloc == location) |
|
{ |
|
fLastFoundPage = *it; |
|
return fLastFoundPage; |
|
} |
|
} |
|
|
|
return nil; |
|
} |
|
|
|
//// FindPage //////////////////////////////////////////////////////////////// |
|
|
|
plRegistryPageNode* plResManager::FindPage(const char* age, const char* page) const |
|
{ |
|
PageSet::const_iterator it; |
|
for (it = fAllPages.begin(); it != fAllPages.end(); it++) |
|
{ |
|
const plPageInfo& info = (*it)->GetPageInfo(); |
|
if (hsStrCaseEQ(info.GetAge(), age) && |
|
hsStrCaseEQ(info.GetPage(), page)) |
|
return *it; |
|
} |
|
|
|
return nil; |
|
} |
|
|
|
////////////////////////////////////////////////////////////////////////////// |
|
//// Key Operations ////////////////////////////////////////////////////////// |
|
////////////////////////////////////////////////////////////////////////////// |
|
|
|
//// AddKey ////////////////////////////////////////////////////////////////// |
|
// Adds a key to the registry. Assumes uoid already set. |
|
|
|
void plResManager::AddKey(plKeyImp* key) |
|
{ |
|
plRegistryPageNode* page = FindPage(key->GetUoid().GetLocation()); |
|
if (page == nil) |
|
return; |
|
|
|
page->AddKey(key); |
|
fLoadedPages.insert(page); |
|
} |
|
|
|
void plResManager::IKeyReffed(plKeyImp* key) |
|
{ |
|
plRegistryPageNode* page = FindPage(key->GetUoid().GetLocation()); |
|
if (page == nil) |
|
{ |
|
hsAssert(0, "Couldn't find page that key belongs to"); |
|
return; |
|
} |
|
|
|
page->SetKeyUsed(key); |
|
} |
|
|
|
void plResManager::IKeyUnreffed(plKeyImp* key) |
|
{ |
|
plRegistryPageNode* page = FindPage(key->GetUoid().GetLocation()); |
|
if (page == nil) |
|
{ |
|
hsAssert(0, "Couldn't find page that key belongs to"); |
|
return; |
|
} |
|
|
|
bool removed = page->SetKeyUnused(key); |
|
hsAssert(removed, "Key wasn't removed from page"); |
|
|
|
if (removed) |
|
{ |
|
if (!page->IsLoaded()) |
|
{ |
|
if (fPageListLock == 0) |
|
fLoadedPages.erase(page); |
|
else |
|
fPagesNeedCleanup = true; |
|
} |
|
} |
|
} |
|
|
|
////////////////////////////////////////////////////////////////////////////// |
|
//// Iterator Functions ////////////////////////////////////////////////////// |
|
////////////////////////////////////////////////////////////////////////////// |
|
|
|
//// IterateKeys Helper Class //////////////////////////////////////////////// |
|
|
|
class plKeyIterEater : public plRegistryPageIterator |
|
{ |
|
protected: |
|
plRegistryKeyIterator* fIter; |
|
|
|
public: |
|
plKeyIterEater(plRegistryKeyIterator* iter) : fIter(iter) {} |
|
virtual hsBool EatPage(plRegistryPageNode* keyNode) |
|
{ |
|
return keyNode->IterateKeys(fIter); |
|
} |
|
}; |
|
|
|
//// IterateKeys ///////////////////////////////////////////////////////////// |
|
|
|
hsBool plResManager::IterateKeys(plRegistryKeyIterator* iterator) |
|
{ |
|
plKeyIterEater myEater(iterator); |
|
return IteratePages(&myEater, nil); |
|
} |
|
|
|
hsBool plResManager::IterateKeys(plRegistryKeyIterator* iterator, const plLocation& pageToRestrictTo) |
|
{ |
|
plRegistryPageNode* page = FindPage(pageToRestrictTo); |
|
if (page == nil) |
|
{ |
|
hsAssert(false, "Page not found to iterate through"); |
|
return false; |
|
} |
|
|
|
plKeyIterEater myEater(iterator); |
|
return myEater.EatPage(page); |
|
} |
|
|
|
//// IteratePages //////////////////////////////////////////////////////////// |
|
// Iterate through all LOADED pages |
|
|
|
hsBool plResManager::IteratePages(plRegistryPageIterator* iterator, const char* ageToRestrictTo) |
|
{ |
|
ILockPages(); |
|
|
|
PageSet::const_iterator it; |
|
for (it = fLoadedPages.begin(); it != fLoadedPages.end(); it++) |
|
{ |
|
plRegistryPageNode* page = *it; |
|
if (page->GetPageInfo().GetLocation() == plLocation::kGlobalFixedLoc) |
|
continue; |
|
|
|
if (!ageToRestrictTo || hsStrCaseEQ(page->GetPageInfo().GetAge(), ageToRestrictTo)) |
|
{ |
|
if (!iterator->EatPage(page)) |
|
{ |
|
IUnlockPages(); |
|
return false; |
|
} |
|
} |
|
} |
|
|
|
IUnlockPages(); |
|
|
|
return true; |
|
} |
|
|
|
//// IterateAllPages ///////////////////////////////////////////////////////// |
|
// Iterate through ALL pages |
|
|
|
hsBool plResManager::IterateAllPages(plRegistryPageIterator* iterator) |
|
{ |
|
ILockPages(); |
|
|
|
PageSet::const_iterator it; |
|
for (it = fAllPages.begin(); it != fAllPages.end(); it++) |
|
{ |
|
plRegistryPageNode* page = *it; |
|
if (page->GetPageInfo().GetLocation() == plLocation::kGlobalFixedLoc) |
|
continue; |
|
|
|
if (!iterator->EatPage(page)) |
|
{ |
|
IUnlockPages(); |
|
return false; |
|
} |
|
} |
|
|
|
IUnlockPages(); |
|
|
|
return true; |
|
} |
|
|
|
//// ILockPages ////////////////////////////////////////////////////////////// |
|
// See, when we iterate through pages, our iterate function might decide to |
|
// move pages, either explicitly through loads or implicitly through key |
|
// deletions. So, before we iterate, we lock 'em all so they won't move, |
|
// then unlock and move them to their proper places at the end. |
|
|
|
void plResManager::ILockPages() |
|
{ |
|
if (fPageListLock == 0) |
|
fPagesNeedCleanup = false; |
|
|
|
fPageListLock++; |
|
} |
|
|
|
//// IUnlockPages //////////////////////////////////////////////////////////// |
|
|
|
void plResManager::IUnlockPages() |
|
{ |
|
fPageListLock--; |
|
if (fPageListLock == 0 && fPagesNeedCleanup) |
|
{ |
|
fPagesNeedCleanup = false; |
|
|
|
fLoadedPages.clear(); |
|
|
|
PageSet::const_iterator it; |
|
for (it = fAllPages.begin(); it != fAllPages.end(); it++) |
|
{ |
|
plRegistryPageNode* page = *it; |
|
if (page->IsLoaded()) |
|
fLoadedPages.insert(page); |
|
} |
|
} |
|
} |
|
|
|
// Defined here 'cause release build hates it defined in settings.h for some reason |
|
#include "plResMgrSettings.h" |
|
plResMgrSettings& plResMgrSettings::Get() |
|
{ |
|
static plResMgrSettings fSettings; |
|
return fSettings; |
|
}
|
|
|