Mahtan/wagic
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updated JFileSystem implementation to be compatible with Qt resources.

Browse Source
This commit is contained in:
xawotihs
2013-12-28 00:38:02 +01:00
parent b09db0c60f
commit fec4468aea
20 changed files with 340 additions and 211 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
JGE/include/JFileSystem.h
View File

@@ -1,6 +1,10 @@
#ifndef _J_FILE_SYSTEM_H_
#define _J_FILE_SYSTEM_H_
#ifdef QT_CONFIG
#include <QFile>
#endif
#include "zfsystem.h"
#include <string>
using zip_file_system::filesystem;
@@ -18,13 +22,38 @@ using namespace std;
/// archive file.
///
//////////////////////////////////////////////////////////////////////////
class JFile {
friend class JFileSystem;
filesystem::limited_file_info * mCurrentFileInZip;
izfstream mFile;
#ifdef QT_CONFIG
QFile *mpqFile;
#endif
public:
JFile() : mCurrentFileInZip(0),
#ifdef QT_CONFIG
mpqFile(0)
#endif
{
};
~JFile() {
#ifdef QT_CONFIG
if(mpqFile) {
mpqFile->close();
delete mpqFile;
}
#endif
if (mFile)
mFile.close();
};
};
class JZipCache {
public:
JZipCache();
~JZipCache();
map<string, filesystem::limited_file_info> dir;
};
class JFileSystem {
@@ -32,23 +61,21 @@ private:
string mSystemFSPath, mUserFSPath;
filesystem * mSystemFS, * mUserFS;
static JFileSystem* mInstance;
izfstream mFile;
map<string,JZipCache *>mZipCache;
unsigned int mZipCachedElementsCount;
string mZipFileName;
int mFileSize;
char *mPassword;
bool mZipAvailable;
void preloadZip(const string& filename);
izfstream mZipFile;
filesystem::limited_file_info * mCurrentFileInZip;
std::vector<std::string>& scanRealFolder(const std::string& folderName, std::vector<std::string>& results);
bool openForRead(izfstream & File, const string & FilePath);
int GetFileSize(izfstream & file);
public:
//////////////////////////////////////////////////////////////////////////
/// Attach ZIP archive to the file system.
///
@@ -83,7 +110,7 @@ public:
/// Open file for reading.
///
//////////////////////////////////////////////////////////////////////////
bool OpenFile(const string &filename);
JFile* OpenFile(const string &filename);
//Fills the vector results with a list of children of the given folder
std::vector<std::string>& scanfolder(const std::string& folderName, std::vector<std::string>& results);
@@ -97,20 +124,19 @@ public:
/// @return Number of bytes read.
///
//////////////////////////////////////////////////////////////////////////
int ReadFile(void *buffer, int size);
int ReadFile(JFile*, void *buffer, int size);
//////////////////////////////////////////////////////////////////////////
/// Get size of file.
///
//////////////////////////////////////////////////////////////////////////
int GetFileSize();
int GetFileSize(izfstream & file);
int GetFileSize(JFile*);
//////////////////////////////////////////////////////////////////////////
/// Close file.
///
//////////////////////////////////////////////////////////////////////////
void CloseFile();
void CloseFile(JFile*);
//////////////////////////////////////////////////////////////////////////
/// Set root for all the following file operations
@@ -124,8 +150,8 @@ public:
void SetUSerRoot(const string& resourceRoot);
string GetUserRoot() { return mUserFSPath; };
bool openForRead(izfstream & File, const string & FilePath);
bool readIntoString(const string & FilePath, string & target);
bool ReadFileLine(JFile*, string&);
bool openForWrite(ofstream & File, const string & FilePath, ios_base::openmode mode = ios_base::out );
bool Rename(string from, string to);
@@ -163,4 +189,4 @@ protected:
#endif
#endif

1
JGE/include/JLBFont.h
View File

@@ -178,7 +178,6 @@ private:
float mSpacing;
PIXEL_TYPE mColor;
int mBlend;
int mBase;

9
JGE/src/JAnimator.cpp
View File

@@ -44,11 +44,12 @@ bool JAnimator::Load(const char* scriptFile)
JFileSystem *fileSystem = JFileSystem::GetInstance();
if (fileSystem == NULL) return false;
if (!fileSystem->OpenFile(scriptFile)) return false;
JFile* jFile = fileSystem->OpenFile(scriptFile);
if (!jFile) return false;
int size = fileSystem->GetFileSize();
int size = fileSystem->GetFileSize(jFile);
char *xmlBuffer = new char[size];
fileSystem->ReadFile(xmlBuffer, size);
fileSystem->ReadFile(jFile, xmlBuffer, size);
TiXmlDocument doc;
doc.Parse(xmlBuffer);
@@ -173,7 +174,7 @@ bool JAnimator::Load(const char* scriptFile)
}
fileSystem->CloseFile();
fileSystem->CloseFile(jFile);
delete[] xmlBuffer;
return true;

