DataStream* ResourceManager::GetResource(const char* ResRef, SClass_ID type, bool silent) const
{
if (ResRef[0] == '\0')
return NULL;
if (!silent) {
printMessage("ResourceManager", "Searching for %s.%s...", WHITE,
ResRef, core->TypeExt(type));
}
FileStream *str = OpenCacheFile(ConstructFilename(ResRef, core->TypeExt(type)));
if (str) {
if (!silent)
printStatus("Cache", GREEN );
return str;
}
for (size_t i = 0; i < searchPath.size(); i++) {
DataStream *ds = searchPath[i]->GetResource(ResRef, type);
if (ds) {
if (!silent) {
printStatus( searchPath[i]->GetDescription(), GREEN );
}
return ds;
}
}
if (!silent) {
printStatus( "ERROR", LIGHT_RED );
}
return NULL;
}
HRESULT KProcessPerfCacheMgr::Init(LPCWSTR strCacheFile, LPCWSTR urlMapName)
{
m_strCacheFile = strCacheFile;
m_strUrlMapName = urlMapName;
if (!OpenCacheFile())
{
if (!CreateCacheFile())
{
kws_log(TEXT("KProcessPerfCacheMgr::Init try create cache file"));
return E_FAIL;
}
if (!OpenCacheFile())
{
kws_log(TEXT("KProcessPerfCacheMgr::Init try open cache file 2 failed"));
return E_FAIL;
}
}
kws_log(TEXT("KProcessPerfCacheMgr::Init sucess"));
return S_OK;
}
DataStream* ResourceManager::AddCacheFile(const char *filename)
{
if (!core->GameOnCD)
return FileStream::OpenFile(filename);
char fname[_MAX_PATH];
ExtractFileFromPath(fname, filename);
FileStream *dest = OpenCacheFile(fname);
// already in cache
if (dest)
return dest;
FileStream* src = FileStream::OpenFile(fname);
dest = CreateCacheFile(fname);
if (!src || !dest) {
printMessage("ResourceManager", "Failed to copy file '%s'\n", RED, fname);
abort();
}
size_t blockSize = 1024 * 1000;
char buff[1024 * 1000];
do {
if (blockSize > src->Remains())
blockSize = src->Remains();
size_t len = src->Read(buff, blockSize);
size_t c = dest->Write(buff, len);
if (c != len) {
printMessage("ResourceManager", "Failed to write to file '%s'\n", RED, fname);
abort();
}
} while (src->Remains());
delete src;
delete dest;
return OpenCacheFile(fname);
}
DataStream *ResourceManager::AddCompressedCacheFile(DataStream *stream, const char* filename, int length, bool overwrite)
{
if (!core->IsAvailable(PLUGIN_COMPRESSION_ZLIB)) {
printMessage("ResourceManager", "No compression manager available.\nCannot load compressed file.\n", RED);
return NULL;
}
char fname[_MAX_PATH];
ExtractFileFromPath(fname, filename);
FileStream *str = NULL;
if (!overwrite)
str = OpenCacheFile(fname);
if (!str) {
FileStream *out = CreateCacheFile(fname);
if (!out) {
printMessage("ResourceManager", "Failed to write to file '%s'.\n", RED, fname);
return NULL;
}
PluginHolder<Compressor> comp(PLUGIN_COMPRESSION_ZLIB);
if (comp->Decompress(out, stream, length) != GEM_OK) {
delete out;
return NULL;
}
delete out;
} else {
stream->Seek(length, GEM_CURRENT_POS);
}
delete str;
return OpenCacheFile(fname);
}
Resource* ResourceManager::GetResource(const char* ResRef, const TypeID *type, bool silent) const
{
if (ResRef[0] == '\0')
return NULL;
if (!silent) {
printMessage("ResourceManager", "Searching for %s... ", WHITE, ResRef);
}
const std::vector<ResourceDesc> &types = PluginMgr::Get()->GetResourceDesc(type);
for (size_t j = 0; j < types.size(); j++) {
FileStream *str = OpenCacheFile(ConstructFilename(ResRef, types[j].GetExt()));
if (str) {
Resource *res = types[j].Create(str);
if (!silent) {
print( "%s.%s...", ResRef, types[j].GetExt() );
printStatus("Cache", GREEN);
}
return res;
}
}
for (size_t j = 0; j < types.size(); j++) {
for (size_t i = 0; i < searchPath.size(); i++) {
DataStream *str = searchPath[i]->GetResource(ResRef, types[j]);
if (str) {
Resource *res = types[j].Create(str);
if (res) {
if (!silent) {
print( "%s.%s...", ResRef, types[j].GetExt() );
printStatus( searchPath[i]->GetDescription(), GREEN );
}
return res;
}
}
}
}
if (!silent) {
print("Tried ");
PrintPossibleFiles(ResRef,type);
printStatus( "ERROR", LIGHT_RED );
}
return NULL;
}
