Cyd
2b8ca921cb
Complete disaster-recovery snapshot: engine/game source, game data assets, VC6 toolchain + DX SDKs, build outputs, deployed game, and _UNUSED archive. Large binaries in Git LFS; text preserved byte-for-byte (core.autocrlf=false, no eol attributes). See RECOVERY.md for the one-clone rebuild procedure.
406 lines
10 KiB
C++
406 lines
10 KiB
C++
#pragma once
|
|
|
|
#include "Adept.hpp"
|
|
#include <Stuff\Database.hpp>
|
|
|
|
namespace Adept {class ResourceID;}
|
|
|
|
#if !defined(Spew)
|
|
void Spew(
|
|
const char* group,
|
|
const Adept::ResourceID& id
|
|
);
|
|
#endif
|
|
|
|
namespace GetHashFunctions {
|
|
unsigned GetHashValue(const Adept::ResourceID &value);
|
|
}
|
|
|
|
namespace Stuff {
|
|
bool Close_Enough(
|
|
const Adept::ResourceID &id1,
|
|
const Adept::ResourceID &id2,
|
|
Scalar e = SMALL
|
|
);
|
|
}
|
|
|
|
namespace Adept {
|
|
|
|
class ResourceFile;
|
|
|
|
//##########################################################################
|
|
//########################## ResourceID ##############################
|
|
//##########################################################################
|
|
|
|
//
|
|
// The resource ID holds the file ID and record ID together. It is used
|
|
// for storing a unique identifier for the resource, and for indexing into
|
|
// the data structures holding the data.
|
|
//
|
|
|
|
class ResourceID
|
|
{
|
|
public:
|
|
ResourceID():
|
|
m_fileID(-1),
|
|
m_recordID(0)
|
|
{}
|
|
explicit ResourceID(ResourceFile *file);
|
|
ResourceID(const ResourceID& resource_id):
|
|
m_fileID(resource_id.m_fileID),
|
|
m_recordID(resource_id.m_recordID)
|
|
{}
|
|
ResourceID(
|
|
short file_id,
|
|
WORD record_id
|
|
):
|
|
m_fileID(file_id),
|
|
m_recordID(record_id)
|
|
{}
|
|
|
|
bool TestInstance() const
|
|
{return true;}
|
|
|
|
//Accessor Functions
|
|
public:
|
|
short GetFileID() const
|
|
{return m_fileID;}
|
|
WORD GetRecordID() const
|
|
{return m_recordID;}
|
|
|
|
public:
|
|
ResourceID& operator=(const ResourceID& resource_id)
|
|
{
|
|
Check_Pointer(this); Check_Object(&resource_id);
|
|
m_fileID = resource_id.m_fileID; m_recordID = resource_id.m_recordID;
|
|
return *this;
|
|
}
|
|
|
|
bool operator==(const ResourceID& resource_id) const
|
|
{
|
|
return
|
|
m_fileID == resource_id.m_fileID &&
|
|
m_recordID == resource_id.m_recordID;
|
|
}
|
|
bool operator!=(const ResourceID& resource_id) const
|
|
{
|
|
return
|
|
m_fileID != resource_id.m_fileID ||
|
|
m_recordID != resource_id.m_recordID;
|
|
}
|
|
bool operator>(const ResourceID& resource_id) const
|
|
{
|
|
return
|
|
(m_fileID == resource_id.m_fileID) ?
|
|
(m_recordID > resource_id.m_recordID) :
|
|
(m_fileID > resource_id.m_fileID);
|
|
}
|
|
bool operator!() const
|
|
{return operator==(Null);}
|
|
|
|
friend bool Stuff::Close_Enough(
|
|
const Adept::ResourceID &id1,
|
|
const Adept::ResourceID &id2,
|
|
Scalar e
|
|
);
|
|
|
|
#if !defined(Spew)
|
|
friend void ::Spew(
|
|
const char* group,
|
|
const ResourceID& resource_id
|
|
)
|
|
{
|
|
Check_Object(&resource_id);
|
|
SPEW((
|
|
group,
|
|
"%d:%d+",
|
|
resource_id.m_fileID,
|
|
resource_id.m_recordID
|
|
));
|
|
}
|
|
#endif
|
|
|
|
friend unsigned GetHashFunctions::GetHashValue(const ResourceID &value)
|
|
{
|
|
//
|
|
// Verify that the unsigned is 32 bits wide
|
|
// Hash value is first 16 bits of m_fileID and first 16 bits of m_recordID
|
|
//
|
|
return ((value.m_fileID) << 16 | value.m_recordID);
|
|
}
|
|
|
|
static ResourceID Null;
|
|
|
|
enum {
|
|
BuildDependenciesRecordID,
|
|
FirstFreeRecordID
|
|
};
|
|
|
|
short m_fileID;
|
|
WORD m_recordID;
|
|
};
|
|
|
|
//##########################################################################
|
|
//########################### Resource ###############################
|
|
//##########################################################################
|
|
|
|
class Resource:
|
|
public Stuff::MemoryStream
|
|
{
|
|
friend class ResourceManager;
|
|
friend class ResourceFile;
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Constructors, Destructors, & Testing
|
|
//
|
|
public:
|
|
//
|
|
// This constructor is used to provide a return mechanism for building
|
|
// resources in another function
|
|
//
|
|
Resource();
|
|
|
|
//
|
|
// These constructors will find the resource and load it
|
|
//
|
|
explicit Resource(const ResourceID &resource_id, bool load=true);
|
|
explicit Resource(const char* name, bool load=false);
|
|
explicit Resource(const char* name, ResourceFile *resource_file, bool load=false);
|
|
|
|
~Resource();
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Accessors
|
|
//
|
|
public:
|
|
void FindID(const ResourceID &resource_id, bool load=true);
|
|
void FindName(const char* name, bool load=false);
|
|
|
|
void LoadData();
|
|
void UnloadData();
|
|
void AbandonData();
|
|
int GetDiskOffset();
|
|
DWORD GetCompressedSize() { return m_handle.GetRealRecordSize();}
|
|
|
|
void First(ResourceFile *file);
|
|
bool ReadAndNext();
|
|
|
|
const ResourceID& GetResourceID()
|
|
{Check_Object(this); return m_ID;}
|
|
const char* GetName()
|
|
{Check_Object(this); return m_handle.m_name;}
|
|
|
|
protected:
|
|
Stuff::RecordHandle m_handle;
|
|
ResourceID m_ID;
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Building functions
|
|
//
|
|
public:
|
|
bool DoesResourceExist()
|
|
{
|
|
Check_Object(this);
|
|
return m_handle.m_record != NULL && streamSize>0;
|
|
}
|
|
bool IsResourceUpToDate();
|
|
bool IsRegistered();
|
|
|
|
void Save(
|
|
Stuff::MemoryStream *stream,
|
|
const Stuff::FileDependencies *dependencies
|
|
);
|
|
void ChangeName(const char* new_name);
|
|
|
|
void AddFileDependenciesTo(Stuff::FileDependencies *dependencies);
|
|
void GetFileDependencies(Stuff::FileDependencies *dependencies);
|
|
static Stuff::FileDependencies *ParentFileDependencies;
|
|
};
|
|
|
|
//##########################################################################
|
|
//####################### ResourceFile ###############################
|
|
//##########################################################################
|
|
|
|
class ResourceFile:
|
|
public Stuff::Plug
|
|
{
|
|
friend class ResourceManager;
|
|
friend class Resource;
|
|
friend class ResourceID;
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Constructors, Destructors, & Testing
|
|
//
|
|
public:
|
|
ResourceFile(
|
|
Stuff::DatabaseHandle *handle,
|
|
Stuff::DatabaseHandle *dependency_handle,
|
|
short file_id,
|
|
bool does_auto_close
|
|
):
|
|
Plug(DefaultData),
|
|
m_fileHandle(handle),
|
|
m_dependencyHandle(dependency_handle),
|
|
m_fileID(file_id),
|
|
m_lastRegisteredRecordID(-1),
|
|
m_doesCloseOnCloseAll(does_auto_close)
|
|
{Check_Pointer(this);}
|
|
~ResourceFile();
|
|
|
|
void Save();
|
|
void SaveAs(const char* filename);
|
|
void ScatterSave();
|
|
void UnloadRecordData();
|
|
|
|
void SetLastRegisteredResourceID(const ResourceID &res_id);
|
|
|
|
__int64 CalculateCRC(int core_key);
|
|
|
|
__int64 CalculateDateCRC()
|
|
{Check_Object(this); Check_Object(m_fileHandle); return m_fileHandle->CalculateDateCRC();};
|
|
|
|
short GetFileID()
|
|
{Check_Object(this); return m_fileID;}
|
|
HGOSFILE GetFileHandle()
|
|
{Check_Object(this); return m_fileHandle->GetFileHandle();}
|
|
|
|
Stuff::MString
|
|
GetFileName()
|
|
{Check_Object(this); return m_fileHandle->GetFileName();}
|
|
bool
|
|
DoesCloseOnCloseAll()
|
|
{Check_Object(this); return m_doesCloseOnCloseAll;}
|
|
|
|
protected:
|
|
Stuff::DatabaseHandle
|
|
*m_fileHandle,
|
|
*m_dependencyHandle;
|
|
WORD m_lastRegisteredRecordID;
|
|
short m_fileID;
|
|
bool m_doesCloseOnCloseAll;
|
|
};
|
|
|
|
inline ResourceID::ResourceID(ResourceFile *file):
|
|
m_fileID(file->m_fileID),
|
|
m_recordID(0)
|
|
{
|
|
}
|
|
|
|
//##########################################################################
|
|
//####################### ResourceManager ############################
|
|
//##########################################################################
|
|
|
|
//
|
|
// The resource manager maintains the list of open resource files, a cache
|
|
// of recently opened resources, and a file that overrides the static
|
|
// resources.
|
|
//
|
|
|
|
class ResourceManager:
|
|
public Stuff::Plug
|
|
{
|
|
friend class Resource;
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Constructors, Destructors, & Testing
|
|
//
|
|
public:
|
|
explicit ResourceManager();
|
|
~ResourceManager();
|
|
|
|
static void TestClass();
|
|
|
|
static ResourceManager *Instance;
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Public Interface
|
|
//
|
|
// OpenResourceFile - Opens a resource file of name file_name and gives
|
|
// it file ID file_ID. The file may be opened in read only mode. If
|
|
// the file is opened in read/write mode, the current file may be
|
|
// overwritten.
|
|
//
|
|
// Close - Closes a resource file
|
|
//
|
|
public:
|
|
ResourceFile* OpenResourceFile(
|
|
const char *file_name,
|
|
const char *dep_file,
|
|
short file_ID,
|
|
DWORD content_version,
|
|
bool core,
|
|
bool overwrite,
|
|
bool close_on_close_all = true //This parameter is for the CloseAllButCore Function
|
|
);
|
|
ResourceFile* OpenResourceFile(
|
|
Stuff::DatabaseHandle *database,
|
|
short file_ID,
|
|
bool core,
|
|
bool close_on_close_all = true //This parameter is for the CloseAllButCore Function
|
|
);
|
|
|
|
ResourceFile* OpenResourceFile(
|
|
Stuff::DatabaseHandle *database,
|
|
const char *dep_file,
|
|
short file_ID,
|
|
DWORD content_version,
|
|
bool core,
|
|
bool overwrite,
|
|
bool close_on_close_all = true //This parameter is for the CloseAllButCore Function
|
|
);
|
|
|
|
|
|
ResourceFile* OpenResourceFile(
|
|
Stuff::MemoryStream *stream,
|
|
const char *file_name,
|
|
const char *dep_file,
|
|
short file_ID,
|
|
DWORD content_version,
|
|
bool core,
|
|
bool close_on_close_all = true //This parameter is for the CloseAllButCore Function
|
|
);
|
|
|
|
void SaveAll();
|
|
|
|
void CloseAllButCore();
|
|
void SpewLoadedResources();
|
|
|
|
ResourceFile* GetResourceFile(short file_id)
|
|
{Check_Object(this); return m_openedFiles.Find(file_id);}
|
|
short AllocateResourceFileID()
|
|
{Check_Object(this); return m_nextResourceFileID++;}
|
|
|
|
|
|
short FindOpenResourceID();
|
|
|
|
protected:
|
|
short m_nextResourceFileID;
|
|
|
|
Stuff::TableOf<ResourceFile*, short> m_openedFiles;
|
|
Stuff::ChainOf<ResourceFile*> m_nonCoreFiles;
|
|
};
|
|
}
|
|
|
|
namespace MemoryStreamIO {
|
|
|
|
inline Stuff::MemoryStream& Read(
|
|
Stuff::MemoryStream *stream,
|
|
Adept::ResourceID *output
|
|
)
|
|
{
|
|
Check_Object(stream);
|
|
return stream->ReadBytes(output, sizeof(*output));
|
|
}
|
|
|
|
inline Stuff::MemoryStream& Write(
|
|
Stuff::MemoryStream *stream,
|
|
const Adept::ResourceID *input
|
|
)
|
|
{
|
|
Check_Object(stream);
|
|
return stream->WriteBytes(input, sizeof(*input));
|
|
}
|
|
|
|
}
|
|
|