235
JGE/src/JFileSystem.cpp
View File

@@ -107,7 +107,6 @@ JFileSystem* JFileSystem::GetInstance()
// Tries to set the system and user paths.
// On some OSes, the parameters get overriden by hardcoded values
JFileSystem::JFileSystem(const string & _userPath, const string & _systemPath)
{
string systemPath = _systemPath;
string userPath = _userPath;
@@ -131,8 +130,8 @@ JFileSystem::JFileSystem(const string & _userPath, const string & _systemPath)
dir.mkdir(USERDIR);
dir.cd(USERDIR);
userPath = QDir::toNativeSeparators(dir.absolutePath()).toStdString();
systemPath = QDir::toNativeSeparators(sysDir.absolutePath()).toStdString();
userPath = QDir::toNativeSeparators(dir.absolutePath()).toStdString();
DebugTrace("User path " << userPath);
DebugTrace("System path " << systemPath);
@@ -192,9 +191,6 @@ JFileSystem::JFileSystem(const string & _userPath, const string & _systemPath)
mZipAvailable = false;
mZipCachedElementsCount = 0;
mPassword = NULL;
mFileSize = 0;
mCurrentFileInZip = NULL;
};
void JFileSystem::Destroy()
@@ -208,14 +204,26 @@ void JFileSystem::Destroy()
bool JFileSystem::DirExists(const string& strDirname)
{
return (mSystemFS && mSystemFS->DirExists(strDirname)) || mUserFS->DirExists(strDirname);
return (
(mSystemFS && mSystemFS->DirExists(strDirname))
|| mUserFS->DirExists(strDirname)
#ifdef QT_CONFIG
|| QDir(QString(":/") + strDirname.c_str()).exists()
#endif
);
}
bool JFileSystem::FileExists(const string& strFilename)
{
if (strFilename.length() < 1 ) return false;
return (mSystemFS && mSystemFS->FileExists(strFilename)) || mUserFS->FileExists(strFilename);
return (
(mSystemFS && mSystemFS->FileExists(strFilename))
|| mUserFS->FileExists(strFilename)
#ifdef QT_CONFIG
|| QFile(QString(":/") + strFilename.c_str()).exists()
#endif
);
}
bool JFileSystem::MakeDir(const string & dir)
@@ -275,7 +283,6 @@ bool JFileSystem::AttachZipFile(const string &zipfile, char *password /* = NULL
}
mZipAvailable = true;
return true;
}
@@ -285,7 +292,6 @@ void JFileSystem::DetachZipFile()
{
mZipFile.close();
}
mCurrentFileInZip = NULL;
mZipAvailable = false;
}
@@ -307,28 +313,58 @@ bool JFileSystem::openForRead(izfstream & File, const string & FilePath) {
bool JFileSystem::readIntoString(const string & FilePath, string & target)
{
izfstream file;
if (!openForRead(file, FilePath))
return false;
int fileSize = GetFileSize(file);
bool result = false;
// Trying first with a izfstream
do {
izfstream file;
if (!openForRead(file, FilePath))
break;
int fileSize = GetFileSize(file);
#ifndef __MINGW32__
try {
try {
#endif
target.resize((std::string::size_type) fileSize);
target.resize((std::string::size_type) fileSize);
#ifndef __MINGW32__
} catch (bad_alloc&) {
return false;
}
} catch (bad_alloc&) {
break;
}
#endif
if (fileSize)
file.read(&target[0], fileSize);
file.close();
return true;
if (fileSize)
file.read(&target[0], fileSize);
file.close();
result = true;
} while (0);
#ifdef QT_CONFIG
// Now we try with qrc if we haven't finc anything yet
if (!result) do {
string path = string(":/") + FilePath.c_str();
QFile qfile(path.c_str());
qfile.open(QIODevice::ReadOnly);
if(!qfile.isReadable())
break;
int fileSize = qfile.size();
#ifndef __MINGW32__
try {
#endif
target.resize((std::string::size_type) fileSize);
#ifndef __MINGW32__
} catch (bad_alloc&) {
break;
}
#endif
if (fileSize)
qfile.read(&target[0], fileSize);
qfile.close();
result = true;
} while (0);
#endif //QT_CONFIG
return result;
}
bool JFileSystem::openForWrite(ofstream & File, const string & FilePath, ios_base::openmode mode)
@@ -374,57 +410,72 @@ bool JFileSystem::openForWrite(ofstream & File, const string & FilePath, ios_bas
return false;
}
bool JFileSystem::OpenFile(const string &filename)
JFile* JFileSystem::OpenFile(const string &filename)
{
mCurrentFileInZip = NULL;
bool result;
JFile* jFile = new JFile();
jFile->mCurrentFileInZip = NULL;
if (!mZipAvailable || !mZipFile)
return openForRead(mFile, filename);
do {
if (!mZipAvailable || !mZipFile) {
result = openForRead(jFile->mFile, filename);
if(!result) {
#ifdef QT_CONFIG
string path = string(":/") + filename.c_str();
jFile->mpqFile = new QFile(path.c_str());
jFile->mpqFile->open(QIODevice::ReadOnly);
result = jFile->mpqFile->isReadable();
#endif
}
break;
}
preloadZip(mZipFileName);
map<string,JZipCache *>::iterator it = mZipCache.find(mZipFileName);
if (it == mZipCache.end())
{
//DetachZipFile();
//return OpenFile(filename);
return openForRead(mFile, filename);
}
JZipCache * zc = it->second;
map<string, filesystem::limited_file_info>::iterator it2 = zc->dir.find(filename);
if (it2 == zc->dir.end())
{
/*DetachZipFile();
preloadZip(mZipFileName);
map<string,JZipCache *>::iterator it = mZipCache.find(mZipFileName);
if (it == mZipCache.end())
{
//DetachZipFile();
//return OpenFile(filename);
result = openForRead(jFile->mFile, filename);
break;
}
JZipCache * zc = it->second;
map<string, filesystem::limited_file_info>::iterator it2 = zc->dir.find(filename);
if (it2 == zc->dir.end())
{
/*DetachZipFile();
return OpenFile(filename); */
return openForRead(mFile, filename);
result = openForRead(jFile->mFile, filename);
break;
}
jFile->mCurrentFileInZip = &(it2->second);
result = true;
} while(0);
if(result)
return jFile;
else {
delete jFile;
return 0;
}
mCurrentFileInZip = &(it2->second);
mFileSize = it2->second.m_Size;
return true;
}
void JFileSystem::CloseFile()
void JFileSystem::CloseFile(JFile* jFile)
{
if (mZipAvailable && mZipFile)
{
mCurrentFileInZip = NULL;
}
if (mFile)
mFile.close();
delete jFile;
}
//returns 0 if less than "size" bits were read
int JFileSystem::ReadFile(void *buffer, int size)
int JFileSystem::ReadFile(JFile* jFile, void *buffer, int size)
{
if (mCurrentFileInZip)
if (jFile->mCurrentFileInZip)
{
assert(mZipFile);
if((size_t)size > mCurrentFileInZip->m_Size) //only support "store" method for zip inside zips
if((size_t)size > jFile->mCurrentFileInZip->m_Size) //only support "store" method for zip inside zips
return 0;
std::streamoff offset = filesystem::SkipLFHdr(mZipFile, mCurrentFileInZip->m_Offset);
std::streamoff offset = filesystem::SkipLFHdr(mZipFile, jFile->mCurrentFileInZip->m_Offset);
if (!mZipFile.seekg(offset))
return 0;
mZipFile.read((char *) buffer, size);
@@ -432,16 +483,43 @@ int JFileSystem::ReadFile(void *buffer, int size)
return size;
}
if (!mFile)
#ifdef QT_CONFIG
if(jFile->mpqFile) {
return jFile->mpqFile->read((char*)buffer, size);
}
#endif
if (!jFile->mFile)
return 0;
assert(!mFile.Zipped() || (size_t)size <= mFile.getUncompSize());
mFile.read((char *)buffer, size);
if (mFile.eof())
assert(!jFile->mFile.Zipped() || (size_t)size <= jFile->mFile.getUncompSize());
jFile->mFile.read((char *)buffer, size);
if (jFile->mFile.eof())
return 0;
return size;
}
bool JFileSystem::ReadFileLine(JFile* jFile, string& s)
{
if(!jFile) return false;
#ifdef QT_CONFIG
if(jFile->mpqFile) {
QString qs = jFile->mpqFile->readLine();
if(qs.isEmpty())
return false;
else {
s = qs.toStdString();
return true;
}
}
#endif
if(!jFile->mFile)
return 0;
assert(!jFile->mFile.Zipped());
return std::getline(jFile->mFile, s);
}
std::vector<std::string>& JFileSystem::scanRealFolder(const std::string& folderName, std::vector<std::string>& results)
{
DIR *dip = opendir(folderName.c_str());
@@ -529,8 +607,17 @@ std::vector<std::string>& JFileSystem::scanfolder(const std::string& _folderName
seen[systemReal[i]] = true;
}
}
#ifdef QT_CONFIG
string path = string(":/") + folderName;
QDir dir(path.c_str());
QStringList list = dir.entryList();
for(int i = 0; i < list.size(); i++)
{
seen[list.at(i).toStdString()] = true;
}
#endif
for(map<string,bool>::iterator it = seen.begin(); it != seen.end(); ++it)
for(map<string,bool>::iterator it = seen.begin(); it != seen.end(); ++it)
{
results.push_back(it->first);
}
@@ -544,12 +631,18 @@ std::vector<std::string> JFileSystem::scanfolder(const std::string& folderName)
return scanfolder(folderName, result);
}
int JFileSystem::GetFileSize()
int JFileSystem::GetFileSize(JFile* jFile)
{
if (mCurrentFileInZip)
return mFileSize;
if (jFile->mCurrentFileInZip)
return jFile->mCurrentFileInZip->m_Size;
return GetFileSize(mFile);
#ifdef QT_CONFIG
if(jFile->mpqFile) {
return jFile->mpqFile->size();
}
#endif
return GetFileSize(jFile->mFile);
}
bool JFileSystem::Rename(string _from, string _to)

