488 lines
11 KiB
C++
488 lines
11 KiB
C++
#include "scene.h"
|
|
#include "CCZip.h"
|
|
|
|
CCZip MyZip;
|
|
|
|
|
|
u32 WORLD::AddFileToPack(char *Filname)
|
|
{
|
|
extern char CurrentDir[];
|
|
char LocalDir[2048];
|
|
char FilnameOK[2048];
|
|
char *pS,*pD;
|
|
FILE *F;
|
|
u32 OSIZE;
|
|
u32 Dummy;
|
|
if (PackFileDicoNeredondance.IsExist(Filname) != -1)
|
|
return 0;
|
|
F = CC_fopen(Filname,"rb");
|
|
if (!F) return 0;
|
|
char buff[2048];
|
|
u32 Readed = 1;
|
|
u32 TOTALReaded = 0;
|
|
while (Readed)
|
|
{
|
|
Readed = fread( buff , 1, 2048, F);
|
|
TOTALReaded += Readed;
|
|
}
|
|
CC_fclose(F);
|
|
if (!TOTALReaded) return 0;
|
|
F = CC_fopen(Filname,"rb");
|
|
if (!F) return 0;
|
|
strcpy(FilnameOK,Filname);
|
|
|
|
/* Compute relativ to current place name */
|
|
char Complete;
|
|
strcpy(LocalDir, CurrentDir);
|
|
pD = LocalDir;
|
|
pS = Filname;
|
|
Complete = 0;
|
|
|
|
while ((Upper(*pS) == Upper(*pD)) && *pS && *pD)
|
|
{
|
|
if (*(pS) == ':') Complete = 1;
|
|
*(pD++) = *(pS++);
|
|
}
|
|
if (*pD == 0) // Path was complete -> Change to local path
|
|
{
|
|
FilnameOK[0] = '.';
|
|
strcpy(FilnameOK + 1,pS);
|
|
} else
|
|
if (Complete)
|
|
{
|
|
/* Create a name in this case (a file is outside CAMCAM directory)*/
|
|
pD = pS = Filname;
|
|
while (*pS)
|
|
{
|
|
if ((*pS == '\\') || (*pS == '/') || (*pS == ':'))
|
|
{
|
|
pD = pS+1;
|
|
}
|
|
}
|
|
sprintf(FilnameOK,".\\Outside\\%s",pD);
|
|
}
|
|
|
|
int cryptNeeded = PackFileCrypt && (GetFileNameExtend(Filname) == '.LUA' || GetFileNameExtend(Filname) == '.CCM');
|
|
if (cryptNeeded)
|
|
strcat(FilnameOK, "x");
|
|
|
|
CC_fclose(F);
|
|
|
|
Dummy = 'NAME';
|
|
MyZip.ZIPWrite(&Dummy,1,sizeof(Dummy));
|
|
Dummy = strlen(FilnameOK) + 1;
|
|
MyZip.ZIPWrite(&Dummy,1,sizeof(Dummy));
|
|
MyZip.ZIPWrite((u8*)FilnameOK,1,Dummy);
|
|
|
|
|
|
Dummy = 'FILE';
|
|
MyZip.ZIPWrite(&Dummy,1,sizeof(Dummy));
|
|
MyZip.ZIPWrite(&TOTALReaded,1,sizeof(Dummy));
|
|
F = CC_fopen(Filname,"rb");
|
|
|
|
Readed = 1;
|
|
while (Readed)
|
|
{
|
|
Readed = fread( buff , 1, 2048, F);
|
|
if (cryptNeeded)
|
|
CryptBuffer(buff, Readed);
|
|
if (Readed) MyZip.ZIPWrite(buff , 1, Readed);
|
|
}
|
|
CC_fclose(F);
|
|
|
|
UnicID ID;
|
|
PackFileDicoNeredondance.GetUnic(&ID,Filname);
|
|
|
|
return TOTALReaded;
|
|
}
|
|
|
|
void CLBKENUM_SCN(char *Filname,void *USRP)
|
|
{
|
|
char DIR[2048];
|
|
WIN32_FIND_DATA FD;
|
|
memset(&FD,0,sizeof(FD));
|
|
sprintf(DIR,".\\MEDIA\\%s\\*.*",Filname);
|
|
HANDLE HHH = FindFirstFile(DIR,&FD);
|
|
if (HHH != INVALID_HANDLE_VALUE)
|
|
{
|
|
do
|
|
{
|
|
if (!( FD.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
|
|
{
|
|
sprintf(DIR,".\\MEDIA\\%s\\%s",Filname,FD.cFileName);
|
|
((WORLD *)(((void **)USRP)[0]))->AddFileToPack(DIR);
|
|
}
|
|
} while (FindNextFile(HHH,&FD));
|
|
FindClose(HHH);
|
|
}
|
|
|
|
memset(&FD,0,sizeof(FD));
|
|
sprintf(DIR,".\\MEDIA\\%s\\Modified\\*.*",Filname);
|
|
HHH = FindFirstFile(DIR,&FD);
|
|
if (HHH != INVALID_HANDLE_VALUE)
|
|
{
|
|
do
|
|
{
|
|
if (!( FD.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
|
|
{
|
|
sprintf(DIR,".\\MEDIA\\%s\\Modified\\%s",Filname,FD.cFileName);
|
|
((WORLD *)(((void **)USRP)[0]))->AddFileToPack(DIR);
|
|
}
|
|
} while (FindNextFile(HHH,&FD));
|
|
FindClose(HHH);
|
|
}
|
|
|
|
}
|
|
void CLBKENUM_MEDIA(char *Filname,void *USRP)
|
|
{
|
|
u32 Alpha;
|
|
Alpha = 0;
|
|
if (GetFileNameExtend((char *)Filname) == 'AVIA' || GetFileNameExtend((char *)Filname) == 'WMVA')
|
|
{
|
|
Filname[strlen((char*)Filname)-1] = 0;
|
|
Alpha = 1;
|
|
}
|
|
if(((WORLD *)(((void **)USRP)[0]))->AddFileToPack(Filname))
|
|
{
|
|
{
|
|
char TRACKNAME[2048];
|
|
strcpy((char*)TRACKNAME,(char*)Filname);
|
|
SetFileNameExtend((char*)TRACKNAME,'.TRK');
|
|
((WORLD *)(((void **)USRP)[0]))->AddFileToPack(TRACKNAME);
|
|
}
|
|
if (GetFileNameExtend((char *)Filname) == '.JPG')
|
|
{
|
|
char String[2048];
|
|
// Try Alpha texture
|
|
sprintf(String,"%s",Filname);
|
|
sprintf(String + strlen(String)-4,"_ALPHA.JPG");
|
|
((WORLD *)(((void **)USRP)[0]))->AddFileToPack(String);
|
|
}
|
|
if ((GetFileNameExtend((char *)Filname) == 'JPEG') )
|
|
{
|
|
char String[2048];
|
|
// Try Alpha texture
|
|
sprintf(String,"%s",Filname);
|
|
if (strlen(String)>5)
|
|
{
|
|
sprintf(String + strlen(String)-5,"_ALPHA.JPG");
|
|
((WORLD *)(((void **)USRP)[0]))->AddFileToPack(String);
|
|
}
|
|
}
|
|
}
|
|
if (Alpha)
|
|
{
|
|
Filname[strlen((char*)Filname)-1] = 'A';
|
|
}
|
|
|
|
}
|
|
void CLBKENUM_ANIM(char *Filname,void *USRP)
|
|
{
|
|
char DIR[2048];
|
|
sprintf(DIR,".\\Anims\\%s.TRK",Filname);
|
|
((WORLD *)(((void **)USRP)[0]))->AddFileToPack(DIR);
|
|
}
|
|
void CLBKENUM_FILE(char *Filname,void *USRP)
|
|
{
|
|
((WORLD *)(((void **)USRP)[0]))->AddFileToPack(Filname);
|
|
}
|
|
void CLBKENUM_PART(char *Filname,void *USRP)
|
|
{
|
|
char DIR[2048];
|
|
sprintf(DIR,".\\Particles\\%s.PGR",Filname);
|
|
((WORLD *)(((void **)USRP)[0]))->AddFileToPack(DIR);
|
|
}
|
|
|
|
|
|
u32 WORLD::UNPACK(char *Filname,u32 LaunchLUA,u32 OverrideMode, bool deleteTarget, volatile const bool *Aborted)
|
|
{
|
|
FILE *FP;
|
|
char scriptName[2048];
|
|
scriptName[0] = 0;
|
|
extern void REC_CreateDirectory(char *Name);
|
|
extern HANDLE PackFileMutex;
|
|
|
|
if (WAIT_OBJECT_0 != WaitForSingleObject(PackFileMutex, INFINITE))
|
|
return 0;
|
|
|
|
if (GetFileNameExtend(Filname) != '.ZCC') AddFileNameExtend(Filname,'.ZCC');
|
|
WFlags &= ~LUA_AUTO_RELOAD;
|
|
|
|
// Read zip file
|
|
FP = CC_fopen(Filname,"rb");
|
|
if (FP)
|
|
{
|
|
CC_fclose(FP);
|
|
u32 Version, Compression;
|
|
MyZip.ZIPOpen(Filname, "rb", &Version, &Compression);
|
|
if (Version != 0xc0de2008)
|
|
{
|
|
MyZip.ZIPClose();
|
|
ReleaseMutex(PackFileMutex);
|
|
return 0;
|
|
}
|
|
MyZip.ZIPSetMode(Compression);
|
|
|
|
u32 Dummy;
|
|
MyZip.ZIPRead(&Dummy,1,4);
|
|
while (Dummy == 'NAME')
|
|
{
|
|
char FileName[2048];
|
|
MyZip.ZIPRead(&Dummy,1,sizeof(Dummy));
|
|
MyZip.ZIPRead((char*)FileName,1,Dummy);
|
|
REC_CreateDirectory(FileName);
|
|
FILE *FDST;
|
|
if (OverrideMode)
|
|
{
|
|
if (deleteTarget)
|
|
{
|
|
DeleteFile(FileName);
|
|
FDST = NULL;
|
|
}
|
|
else
|
|
{
|
|
FDST = CC_fopen(FileName,"wb");
|
|
if (!FDST)
|
|
{
|
|
ReleaseMutex(PackFileMutex);
|
|
return 0; // tell the caller if a file can't be writen/overwritten
|
|
}
|
|
}
|
|
} else
|
|
{
|
|
FDST = CC_fopen(FileName,"rb");
|
|
if (FDST)
|
|
{
|
|
CC_fclose(FDST); // Already exist !!
|
|
FDST = NULL;
|
|
}
|
|
else
|
|
FDST = CC_fopen(FileName,"wb");
|
|
}
|
|
MyZip.ZIPRead(&Dummy,1,sizeof(Dummy));
|
|
if (Dummy == 'FILE')
|
|
{
|
|
Sleep(0);
|
|
u32 FILESIZE;
|
|
MyZip.ZIPRead(&FILESIZE,1,sizeof(FILESIZE));
|
|
if ((scriptName[0] == 0) && (GetFileNameExtend(FileName) == '.LUA'))
|
|
strcpy(scriptName,FileName);
|
|
while (FILESIZE)
|
|
{
|
|
Sleep(0);
|
|
char buff[2048];
|
|
MyZip.ZIPRead( buff , 1, FILESIZE > 2048 ? 2048 : FILESIZE);
|
|
if (FDST)
|
|
fwrite(buff , 1, FILESIZE > 2048 ? 2048 : FILESIZE, FDST);
|
|
if (FILESIZE >= 2048)
|
|
FILESIZE -= 2048;
|
|
else
|
|
FILESIZE = 0;
|
|
|
|
if (Aborted && *Aborted)
|
|
{
|
|
// Exit if another thread wants to bail out (this will leave a subset of the unpacked files on disk)
|
|
if (FDST) CC_fclose(FDST);
|
|
DeleteFile(FileName); // don't leave out any corrupted file
|
|
MyZip.ZIPClose();
|
|
ReleaseMutex(PackFileMutex);
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
if (FDST) CC_fclose(FDST);
|
|
MyZip.ZIPRead(&Dummy,1,sizeof(Dummy));
|
|
}
|
|
MyZip.ZIPClose();
|
|
}
|
|
|
|
if (LaunchLUA && scriptName[0])
|
|
{
|
|
extern char CamcamCCM[];
|
|
|
|
LoadLua(scriptName, 1);
|
|
sprintf(ScriptNameStack[currentScript],"%s", scriptName);
|
|
SetIniValue(CamcamCCM, "lastScriptPath", scriptName);
|
|
SaveIniFile(CamcamCCM);
|
|
}
|
|
|
|
ReleaseMutex(PackFileMutex);
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
char** WORLD::GETZCCFILES(char *Filname, int *nbElmts)
|
|
{
|
|
FILE *FP;
|
|
char **FileList = NULL;
|
|
int FileAlloc = 0;
|
|
*nbElmts = 0;
|
|
extern HANDLE PackFileMutex;
|
|
|
|
// pas cool
|
|
if (WAIT_OBJECT_0 != WaitForSingleObject(PackFileMutex, INFINITE))
|
|
return NULL;
|
|
|
|
if (GetFileNameExtend(Filname) != '.ZCC') AddFileNameExtend(Filname,'.ZCC');
|
|
WFlags &= ~LUA_AUTO_RELOAD;
|
|
|
|
FP = CC_fopen(Filname,"rb");
|
|
if (!FP)
|
|
{
|
|
ReleaseMutex(PackFileMutex);
|
|
return NULL;
|
|
}
|
|
CC_fclose(FP);
|
|
|
|
u32 Version, Compression;
|
|
MyZip.ZIPOpen(Filname,"rb",&Version, &Compression);
|
|
if (Version != 0xc0de2008)
|
|
{
|
|
MyZip.ZIPClose();
|
|
ReleaseMutex(PackFileMutex);
|
|
return NULL;
|
|
}
|
|
MyZip.ZIPSetMode(Compression);
|
|
|
|
u32 Dummy;
|
|
MyZip.ZIPRead(&Dummy,1,4);
|
|
while (Dummy == 'NAME')
|
|
{
|
|
char FileName[2048];
|
|
MyZip.ZIPRead(&Dummy,1,sizeof(Dummy));
|
|
MyZip.ZIPRead((char*)FileName,1,Dummy);
|
|
|
|
|
|
if (!FileList)
|
|
{
|
|
FileAlloc = 8;
|
|
FileList = (char **)CC_malloc(FileAlloc*sizeof(char *));
|
|
}
|
|
|
|
if (*nbElmts >= FileAlloc)
|
|
{
|
|
FileAlloc *= 2;
|
|
FileList = (char **)CC_realloc(FileList, FileAlloc*sizeof(char *));
|
|
}
|
|
|
|
FileList[*nbElmts] = (char*)ZeroAlloc(strlen(FileName)+1);
|
|
strcpy(FileList[*nbElmts], FileName);
|
|
(*nbElmts)++;
|
|
|
|
MyZip.ZIPRead(&Dummy,1,sizeof(Dummy));
|
|
if (Dummy == 'FILE')
|
|
{
|
|
u32 FILESIZE;
|
|
MyZip.ZIPRead(&FILESIZE,1,sizeof(FILESIZE));
|
|
while (FILESIZE)
|
|
{
|
|
char buff[2048];
|
|
MyZip.ZIPRead( buff , 1, FILESIZE > 2048 ? 2048 : FILESIZE);
|
|
if (FILESIZE >= 2048)
|
|
FILESIZE -= 2048;
|
|
else
|
|
FILESIZE = 0;
|
|
}
|
|
}
|
|
MyZip.ZIPRead(&Dummy,1,sizeof(Dummy));
|
|
}
|
|
MyZip.ZIPClose();
|
|
|
|
// pas cool
|
|
ReleaseMutex(PackFileMutex);
|
|
return FileList;
|
|
}
|
|
|
|
|
|
u32 WORLD::PACK_ADDREFFILE(char *Filname)
|
|
{
|
|
UnicID ID;
|
|
PackFileDico.GetUnic(&ID,Filname);
|
|
return 0;
|
|
}
|
|
|
|
u32 PACK_DirectoryRecurseAddFiles(char *Directory,UNIC_Dico *PackFileDico)
|
|
{
|
|
char DIR[2048];
|
|
sprintf(DIR,"%s\\*.*",Directory);
|
|
UnicID ID;
|
|
u32 ret = 0;
|
|
WIN32_FIND_DATA FD;
|
|
memset(&FD,0,sizeof(FD));
|
|
HANDLE HHH = FindFirstFile(DIR,&FD);
|
|
if (HHH != INVALID_HANDLE_VALUE)
|
|
{
|
|
do
|
|
{
|
|
sprintf(DIR,"%s\\%s",Directory,FD.cFileName);
|
|
if (!( FD.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
|
|
{
|
|
PackFileDico->GetUnic(&ID,DIR);
|
|
ret++;
|
|
} else
|
|
if ((strcmp(FD.cFileName,".") != 0) && (strcmp(FD.cFileName,"..") != 0))
|
|
{
|
|
ret += PACK_DirectoryRecurseAddFiles(DIR,PackFileDico);
|
|
}
|
|
} while (FindNextFile(HHH,&FD));
|
|
FindClose(HHH);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
u32 WORLD::PACK_ADDREFSCENE(char *SCENEname)
|
|
{
|
|
char DIR[2048];
|
|
sprintf(DIR,".\\MEDIA\\%s",SCENEname);
|
|
return PACK_DirectoryRecurseAddFiles(DIR,&PackFileDico);
|
|
}
|
|
|
|
|
|
u32 WORLD::PACK(char *Filname,u32 AllCurrent)
|
|
{
|
|
FILE *FP;
|
|
|
|
if (GetFileNameExtend(Filname) != '.ZCC') AddFileNameExtend(Filname,'.ZCC');
|
|
|
|
FP = CC_fopen(Filname,"wb");
|
|
if (FP)
|
|
{
|
|
CC_fclose(FP);
|
|
PackFileDicoNeredondance.Init();
|
|
|
|
u32 Version = 0xc0de2008;
|
|
u32 Compression = 2;
|
|
void *PACK[2];
|
|
PACK[0] = (void*)this;
|
|
MyZip.ZIPOpen(Filname,"wb", &Version, &Compression);
|
|
MyZip.ZIPSetMode(Compression);
|
|
if (AllCurrent)
|
|
AddFileToPack((char *)ScriptNameStack[currentScript]);
|
|
|
|
PackFileDico.EnumWords(CLBKENUM_FILE,(void*)PACK);
|
|
|
|
if (AllCurrent)
|
|
{
|
|
/* 1 Save all Currents Scripts */
|
|
for (int Counter = 0 ; Counter < currentScript + 1; Counter++)
|
|
{
|
|
AddFileToPack((char *)ScriptNameStack[Counter]);
|
|
}
|
|
luaLoaddedFilesDICO.EnumWords(CLBKENUM_FILE,(void*)PACK);
|
|
/* 2 Save all SMSC */
|
|
SmallSceneDico.EnumWords(CLBKENUM_SCN,(void*)PACK);
|
|
/* 3 Save all anims */
|
|
AnimDico.EnumWords(CLBKENUM_ANIM,(void*)PACK);
|
|
/* 4 Save all Particules */
|
|
PGeneratorDico.EnumWords(CLBKENUM_PART,(void*)PACK);
|
|
/* 4 Save All media */
|
|
MediaDico.EnumWords(CLBKENUM_MEDIA,(void*)PACK,1 /* ADD DELETED MEDIA */);
|
|
}
|
|
|
|
MyZip.ZIPClose();
|
|
}
|
|
PackFileDicoNeredondance.Destroy();
|
|
return 0;
|
|
}
|
|
|