void CALL HGE_Impl::System_SetStateString(hgeStringState state, const char *value)
{
FILE *hf;
switch(state)
{
case HGE_ICON: szIcon=value;
if(pHGE->hwnd) SetClassLong(pHGE->hwnd, GCL_HICON, (LONG)LoadIcon(pHGE->hInstance, szIcon));
break;
case HGE_TITLE: strcpy(szWinTitle,value);
if(pHGE->hwnd) SetWindowText(pHGE->hwnd, szWinTitle);
break;
case HGE_INIFILE: if(value) strcpy(szIniFile,Resource_MakePath(value));
else szIniFile[0]=0;
break;
case HGE_LOGFILE: if(value)
{
strcpy(szLogFile,Resource_MakePath(value));
hf=fopen(szLogFile, "w");
if(!hf) szLogFile[0]=0;
else fclose(hf);
}
else szLogFile[0]=0;
break;
}
}
void CALL HGE_Impl::System_Snapshot(const char *filename)
{
LPDIRECT3DSURFACE9 pSurf;
char *shotname, tempname[_MAX_PATH];
int i;
if(!filename)
{
i=0;
shotname=Resource_EnumFiles("shot???.bmp");
while(shotname)
{
i++;
shotname=Resource_EnumFiles();
}
sprintf(tempname, "shot%03d.bmp", i);
filename=Resource_MakePath(tempname);
}
if(pD3DDevice)
{
pD3DDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &pSurf);
D3DXSaveSurfaceToFile(filename, D3DXIFF_BMP, pSurf, NULL, NULL);
pSurf->Release();
}
}
char* HGE_CALL HGE_Impl::Resource_EnumFolders(const char* wildcard) {
if (wildcard) {
if (h_search_) {
FindClose(h_search_);
h_search_ = nullptr;
}
h_search_ = FindFirstFile(Resource_MakePath(wildcard), &search_data_);
if (h_search_ == INVALID_HANDLE_VALUE) {
h_search_ = nullptr;
return nullptr;
}
if ((search_data_.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
strcmp(search_data_.cFileName, ".") && strcmp(search_data_.cFileName, "..")) {
return search_data_.cFileName;
}
return Resource_EnumFolders();
}
if (!h_search_) {
return nullptr;
}
for (;;) {
if (!FindNextFile(h_search_, &search_data_)) {
FindClose(h_search_);
h_search_ = nullptr;
return nullptr;
}
if ((search_data_.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
strcmp(search_data_.cFileName, ".") && strcmp(search_data_.cFileName, "..")) {
return search_data_.cFileName;
}
}
}
bool CALL HGE_Impl::Resource_AttachPack(const char *filename, const char *password)
{
char *szName;
CResourceList *resItem=res;
unzFile zip;
szName=Resource_MakePath(filename);
while(resItem)
{
if(!strcmp(szName,resItem->filename)) return false;
resItem=resItem->next;
}
zip=unzOpen(szName);
if(!zip) {
System_Log("Unable to unzip: %s", szName);
return false;
}
unzClose(zip);
resItem=new CResourceList;
strcpy(resItem->filename, szName);
if(password) strcpy(resItem->password, password);
else resItem->password[0]=0;
resItem->next=res;
res=resItem;
return true;
}
void HGE_CALL HGE_Impl::Resource_RemovePack(const char *filename)
{
char *szName;
//resource_packs_item_t *resItem = m_resources, *resPrev = 0;
szName = Resource_MakePath(filename);
strupr(szName);
// while (resItem)
// {
// if (!strcmp(szName, resItem->filename))
// {
// if (resPrev)
// resPrev->next = resItem->next;
// else
// m_resources = resItem->next;
// delete resItem;
// break;
// }
//
// resPrev = resItem;
// resItem = resItem->next;
// }
auto itr = m_resources.find( szName );
if ( itr != m_resources.end() ) {
m_resources.erase( szName );
}
}
bool HGE_CALL HGE_Impl::Resource_AttachPack(const char* filename, const char* password) {
auto res_item = res_list_;
const auto sz_name = Resource_MakePath(filename);
strupr(sz_name);
while (res_item) {
if (!strcmp(sz_name, res_item->filename)) {
return false;
}
res_item = res_item->next;
}
const auto zip = unzOpen(sz_name);
if (!zip) {
return false;
}
unzClose(zip);
res_item = new CResourceList;
strcpy(res_item->filename, sz_name);
if (password) {
strcpy(res_item->password, password);
}
else {
res_item->password[0] = 0;
}
res_item->next = res_list_;
res_list_ = res_item;
return true;
}
char* CALL HGE_Impl::Resource_EnumFolders(const char *wildcard)
{
if(wildcard)
{
if(hSearch) { FindClose(hSearch); hSearch=0; }
hSearch=FindFirstFile(Resource_MakePath(wildcard), &SearchData);
if(hSearch==INVALID_HANDLE_VALUE) { hSearch=0; return 0; }
if((SearchData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
strcmp(SearchData.cFileName,".") && strcmp(SearchData.cFileName,".."))
return SearchData.cFileName;
else return Resource_EnumFolders();
}
else
{
if(!hSearch) return 0;
for(;;)
{
if(!FindNextFile(hSearch, &SearchData)) { FindClose(hSearch); hSearch=0; return 0; }
if((SearchData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
strcmp(SearchData.cFileName,".") && strcmp(SearchData.cFileName,".."))
return SearchData.cFileName;
}
}
}
bool HGE_CALL HGE_Impl::Resource_AttachPack(const char *filename, const char *password)
{
char *szName;
CResourceList *resItem=res;
unzFile zip;
szName=Resource_MakePath(filename);
strupr(szName);
while(resItem) {
if(!strcmp(szName,resItem->filename)) {
return false;
}
resItem=resItem->next;
}
zip=unzOpen(szName);
if(!zip) {
return false;
}
unzClose(zip);
resItem=new CResourceList;
strcpy(resItem->filename, szName);
if(password) {
strcpy(resItem->password, password);
} else {
resItem->password[0]=0;
}
resItem->next=res;
res=resItem;
return true;
}
void CALL HGE_Impl::Resource_RemovePack(const char *filename)
{
char *szName;
CResourceList *resItem=res, *resPrev=0;
szName=Resource_MakePath(filename);
while(resItem)
{
if(!strcmp(szName,resItem->filename))
{
if(resPrev) resPrev->next=resItem->next;
else res=resItem->next;
delete resItem;
break;
}
resPrev=resItem;
resItem=resItem->next;
}
}
bool HGE_Impl::_PrepareFileEnum(const char *wildcard)
{
if(hSearch) { closedir(hSearch); hSearch=0; }
char *madepath = Resource_MakePath(wildcard);
const char *fname = strrchr(madepath, '/');
const char *dir = NULL;
if (fname == NULL) {
dir = ".";
fname = madepath;
} else {
dir = madepath;
char *ptr = (char *) fname;
*ptr = '\0'; // split dir and filename.
fname++;
}
strcpy(szSearchDir, dir);
strcpy(szSearchWildcard, fname);
hSearch=opendir(dir);
return (hSearch!=0);
}
char* HGE_CALL HGE_Impl::Resource_EnumFiles(const char *wildcard)
{
if (wildcard)
{
if (m_hsearch)
{
FindClose(m_hsearch);
m_hsearch = 0;
}
m_hsearch = FindFirstFile(Resource_MakePath(wildcard), &m_search_data);
if (m_hsearch == INVALID_HANDLE_VALUE)
{
m_hsearch = 0;
return 0;
}
if (!(m_search_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
return m_search_data.cFileName;
else
return Resource_EnumFiles();
}
else
{
if (!m_hsearch)
return 0;
for (;;)
{
if (!FindNextFile(m_hsearch, &m_search_data))
{
FindClose(m_hsearch);
m_hsearch = 0;
return 0;
}
if (!(m_search_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
return m_search_data.cFileName;
}
}
}
void HGE_CALL HGE_Impl::Resource_RemovePack(const char* filename) {
auto res_item = res_list_;
CResourceList* res_prev = nullptr;
const auto sz_name = Resource_MakePath(filename);
strupr(sz_name);
while (res_item) {
if (!strcmp(sz_name, res_item->filename)) {
if (res_prev) {
res_prev->next = res_item->next;
}
else {
res_list_ = res_item->next;
}
delete res_item;
break;
}
res_prev = res_item;
res_item = res_item->next;
}
}
void* CALL HGE_Impl::Resource_Load(const char *filename, DWORD *size)
{
const char *res_err="Can't load resource: %s";
CResourceList *resItem=res;
char szName[_MAX_PATH];
char szZipName[_MAX_PATH];
unzFile zip;
unz_file_info file_info;
int done, i;
void *ptr;
FILE *hF;
if(filename[0]=='\\' || filename[0]=='/' || filename[1]==':') goto _fromfile; // skip absolute paths
// Load from pack
strcpy(szName,filename);
for(i=0; szName[i]; i++) { if(szName[i]=='/') szName[i]='\\'; }
while(resItem)
{
zip=unzOpen(resItem->filename);
done=unzGoToFirstFile(zip);
while(done==UNZ_OK)
{
unzGetCurrentFileInfo(zip, &file_info, szZipName, sizeof(szZipName), NULL, 0, NULL, 0);
for(i=0; szZipName[i]; i++) { if(szZipName[i]=='/') szZipName[i]='\\'; }
if(!strcmp(szName,szZipName))
{
if(unzOpenCurrentFilePassword(zip, resItem->password[0] ? resItem->password : 0) != UNZ_OK)
{
unzClose(zip);
sprintf(szName, res_err, filename);
_PostError(szName);
return 0;
}
ptr = malloc(file_info.uncompressed_size);
if(!ptr)
{
unzCloseCurrentFile(zip);
unzClose(zip);
sprintf(szName, res_err, filename);
_PostError(szName);
return 0;
}
if(unzReadCurrentFile(zip, ptr, file_info.uncompressed_size) < 0)
{
unzCloseCurrentFile(zip);
unzClose(zip);
free(ptr);
sprintf(szName, res_err, filename);
_PostError(szName);
return 0;
}
unzCloseCurrentFile(zip);
unzClose(zip);
if(size) *size=file_info.uncompressed_size;
return ptr;
}
done=unzGoToNextFile(zip);
}
unzClose(zip);
resItem=resItem->next;
}
// Load from file
_fromfile:
hF = fopen(Resource_MakePath(filename), "rb");
if(hF == NULL)
{
sprintf(szName, res_err, filename);
_PostError(szName);
return 0;
}
struct stat statbuf;
if (fstat(fileno(hF), &statbuf) == -1)
{
fclose(hF);
sprintf(szName, res_err, filename);
_PostError(szName);
return 0;
}
file_info.uncompressed_size = statbuf.st_size;
ptr = malloc(file_info.uncompressed_size);
if(!ptr)
{
fclose(hF);
sprintf(szName, res_err, filename);
_PostError(szName);
return 0;
}
if(fread(ptr, file_info.uncompressed_size, 1, hF) != 1)
{
fclose(hF);
free(ptr);
sprintf(szName, res_err, filename);
_PostError(szName);
return 0;
}
fclose(hF);
if(size) *size=file_info.uncompressed_size;
return ptr;
}
void* HGE_CALL HGE_Impl::Resource_Load(const char* filename, uint32_t* size) {
static char* res_err = "Can't load resource: %s";
auto res_item = res_list_;
char sz_name[_MAX_PATH];
char sz_zip_name[_MAX_PATH];
unz_file_info file_info;
int i;
void* ptr;
if (filename[0] == '\\' || filename[0] == '/' || filename[1] == ':') {
goto _fromfile; // skip absolute paths
}
// Load from pack
strcpy(sz_name, filename);
strupr(sz_name);
for (i = 0; sz_name[i]; i++) {
if (sz_name[i] == '/') {
sz_name[i] = '\\';
}
}
while (res_item) {
const auto zip = unzOpen(res_item->filename);
auto done = unzGoToFirstFile(zip);
while (done == UNZ_OK) {
unzGetCurrentFileInfo(zip, &file_info, sz_zip_name, sizeof(sz_zip_name), nullptr, 0,
nullptr, 0);
strupr(sz_zip_name);
for (i = 0; sz_zip_name[i]; i++) {
if (sz_zip_name[i] == '/') {
sz_zip_name[i] = '\\';
}
}
if (!strcmp(sz_name, sz_zip_name)) {
if (unzOpenCurrentFilePassword(zip, res_item->password[0] ? res_item->password : 0)
!=
UNZ_OK) {
unzClose(zip);
sprintf(sz_name, res_err, filename);
post_error(sz_name);
return nullptr;
}
ptr = malloc(file_info.uncompressed_size);
if (!ptr) {
unzCloseCurrentFile(zip);
unzClose(zip);
sprintf(sz_name, res_err, filename);
post_error(sz_name);
return nullptr;
}
if (unzReadCurrentFile(zip, ptr, file_info.uncompressed_size) < 0) {
unzCloseCurrentFile(zip);
unzClose(zip);
free(ptr);
sprintf(sz_name, res_err, filename);
post_error(sz_name);
return nullptr;
}
unzCloseCurrentFile(zip);
unzClose(zip);
if (size) {
*size = file_info.uncompressed_size;
}
return ptr;
}
done = unzGoToNextFile(zip);
}
unzClose(zip);
res_item = res_item->next;
}
// Load from file
_fromfile:
const auto h_f = CreateFile(Resource_MakePath(filename), GENERIC_READ,
FILE_SHARE_READ, nullptr, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS,
nullptr);
if (h_f == INVALID_HANDLE_VALUE) {
sprintf(sz_name, res_err, filename);
post_error(sz_name);
return nullptr;
}
file_info.uncompressed_size = GetFileSize(h_f, nullptr);
ptr = malloc(file_info.uncompressed_size);
if (!ptr) {
CloseHandle(h_f);
sprintf(sz_name, res_err, filename);
post_error(sz_name);
return nullptr;
}
if (ReadFile(h_f, ptr, file_info.uncompressed_size, &file_info.uncompressed_size,
nullptr) == 0) {
CloseHandle(h_f);
free(ptr);
sprintf(sz_name, res_err, filename);
post_error(sz_name);
return nullptr;
}
CloseHandle(h_f);
if (size) {
*size = file_info.uncompressed_size;
}
return ptr;
}
bytes_t HGE_CALL HGE_Impl::Resource_Load(const char *filename, uint32_t *size)
{
static char *res_err = "Can't load resource: %s";
//resource_packs_item_t *resItem = m_resources;
char szName[_MAX_PATH];
char szZipName[_MAX_PATH];
unzFile zip;
unz_file_info file_info;
int done, i;
void * ptr;
HANDLE hF;
if (filename[0] == '\\' || filename[0] == '/' || filename[1] == ':')
goto _fromfile; // skip absolute paths
// Load from pack
strcpy(szName, filename);
strupr(szName);
for (i = 0; szName[i]; i++)
{
if (szName[i] == '/')
szName[i] = '\\';
}
//while (resItem)
// TODO: optimize this reopening shit out
for( auto itr = m_resources.begin(); itr != m_resources.end(); ++itr )
{
resource_packs_item_t & resItem = itr->second;
zip = unzOpen(resItem.filename.c_str());
done = unzGoToFirstFile(zip);
while (done == UNZ_OK)
{
unzGetCurrentFileInfo(zip, &file_info, szZipName, sizeof(szZipName), NULL, 0, NULL, 0);
strupr(szZipName);
for (i = 0; szZipName[i]; i++)
{
if (szZipName[i] == '/')
szZipName[i] = '\\';
}
if (!strcmp(szName, szZipName))
{
if (unzOpenCurrentFilePassword( zip, resItem.password.empty()
? resItem.password.c_str()
: nullptr ) != UNZ_OK)
{
unzClose(zip);
sprintf(szName, res_err, filename);
_PostError(szName);
return nullptr;
}
ptr = malloc(file_info.uncompressed_size);
if (!ptr)
{
unzCloseCurrentFile(zip);
unzClose(zip);
sprintf(szName, res_err, filename);
_PostError(szName);
return nullptr;
}
if (unzReadCurrentFile(zip, ptr, file_info.uncompressed_size) < 0)
{
unzCloseCurrentFile(zip);
unzClose(zip);
free(ptr);
sprintf(szName, res_err, filename);
_PostError(szName);
return nullptr;
}
unzCloseCurrentFile(zip);
unzClose(zip);
if (size)
*size = file_info.uncompressed_size;
return bytes_t( (char*)ptr );
}
done = unzGoToNextFile(zip);
}
unzClose(zip);
//resItem = resItem->next;
}
// Load from file
_fromfile:
hF = CreateFile(Resource_MakePath(filename), GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, NULL);
if (hF == INVALID_HANDLE_VALUE)
{
sprintf(szName, res_err, filename);
_PostError(szName);
return nullptr;
}
file_info.uncompressed_size = GetFileSize(hF, NULL);
ptr = malloc(file_info.uncompressed_size);
if (!ptr)
{
CloseHandle(hF);
sprintf(szName, res_err, filename);
_PostError(szName);
return nullptr;
}
if (ReadFile(hF, ptr, file_info.uncompressed_size, &file_info.uncompressed_size, NULL ) == 0)
{
CloseHandle(hF);
free(ptr);
sprintf(szName, res_err, filename);
_PostError(szName);
return nullptr;
}
CloseHandle(hF);
if (size)
*size = file_info.uncompressed_size;
return bytes_t( (char*)ptr);
}
void* CALL HGE_Impl::Resource_Load(const char *filename, DWORD *size)
{
static char *res_err="Can't load resource: %s";
CResourceList *resItem=res;
char szName[_MAX_PATH];
char szZipName[_MAX_PATH];
unzFile zip;
unz_file_info file_info;
int done, i;
void *ptr;
HANDLE hF;
if(filename[0]=='\\' || filename[0]=='/' || filename[1]==':') goto _fromfile; // skip absolute paths
// Load from pack
strcpy(szName,filename);
strupr(szName);
for(i=0; szName[i]; i++) { if(szName[i]=='/') szName[i]='\\'; }
while(resItem)
{
zip=unzOpen(resItem->filename);
done=unzGoToFirstFile(zip);
while(done==UNZ_OK)
{
unzGetCurrentFileInfo(zip, &file_info, szZipName, sizeof(szZipName), NULL, 0, NULL, 0);
strupr(szZipName);
for(i=0; szZipName[i]; i++) { if(szZipName[i]=='/') szZipName[i]='\\'; }
if(!strcmp(szName,szZipName))
{
if(unzOpenCurrentFilePassword(zip, resItem->password[0] ? resItem->password : 0) != UNZ_OK)
{
unzClose(zip);
sprintf(szName, res_err, filename);
_PostError(szName);
return 0;
}
ptr = malloc(file_info.uncompressed_size);
if(!ptr)
{
unzCloseCurrentFile(zip);
unzClose(zip);
sprintf(szName, res_err, filename);
_PostError(szName);
return 0;
}
if(unzReadCurrentFile(zip, ptr, file_info.uncompressed_size) < 0)
{
unzCloseCurrentFile(zip);
unzClose(zip);
free(ptr);
sprintf(szName, res_err, filename);
_PostError(szName);
return 0;
}
unzCloseCurrentFile(zip);
unzClose(zip);
if(size) *size=file_info.uncompressed_size;
return ptr;
}
done=unzGoToNextFile(zip);
}
unzClose(zip);
resItem=resItem->next;
}
// Load from file
_fromfile:
hF = CreateFile(Resource_MakePath(filename), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, NULL);
if(hF == INVALID_HANDLE_VALUE)
{
sprintf(szName, res_err, filename);
_PostError(szName);
return 0;
}
file_info.uncompressed_size = GetFileSize(hF, NULL);
ptr = malloc(file_info.uncompressed_size);
if(!ptr)
{
CloseHandle(hF);
sprintf(szName, res_err, filename);
_PostError(szName);
return 0;
}
if(ReadFile(hF, ptr, file_info.uncompressed_size, &file_info.uncompressed_size, NULL ) == 0)
{
CloseHandle(hF);
free(ptr);
sprintf(szName, res_err, filename);
_PostError(szName);
return 0;
}
CloseHandle(hF);
if(size) *size=file_info.uncompressed_size;
return ptr;
}