7
JGE/src/JLBFont.cpp
View File

@@ -42,10 +42,11 @@ JLBFont::JLBFont(const char *fontname, int lineheight, bool useVideoRAM)
//FILE *file;
JFileSystem *fileSys = JFileSystem::GetInstance();
if (!fileSys->OpenFile(filename)) return;
JFile* jFile = fileSys->OpenFile(filename);
if (!jFile) return;
fileSys->ReadFile((u8 *)buffer, 2048);
fileSys->CloseFile();
fileSys->ReadFile(jFile, (u8 *)buffer, 2048);
fileSys->CloseFile(jFile);
sprintf(filename, "%s.png", fontname);
mTexture = mRenderer->LoadTexture(filename, useVideoRAM);

9
JGE/src/JMD2Model.cpp
View File

@@ -96,7 +96,8 @@ bool JMD2Model::Load(char *filename, char *textureName)
// open the model file
JFileSystem* fileSystem = JFileSystem::GetInstance();
if (!fileSystem->OpenFile(filename))
JFile* jFile = fileSystem->OpenFile(filename);
if (!jFile)
return false;
//filePtr = fopen(filename, "rb");
//if (filePtr == NULL)
@@ -107,13 +108,13 @@ bool JMD2Model::Load(char *filename, char *textureName)
//fileLen = ftell(filePtr);
//fseek(filePtr, 0, SEEK_SET);
fileLen = fileSystem->GetFileSize();
fileLen = fileSystem->GetFileSize(jFile);
// read entire file into buffer
buffer = (char*)malloc(fileLen + 1);
//fread(buffer, sizeof(char), fileLen, filePtr);
fileSystem->ReadFile(buffer, fileLen);
fileSystem->CloseFile();
fileSystem->ReadFile(jFile, buffer, fileLen);
fileSystem->CloseFile(jFile);
// extract model file header from buffer
modelHeader = (modelHeader_t*)buffer;

