/*****************************************************************************
BOOL EnterHashMode(lFILEINFO *fileList, UINT uiMode)
fileList : (IN/OUT) pointer to the job structure whose files are to be processed
uiMode : (IN) type of hash file
Return Value:
returns TRUE if everything went fine. FALSE went something went wrong.
Notes:
- takes fileList->fInfos.front().szFilename as .sha1 file and creates new list entries
based on that
*****************************************************************************/
BOOL EnterHashMode(lFILEINFO *fileList, UINT uiMode)
{
#ifdef UNICODE
CHAR szLineAnsi[MAX_LINE_LENGTH];
#endif
TCHAR szLine[MAX_LINE_LENGTH];
TCHAR szFilenameHash[MAX_PATH_EX];
HANDLE hFile;
UINT uiStringLength;
BOOL bErrorOccured, bEndOfFile;
BOOL fileIsUTF16;
UINT codePage;
UNICODE_TYPE detectedBOM;
FILEINFO fileinfoTmp = {0};
// save hash filename and path
// => g_szBasePath in is the path part of the complete filename of the .xyz file
StringCchCopy(szFilenameHash, MAX_PATH_EX, fileList->fInfos.front().szFilename);
StringCchCopy(fileList->g_szBasePath, MAX_PATH_EX, szFilenameHash);
ReduceToPath(fileList->g_szBasePath);
if(fileList->uiCmdOpts==CMD_REPARENT) {
TCHAR szReparentPath[MAX_PATH_EX];
LPITEMIDLIST iidl=NULL;
BROWSEINFO bInfo = {0};
bInfo.lpszTitle = TEXT("Select folder for reparenting");
bInfo.ulFlags = BIF_RETURNONLYFSDIRS | BIF_USENEWUI;
bInfo.lpfn = BrowseFolderSetSelProc;
bInfo.lParam = (LPARAM)(fileList->g_szBasePath + 4);
if(iidl=SHBrowseForFolder(&bInfo)) {
SHGetPathFromIDList(iidl,szReparentPath);
CoTaskMemFree(iidl);
StringCchPrintf(fileList->g_szBasePath, MAX_PATH_EX, TEXT("\\\\?\\%s\\"),szReparentPath);
if(fileList->g_szBasePath[lstrlen(fileList->g_szBasePath) - 2] == TEXT('\\'))
fileList->g_szBasePath[lstrlen(fileList->g_szBasePath) - 1] = TEXT('\0');
}
}
// set mode
fileList->uiRapidCrcMode = uiMode;
// free everything we did so far
fileList->fInfos.clear();
hFile = CreateFile(szFilenameHash, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN , 0);
if(hFile == INVALID_HANDLE_VALUE) {
MessageBox(NULL, TEXT("Hash file could not be read"), TEXT("Error"), MB_ICONERROR | MB_OK);
return FALSE;
}
// check for the BOM and read accordingly
detectedBOM = CheckForBOM(hFile);
fileIsUTF16 = (detectedBOM == UTF_16LE);
if(!fileIsUTF16) {
if(detectedBOM==UTF_8_BOM)
codePage = CP_UTF8;
else if(g_program_options.bUseDefaultCP)
codePage = g_program_options.uiDefaultCP;
else
codePage = DetermineFileCP(hFile);
}
GetNextLine(hFile, szLine, MAX_LINE_LENGTH, & uiStringLength, &bErrorOccured, &bEndOfFile, fileIsUTF16);
if(bErrorOccured) {
MessageBox(NULL, TEXT("Hash file could not be read"), TEXT("Error"), MB_ICONERROR | MB_OK);
return FALSE;
}
while( !(bEndOfFile && uiStringLength == 0) ) {
#ifdef UNICODE
// if we already read unicode characters we don't need the conversion here
if(!fileIsUTF16) {
AnsiFromUnicode(szLineAnsi,MAX_LINE_LENGTH,szLine);
MultiByteToWideChar(codePage, // ANSI Codepage
0, // we use no flags; ANSI isn't a 'real' MBCC
szLineAnsi, // the ANSI String
-1, // ANSI String is 0 terminated
szLine, // the UNICODE destination string
MAX_LINE_LENGTH ); // size of the UNICODE String in chars
uiStringLength = lstrlen(szLine);
}
#endif
switch(uiMode) {
case MODE_SFV:
InterpretSFVLine(szLine, uiStringLength, fileList);
break;
case MODE_MD5:
case MODE_SHA1:
case MODE_SHA256:
case MODE_SHA512:
InterpretMDSHALine(szLine, uiStringLength, uiMode, fileList);
break;
case MODE_BSD:
InterpretBSDLine(szLine, uiStringLength, fileList);
break;
}
GetNextLine(hFile, szLine, MAX_LINE_LENGTH, & uiStringLength, &bErrorOccured, &bEndOfFile, fileIsUTF16);
if(bErrorOccured) {
MessageBox(NULL, TEXT("Hash file could not be read"), TEXT("Error"), MB_ICONERROR | MB_OK);
fileList->fInfos.clear();
return FALSE;
}
}
CloseHandle(hFile);
return TRUE;
}
bool CGLCG::LoadShader(const TCHAR *shaderFile)
{
CCGShader cgShader;
TCHAR shaderPath[MAX_PATH];
TCHAR tempPath[MAX_PATH];
CGprofile vertexProfile, fragmentProfile;
GLenum error;
if(!fboFunctionsLoaded) {
MessageBox(NULL, TEXT("Your OpenGL graphics driver does not support framebuffer objects.\nYou will not be able to use CG shaders in OpenGL mode."), TEXT("CG Error"),
MB_OK|MB_ICONEXCLAMATION);
return false;
}
vertexProfile = cgGLGetLatestProfile(CG_GL_VERTEX);
fragmentProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT);
cgGLDisableProfile(vertexProfile);
cgGLDisableProfile(fragmentProfile);
ClearPasses();
if (shaderFile == NULL || *shaderFile==TEXT('\0'))
return true;
lstrcpy(shaderPath, shaderFile);
ReduceToPath(shaderPath);
SetCurrentDirectory(shaderPath);
if(!cgShader.LoadShader(_tToChar(shaderFile)))
return false;
cgGLSetOptimalOptions(vertexProfile);
cgGLSetOptimalOptions(fragmentProfile);
/* insert dummy pass that will contain the original texture
*/
shaderPasses.push_back(shaderPass());
for(CCGShader::passVector::iterator it=cgShader.shaderPasses.begin();
it!=cgShader.shaderPasses.end();it++) {
shaderPass pass;
pass.scaleParams = it->scaleParams;
/* if this is the last pass (the only one that can have CG_SCALE_NONE)
and no filter has been set use the GUI setting
*/
if(pass.scaleParams.scaleTypeX==CG_SCALE_NONE && !it->filterSet) {
pass.linearFilter = GUI.BilinearFilter;
} else {
pass.linearFilter = it->linearFilter;
}
pass.frameCounterMod = it->frameCounterMod;
pass.floatFbo = it->floatFbo;
// paths in the meta file can be relative
_tfullpath(tempPath,_tFromChar(it->cgShaderFile),MAX_PATH);
char *fileContents = ReadShaderFileContents(tempPath);
if(!fileContents)
return false;
// individual shader might include files, these should be relative to shader
ReduceToPath(tempPath);
SetCurrentDirectory(tempPath);
pass.cgVertexProgram = cgCreateProgram( cgContext, CG_SOURCE, fileContents,
vertexProfile, "main_vertex", NULL);
checkForCgError("Compiling vertex program");
pass.cgFragmentProgram = cgCreateProgram( cgContext, CG_SOURCE, fileContents,
fragmentProfile, "main_fragment", NULL);
checkForCgError("Compiling fragment program");
// set path back for next pass
SetCurrentDirectory(shaderPath);
delete [] fileContents;
if(!pass.cgVertexProgram || !pass.cgFragmentProgram) {
return false;
}
cgGLLoadProgram(pass.cgVertexProgram);
cgGLLoadProgram(pass.cgFragmentProgram);
/* generate framebuffer and texture for this pass and apply
default texture settings
*/
glGenFramebuffers(1,&pass.fbo);
glGenTextures(1,&pass.tex);
glBindTexture(GL_TEXTURE_2D,pass.tex);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
shaderPasses.push_back(pass);
}
for(std::vector<CCGShader::lookupTexture>::iterator it=cgShader.lookupTextures.begin();it!=cgShader.lookupTextures.end();it++) {
lookupTexture tex;
strcpy(tex.id,it->id);
/* generate texture for the lut and apply specified filter setting
*/
glGenTextures(1,&tex.tex);
glBindTexture(GL_TEXTURE_2D,tex.tex);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, it->linearfilter?GL_LINEAR:GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, it->linearfilter?GL_LINEAR:GL_NEAREST);
_tfullpath(tempPath,_tFromChar(it->texturePath),MAX_PATH);
// simple file extension png/tga decision
int strLen = strlen(it->texturePath);
if(strLen>4) {
if(!strcasecmp(&it->texturePath[strLen-4],".png")) {
int width, height;
bool hasAlpha;
GLubyte *texData;
if(loadPngImage(tempPath,width,height,hasAlpha,&texData)) {
glPixelStorei(GL_UNPACK_ROW_LENGTH, width);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width,
height, 0, hasAlpha ? GL_RGBA : GL_RGB, GL_UNSIGNED_BYTE, texData);
free(texData);
}
} else if(!strcasecmp(&it->texturePath[strLen-4],".tga")) {
STGA stga;
if(loadTGA(tempPath,stga)) {
glPixelStorei(GL_UNPACK_ROW_LENGTH, stga.width);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, stga.width,
stga.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, stga.data);
}
}
}
lookupTextures.push_back(tex);
}
/* enable texture unit 1 for the lookup textures
*/
glClientActiveTexture(GL_TEXTURE1);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2,GL_FLOAT,0,lut_coords);
glClientActiveTexture(GL_TEXTURE0);
/* generate textures and set default values for the pref-filled PREV deque.
*/
for(int i=0;i<prevPasses.size();i++) {
glGenTextures(1,&prevPasses[i].tex);
glBindTexture(GL_TEXTURE_2D,prevPasses[i].tex);
glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,512,512,0,GL_RGB,GL_UNSIGNED_SHORT_5_6_5,NULL);
glBindTexture(GL_TEXTURE_2D,0);
prevPasses[i].textureSize.x = prevPasses[i].textureSize.y = prevPasses[i].textureSize.x = prevPasses[i].textureSize.y = 0;
memset(prevPasses[i].texCoords,0,sizeof(prevPasses[i].texCoords));
}
shaderLoaded = true;
return true;
}
/*****************************************************************************
static DWORD CreateChecksumFiles_OnePerDir(CONST UINT uiMode,CONST TCHAR szChkSumFilename[MAX_PATH_EX], list<FILEINFO*> *finalList)
uiMode : (IN) create MD5 or SFV files
szChkSumFilename: (IN) filename without path
finalList : (IN) pointer to list of fileinfo pointers on which the action is to be performed
Return Value:
returns NOERROR or GetLastError()
Notes:
- handles the situation if the user want one sfv/md5 file per directory. In every directory
a file with the name szChkSumFilename is created
*****************************************************************************/
static DWORD CreateChecksumFiles_OnePerDir(CONST UINT uiMode,CONST TCHAR szChkSumFilename[MAX_PATH_EX], list<FILEINFO*> *finalList)
{
DWORD dwResult;
TCHAR szCurrentDir[MAX_PATH_EX];
TCHAR szCurChecksumFilename[MAX_PATH_EX];
TCHAR szPreviousDir[MAX_PATH_EX] = TEXT("?:><"); // some symbols that are not allowed in filenames to force
// the checksum file creation in the for loop
HANDLE hFile = NULL;
for(list<FILEINFO*>::iterator it=finalList->begin();it!=finalList->end();it++) {
if( (*it)->dwError == NO_ERROR ){
StringCchCopy(szCurrentDir, MAX_PATH_EX, (*it)->szFilename);
ReduceToPath(szCurrentDir);
if(lstrcmpi(szPreviousDir, szCurrentDir) != 0){
if(hFile) {
CloseHandle(hFile);
hFile = NULL;
}
StringCchCopy(szPreviousDir, MAX_PATH_EX, szCurrentDir);
StringCchPrintf(szCurChecksumFilename, MAX_PATH_EX, TEXT("%s%s"), szCurrentDir, szChkSumFilename);
if(g_program_options.bNoHashFileOverride && FileExists(szCurChecksumFilename)) {
continue;
}
hFile = CreateFile(szCurChecksumFilename, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, NULL);
if(hFile == INVALID_HANDLE_VALUE){
return GetLastError();
}
#ifdef UNICODE
// we need a BOM if we are writing unicode
if(!WriteCurrentBOM(hFile))
return GetLastError();
#endif
if( (uiMode == MODE_SFV) && g_program_options.bWinsfvComp){
dwResult = WriteSfvHeader(hFile);
if(dwResult != NOERROR){
CloseHandle(hFile);
return dwResult;
}
}
if(g_program_options.bIncludeFileComments) {
list<FILEINFO*>::iterator commentIt = it;
do
{
if((*commentIt)->dwError == NO_ERROR) {
WriteFileComment(hFile, (*commentIt), (UINT)(GetFilenameWithoutPathPointer((*commentIt)->szFilenameShort) - (*commentIt)->szFilename));
}
commentIt++;
if(commentIt == finalList->end())
break;
StringCchCopy(szCurrentDir, MAX_PATH_EX, (*commentIt)->szFilename);
ReduceToPath(szCurrentDir);
}
while(lstrcmpi(szPreviousDir, szCurrentDir) == 0);
}
}
if(hFile) {
dwResult = WriteHashLine(hFile, GetFilenameWithoutPathPointer((*it)->szFilenameShort),
(*it)->hashInfo[uiMode].szResult, uiMode == MODE_SFV);
if(dwResult != NOERROR){
CloseHandle(hFile);
return dwResult;
}
}
}
}
CloseHandle(hFile);
return NOERROR;
}
