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.
244 lines
9.1 KiB
244 lines
9.1 KiB
14 years ago
|
/*==LICENSE==*
|
||
|
|
||
|
CyanWorlds.com Engine - MMOG client, server and tools
|
||
13 years ago
|
Copyright (C) 2011 Cyan Worlds, Inc.
|
||
14 years ago
|
|
||
|
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
|
||
13 years ago
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
14 years ago
|
GNU General Public License for more details.
|
||
|
|
||
|
You should have received a copy of the GNU General Public License
|
||
13 years ago
|
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.
|
||
14 years ago
|
|
||
|
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 plResManager_h_inc
|
||
|
#define plResManager_h_inc
|
||
|
|
||
|
#include "hsResMgr.h"
|
||
|
#include <set>
|
||
|
#include <map>
|
||
|
#include <vector>
|
||
|
|
||
|
class plRegistryPageNode;
|
||
|
class plRegistryKeyIterator;
|
||
|
class plRegistryPageIterator;
|
||
|
class plRegistryDataStream;
|
||
|
class plResAgeHolder;
|
||
|
class plResManagerHelper;
|
||
|
class plDispatch;
|
||
|
|
||
|
// plProgressProc is a proc called every time an object loads, to keep a progress bar for
|
||
|
// loading ages up-to-date.
|
||
|
typedef void(*plProgressProc)(plKey key);
|
||
|
|
||
|
class plResManager : public hsResMgr
|
||
|
{
|
||
|
public:
|
||
|
plResManager();
|
||
|
virtual ~plResManager();
|
||
|
|
||
|
// If the ResManager has already been initialized, you should call Reset after setting this
|
||
|
void SetDataPath(const char* path) { fDataPath = path; }
|
||
|
|
||
|
// Mainly for external tools.
|
||
|
void AddSinglePage(const char* path);
|
||
|
plRegistryPageNode* FindSinglePage(const char* path) const;
|
||
|
void RemoveSinglePage(const char* path);
|
||
|
|
||
|
//---------------------------
|
||
|
// Load and Unload
|
||
|
//---------------------------
|
||
|
virtual void Load (const plKey& objKey); // places on list to be loaded
|
||
|
virtual hsBool Unload(const plKey& objKey); // Unregisters (deletes) an object, Return true if successful
|
||
|
virtual plKey CloneKey(const plKey& objKey);
|
||
|
|
||
|
//---------------------------
|
||
|
// Finding Functions
|
||
|
//---------------------------
|
||
|
plKey FindOriginalKey(const plUoid&);
|
||
|
virtual plKey FindKey(const plUoid&); // Same as above, but will check the uoid for clones
|
||
|
const plLocation& FindLocation(const char* age, const char* page) const;
|
||
|
// Use nil for any strings you don't need
|
||
|
const void GetLocationStrings(const plLocation& loc, char* ageBuffer, char* pageBuffer) const;
|
||
|
|
||
|
//---------------------------
|
||
|
// Establish reference linkage
|
||
|
//---------------------------
|
||
|
virtual hsBool AddViaNotify(const plKey& key, plRefMsg* msg, plRefFlags::Type flags);
|
||
|
virtual hsBool AddViaNotify(plRefMsg* msg, plRefFlags::Type flags); // msg->fRef->GetKey() == sentKey
|
||
|
|
||
|
virtual hsBool SendRef(const plKey& key, plRefMsg* refMsg, plRefFlags::Type flags);
|
||
|
virtual hsBool SendRef(hsKeyedObject* ko, plRefMsg* refMsg, plRefFlags::Type flags);
|
||
|
|
||
|
//---------------------------
|
||
|
// Reding and Writing keys
|
||
|
//---------------------------
|
||
|
// Read a Key in, and Notify me when the Object is loaded
|
||
|
virtual plKey ReadKeyNotifyMe(hsStream* stream, plRefMsg* retMsg, plRefFlags::Type flags);
|
||
|
// Just read the Key data in and find a match in the registry and return it.
|
||
|
virtual plKey ReadKey(hsStream* stream);
|
||
|
|
||
|
// For convenience you can write a key using the KeyedObject or the Key...same result
|
||
|
virtual void WriteKey(hsStream* s, hsKeyedObject* obj);
|
||
|
virtual void WriteKey(hsStream* s, const plKey& key);
|
||
|
|
||
|
//---------------------------
|
||
|
// Reding and Writing Objects directly
|
||
|
//---------------------------
|
||
|
virtual plCreatable* ReadCreatable(hsStream* s);
|
||
|
virtual void WriteCreatable(hsStream* s, plCreatable* cre);
|
||
|
|
||
|
virtual plCreatable* ReadCreatableVersion(hsStream* s);
|
||
|
virtual void WriteCreatableVersion(hsStream* s, plCreatable* cre);
|
||
|
|
||
|
//---------------------------
|
||
|
// Registry Modification Functions
|
||
|
//---------------------------
|
||
|
virtual plKey NewKey(const char* name, hsKeyedObject* object, const plLocation& loc, const plLoadMask& m = plLoadMask::kAlways);
|
||
|
virtual plKey NewKey(plUoid& newUoid, hsKeyedObject* object);
|
||
|
|
||
|
virtual plDispatchBase* Dispatch();
|
||
|
|
||
|
virtual void SetProgressBarProc(plProgressProc proc);
|
||
|
|
||
|
//---------------------------
|
||
|
// Load optimizations
|
||
|
//---------------------------
|
||
|
void LoadAgeKeys(const char* age);
|
||
|
void DropAgeKeys(const char* age);
|
||
|
void PageInRoom(const plLocation& page, UInt16 objClassToRef, plRefMsg* refMsg);
|
||
|
void PageInAge(const char* age);
|
||
|
|
||
|
// Usually, a page file is kept open during load because the first keyed object
|
||
|
// read causes all the other objects to be read before it returns. In some
|
||
|
// cases though (mostly just the texture file), this doesn't work. In that
|
||
|
// case, we just want to force it to stay open until we're done reading the age.
|
||
|
void KeepPageOpen(const plLocation& page, hsBool keepOpen);
|
||
|
|
||
|
// We're on the way down, act accordingly.
|
||
|
virtual void BeginShutdown();
|
||
|
|
||
|
// Determines whether the time to read each object is dumped to a log
|
||
|
void LogReadTimes(hsBool logReadTimes);
|
||
|
|
||
|
// All keys version
|
||
|
hsBool IterateKeys(plRegistryKeyIterator* iterator);
|
||
|
// Single page version
|
||
|
hsBool IterateKeys(plRegistryKeyIterator* iterator, const plLocation& pageToRestrictTo);
|
||
|
// Iterate through loaded pages
|
||
|
hsBool IteratePages(plRegistryPageIterator* iterator, const char* ageToRestrictTo = nil);
|
||
|
// Iterate through ALL pages, loaded or not
|
||
|
hsBool IterateAllPages(plRegistryPageIterator* iterator);
|
||
|
|
||
|
// Helpers for key iterators
|
||
|
void LoadPageKeys(plRegistryPageNode* pageNode);
|
||
|
void UnloadPageObjects(plRegistryPageNode* pageNode, UInt16 classIndexHint);
|
||
|
void DumpUnusedKeys(plRegistryPageNode* page) const;
|
||
|
plRegistryPageNode* FindPage(const plLocation& location) const;
|
||
|
plRegistryPageNode* FindPage(const char* age, const char* page) const;
|
||
|
|
||
|
// Runs through all the pages and verifies that the data versions are good
|
||
|
hsBool VerifyPages();
|
||
|
|
||
|
protected:
|
||
|
friend class hsKeyedObject;
|
||
|
friend class plKeyImp;
|
||
|
friend class plResManagerHelper;
|
||
|
|
||
|
virtual plKey ReRegister(const char* nm, const plUoid& uoid);
|
||
|
virtual hsBool ReadObject(plKeyImp* key); // plKeys call this when needed
|
||
|
virtual hsBool IReadObject(plKeyImp* pKey, hsStream *stream);
|
||
|
|
||
|
plCreatable* IReadCreatable(hsStream* s) const;
|
||
|
plKey ICloneKey(const plUoid& objUoid, UInt32 playerID, UInt32 cloneID);
|
||
|
|
||
|
virtual void IKeyReffed(plKeyImp* key);
|
||
|
virtual void IKeyUnreffed(plKeyImp* key);
|
||
|
|
||
|
virtual hsBool IReset();
|
||
|
virtual hsBool IInit();
|
||
|
virtual void IShutdown();
|
||
|
|
||
|
void IPageOutSceneNodes(hsBool forceAll);
|
||
|
void IDropAllAgeKeys();
|
||
|
|
||
|
hsKeyedObject* IGetSharedObject(plKeyImp* pKey);
|
||
|
|
||
|
void IUnloadPageKeys(plRegistryPageNode* pageNode, hsBool dontClear = false);
|
||
|
|
||
|
hsBool IDeleteBadPages(hsTArray<plRegistryPageNode*>& invalidPages, hsBool conflictingSeqNums);
|
||
|
hsBool IWarnNewerPages(hsTArray<plRegistryPageNode*>& newerPages);
|
||
|
|
||
|
void ILockPages();
|
||
|
void IUnlockPages();
|
||
|
|
||
|
void AddPage(plRegistryPageNode* page);
|
||
|
|
||
|
// Adds a key to the registry. Assumes uoid already set
|
||
|
void AddKey(plKeyImp* key);
|
||
|
|
||
|
plRegistryPageNode* CreatePage(const plLocation& location, const char* age, const char* page);
|
||
|
|
||
|
hsBool fInited;
|
||
|
UInt16 fPageOutHint;
|
||
|
|
||
|
// True if we're reading in an object. We only read one object at a time
|
||
|
hsBool fReadingObject;
|
||
|
std::vector<plKey> fQueuedReads;
|
||
|
|
||
|
std::string fDataPath;
|
||
|
|
||
|
plDispatch* fDispatch;
|
||
|
|
||
|
UInt32 fCurCloneID; // Current clone ID. If it isn't zero, we're cloning
|
||
|
UInt32 fCurClonePlayerID;
|
||
|
UInt32 fCloningCounter; // Next clone ID to use.
|
||
|
|
||
|
typedef std::map<std::string,plResAgeHolder*> HeldAgeKeyMap;
|
||
|
HeldAgeKeyMap fHeldAgeKeys;
|
||
|
plProgressProc fProgressProc;
|
||
|
|
||
|
plResManagerHelper *fMyHelper;
|
||
|
|
||
|
hsBool fLogReadTimes;
|
||
|
|
||
|
UInt8 fPageListLock; // Number of locks on the page lists. If it's greater than zero, they can't be modified
|
||
|
hsBool fPagesNeedCleanup; // True if something modified the page lists while they were locked.
|
||
|
|
||
|
typedef std::set<plRegistryPageNode*> PageSet;
|
||
|
PageSet fAllPages; // All the pages, loaded or not
|
||
|
PageSet fLoadedPages; // Just the loaded pages
|
||
|
|
||
|
mutable plRegistryPageNode* fLastFoundPage;
|
||
|
};
|
||
|
|
||
|
#endif // plResManager_h_inc
|