9
JGE/src/JOBJModel.cpp
View File

@@ -47,14 +47,15 @@ bool JOBJModel::Load(const char *modelName, const char *textureName)
{
JFileSystem* fileSys = JFileSystem::GetInstance();
if (!fileSys->OpenFile(modelName))
JFile* jFile = fileSys->OpenFile(modelName);
if (!jFile)
return false;
int size = fileSys->GetFileSize();
int size = fileSys->GetFileSize(jFile);
char *buffer = new char[size];
fileSys->ReadFile(buffer, size);
fileSys->CloseFile();
fileSys->ReadFile(jFile, buffer, size);
fileSys->CloseFile(jFile);
Vector3D vert;

9
JGE/src/JParticleEffect.cpp
View File

@@ -55,11 +55,12 @@ bool JParticleEffect::Load(const char* filename)
JFileSystem *fileSystem = JFileSystem::GetInstance();
if (fileSystem == NULL) return false;
if (!fileSystem->OpenFile(filename)) return false;
JFile* jFile = fileSystem->OpenFile(filename);
if (!jFile) return false;
int size = fileSystem->GetFileSize();
int size = fileSystem->GetFileSize(jFile);
char *xmlBuffer = new char[size];
fileSystem->ReadFile(xmlBuffer, size);
fileSystem->ReadFile(jFile, xmlBuffer, size);
TiXmlDocument doc;
@@ -296,7 +297,7 @@ bool JParticleEffect::Load(const char* filename)
}
}
fileSystem->CloseFile();
fileSystem->CloseFile(jFile);
delete[] xmlBuffer;
return true;

10
JGE/src/JResourceManager.cpp
View File

@@ -93,13 +93,13 @@ bool JResourceManager::LoadResource(const string& resourceName)
JFileSystem *fileSystem = JFileSystem::GetInstance();
if (fileSystem == NULL) return false;
JFile* jFile = fileSystem->OpenFile(path.c_str());
if (!jFile) return false;
if (!fileSystem->OpenFile(path.c_str())) return false;
int size = fileSystem->GetFileSize();
int size = fileSystem->GetFileSize(jFile);
char *xmlBuffer = new char[size];
fileSystem->ReadFile(xmlBuffer, size);
fileSystem->ReadFile(jFile, xmlBuffer, size);
TiXmlDocument doc;
doc.Parse(xmlBuffer);
@@ -179,7 +179,7 @@ bool JResourceManager::LoadResource(const string& resourceName)
}
fileSystem->CloseFile();
fileSystem->CloseFile(jFile);
delete[] xmlBuffer;
// JGERelease();

9
JGE/src/JSpline.cpp
View File

@@ -41,11 +41,12 @@ bool JSpline::Load(const char *filename, float xscale, float yscale)
JFileSystem *fileSystem = JFileSystem::GetInstance();
if (fileSystem == NULL) return false;
if (!fileSystem->OpenFile(filename)) return false;
JFile* jFile = fileSystem->OpenFile(filename);
if (!jFile) return false;
int size = fileSystem->GetFileSize();
int size = fileSystem->GetFileSize(jFile);
char *xmlBuffer = new char[size];
fileSystem->ReadFile(xmlBuffer, size);
fileSystem->ReadFile(jFile, xmlBuffer, size);
TiXmlDocument doc;
doc.Parse(xmlBuffer);
@@ -76,7 +77,7 @@ bool JSpline::Load(const char *filename, float xscale, float yscale)
}
fileSystem->CloseFile();
fileSystem->CloseFile(jFile);
delete[] xmlBuffer;
return true;

9
JGE/src/hge/hgefont.cpp
View File

@@ -57,19 +57,20 @@ hgeFont::hgeFont(const char *szFont, bool bMipmap __attribute__((unused)))
// Load font description
JFileSystem* fileSys = JFileSystem::GetInstance();
if (!fileSys->OpenFile(szFont)) return;
JFile* jFile = fileSys->OpenFile(szFont);
if (!jFile) return;
//data=hge->Resource_Load(szFont, &size);
//if(!data) return;
size = fileSys->GetFileSize();
size = fileSys->GetFileSize(jFile);
desc = new char[size+1];
//memcpy(desc,data,size);
fileSys->ReadFile(desc, size);
fileSys->ReadFile(jFile, desc, size);
desc[size]=0;
//hge->Resource_Free(data);
fileSys->CloseFile();
fileSys->CloseFile(jFile);
pdesc=_get_line(desc,linebuf);
if(strcmp(linebuf, FNTHEADERTAG))

75
JGE/src/hge/hgeparticle.cpp
View File

@@ -50,46 +50,41 @@ float Random_Float(float min, float max)
hgeParticleSystem::hgeParticleSystem(const char *filename, JQuad *sprite)
{
//void *psi;
//hgeParticleSystemInfo psi;
JFileSystem* fileSys = JFileSystem::GetInstance();
//hge=hgeCreate(HGE_VERSION);
//psi=hge->Resource_Load(filename);
if (!fileSys->OpenFile(filename)) return;
//if(!psi) return;
//memcpy(&info, psi, sizeof(hgeParticleSystemInfo));
//hge->Resource_Free(psi);
// Skip reading the pointer as it may be larger than 4 bytes in the structure
void *dummyPointer;
fileSys->ReadFile(&dummyPointer, 4);
// we're actually trying to read more than the file size now, but it's no problem.
// Note that this fix is only to avoid the largest problems, filling a structure
// by directly reading a file, is really a bad idea ...
fileSys->ReadFile(&(info.nEmission), sizeof(hgeParticleSystemInfo) - 4);
fileSys->CloseFile();
info.sprite=sprite;
// info.fGravityMin *= 100;
// info.fGravityMax *= 100;
// info.fSpeedMin *= 100;
// info.fSpeedMax *= 100;
vecLocation.x=vecPrevLocation.x=0.0f;
vecLocation.y=vecPrevLocation.y=0.0f;
fTx=fTy=0;
fEmissionResidue=0.0f;
nParticlesAlive=0;
fAge=-2.0;
mTimer = 0.0f;
rectBoundingBox.Clear();
bUpdateBoundingBox=false;
JFileSystem* fileSys = JFileSystem::GetInstance();
JFile* jFile = fileSys->OpenFile(filename);
if (!jFile) return;
//if(!psi) return;
//memcpy(&info, psi, sizeof(hgeParticleSystemInfo));
//hge->Resource_Free(psi);
// Skip reading the pointer as it may be larger than 4 bytes in the structure
void *dummyPointer;
fileSys->ReadFile(jFile, &dummyPointer, 4);
// we're actually trying to read more than the file size now, but it's no problem.
// Note that this fix is only to avoid the largest problems, filling a structure
// by directly reading a file, is really a bad idea ...
fileSys->ReadFile(jFile, &(info.nEmission), sizeof(hgeParticleSystemInfo) - 4);
fileSys->CloseFile(jFile);
info.sprite=sprite;
// info.fGravityMin *= 100;
// info.fGravityMax *= 100;
// info.fSpeedMin *= 100;
// info.fSpeedMax *= 100;
vecLocation.x=vecPrevLocation.x=0.0f;
vecLocation.y=vecPrevLocation.y=0.0f;
fTx=fTy=0;
fEmissionResidue=0.0f;
nParticlesAlive=0;
fAge=-2.0;
mTimer = 0.0f;
rectBoundingBox.Clear();
bUpdateBoundingBox=false;
}
hgeParticleSystem::hgeParticleSystem(hgeParticleSystemInfo *psi)

27
JGE/src/pc/JGfx.cpp
View File

@@ -2130,7 +2130,8 @@ void JRenderer::LoadGIF(TextureInfo &textureInfo, const char *filename, int mode
///*
//FILE * fp = fopen(filename, "rb");
JFileSystem *fileSys = JFileSystem::GetInstance();
if (!fileSys->OpenFile(filename))
JFile* jFile = fileSystem->OpenFile(filename);
if (!jFile))
return;
//if(fp == NULL)
@@ -2140,7 +2141,7 @@ void JRenderer::LoadGIF(TextureInfo &textureInfo, const char *filename, int mode
if(result!=0)
textureInfo.mBits=NULL;
//fclose(fp);
fileSys->CloseFile();
fileSys->CloseFile(jFile);
return ;//*/
}
#endif //(!defined IOS) && (!defined QT_CONFIG) && (!defined SDL_CONFIG)
@@ -2161,20 +2162,21 @@ JTexture* JRenderer::LoadTexture(const char* filename, int mode, int TextureForm
UIImage *image = NULL;
do {
if (!fileSystem->OpenFile(filename))
JFile* jFile = fileSystem->OpenFile(filename);
if (!jFile)
break;
rawsize = fileSystem->GetFileSize();
rawsize = fileSystem->GetFileSize(jFile);
rawdata = new BYTE[rawsize];
if (!rawdata)
{
fileSystem->CloseFile();
fileSystem->CloseFile(jFile);
break;
}
fileSystem->ReadFile(rawdata, rawsize);
fileSystem->CloseFile();
fileSystem->ReadFile(jFile, rawdata, rawsize);
fileSystem->CloseFile(jFile);
texData = [[NSData alloc] initWithBytes:rawdata length:rawsize];
image = [[UIImage alloc] initWithData:texData];
@@ -2254,20 +2256,21 @@ JTexture* JRenderer::LoadTexture(const char* filename, int, int)
JFileSystem* fileSystem = JFileSystem::GetInstance();
do {
if (!fileSystem->OpenFile(filename))
JFile* jFile = fileSystem->OpenFile(filename);
if (!jFile)
break;
rawsize = fileSystem->GetFileSize();
rawsize = fileSystem->GetFileSize(jFile);
rawdata = new BYTE[rawsize];
if (!rawdata)
{
fileSystem->CloseFile();
fileSystem->CloseFile(jFile);
break;
}
fileSystem->ReadFile(rawdata, rawsize);
fileSystem->CloseFile();
fileSystem->ReadFile(jFile, rawdata, rawsize);
fileSystem->CloseFile(jFile);
QImage tmpImage = QImage::fromData(rawdata, rawsize);
if(tmpImage.isNull())