main.cpp

mpq文件查看器

	}
	else
	if(ISBLP(ofn.lpstrFile))
	{
		nn = ConvertBLP(filebuf, NULL, (ULONG*)&bw, (ULONG*)&bh, NULL, NULL);
		rawbuf = (char*)malloc_func(nn);
		ConvertBLP(filebuf, rawbuf, (ULONG*)&bw, (ULONG*)&bh, NULL, NULL);
		bp = 32;
		free_func(filebuf);
	}
	else
	if(ISTGA(ofn.lpstrFile))
	{
		nn = LoadTGA(filebuf, &bw, &bh, &bp, NULL, NULL);
		rawbuf = (char*)malloc_func(nn);
		LoadTGA(filebuf, &bw, &bh, &bp, rawbuf, NULL);
		HorizFlip(rawbuf, bw*bp/8, bh);
		free_func(filebuf);
	}
	else
	if(ISJPG(ofn.lpstrFile))
	{
		DWORD n = nn;
		nn = IJGRead((unsigned char*)filebuf, n, &bw, &bh, &bp, NULL);
		rawbuf = (char*)malloc_func(nn);
		IJGRead((unsigned char*)filebuf, n, &bw, &bh, &bp, (unsigned char*)rawbuf);
		if(bp == 24)
			RGB2BGR(rawbuf, nn);

		if(bp == 32)
			RGBA2BGRA(rawbuf, nn);

		free_func(filebuf);
	}
	else
	{
		free_func(ofn.lpstrFile);
		bgloaded = FALSE;
		free_func(filebuf);
	}



	if(bw%4 != 0) // Grelaga ... cette p****** de fonction de gluScaleImage (ou gluBuild2DMipmaps)
	{			  // ne fonctionne qu'avec des largeurs multiples de 4
		long byteslacking = 4-(bw%4);
		
		long nbw = bw+byteslacking, bytespp = bp/8,
			nrowsize = nbw*bytespp, rowsize = bw*bytespp;
		DWORD ns = nbw*bh*bytespp*2;		
		tmpbuf = (char*)malloc_func(ns);
		char *savebuf1 = tmpbuf, *savebuf2 = rawbuf;

		for(long k=0; k<bh; ++k)
		{
			memcpy(tmpbuf, rawbuf, rowsize);
			rawbuf += rowsize;
			tmpbuf += rowsize;

			for(long l=0; l<byteslacking; ++l)
			{
				*tmpbuf++ = (char)(BGColor[2]*255.0f);
				*tmpbuf++ = (char)(BGColor[1]*255.0f);
				*tmpbuf++ = (char)(BGColor[0]*255.0f);

				if(bp == 32)
					*tmpbuf++ = 0;
			}
		}

		free_func(savebuf2);
		rawbuf = savebuf1;
		bw = nbw;
/*
		hFile = CreateFile("c:\\bmptest.raw", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
		WriteFile(hFile, rawbuf, ns, &r, NULL);
		CloseHandle(hFile);*/
	}

	glGenTextures(1, &texID);
	glEnable(GL_TEXTURE_2D);
	glBindTexture(GL_TEXTURE_2D, texID);
	
	int bpp=GL_BGRA_EXT;

	if(bp == 24)
		bpp = GL_BGR_EXT;


	int numplanes = 4;

	if(bp == 24)
		numplanes = 3;

	r = gluBuild2DMipmaps(GL_TEXTURE_2D, numplanes, bw, bh, bpp, GL_UNSIGNED_BYTE, rawbuf);
	if(r != 0)
		MessageBox(dlg, (const char*)gluErrorString(r), szAppName, MB_ICONEXCLAMATION);
	
	glTexParameteri( GL_TEXTURE_2D,GL_TEXTURE_WRAP_S, GL_REPEAT );
	glTexParameteri( GL_TEXTURE_2D,GL_TEXTURE_WRAP_T, GL_REPEAT );
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR_MIPMAP_LINEAR);
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);

	bgloaded = TRUE;
}



BOOL AVIInit(char *sfdest, long lwidth, long lheight, long lbpp)
{
	ZeroMemory(&birgb, sizeof(BITMAPINFOHEADER));
	birgb.biSize = sizeof(BITMAPINFOHEADER);
	birgb.biWidth = lwidth;
	birgb.biHeight = lheight;
	birgb.biPlanes = 1;
	birgb.biBitCount = (unsigned short)lbpp;
	birgb.biCompression = BI_RGB;
	birgb.biSizeImage = lwidth * lheight * lbpp/8;


	compvars.cbSize = sizeof(compvars);

	if (ICCompressorChoose(dlg, ICMF_CHOOSE_DATARATE | ICMF_CHOOSE_KEYFRAME, &birgb, NULL, &compvars, NULL)==FALSE)
		return FALSE;

	// set AVI header
	ZeroMemory(&strinfo, sizeof(AVISTREAMINFO));
	strinfo.fccType					= streamtypeVIDEO;
	strinfo.fccHandler				= compvars.fccHandler;
	strinfo.dwQuality				= -1;
	strinfo.dwSuggestedBufferSize	= birgb.biSizeImage;
	strinfo.dwScale	= tinterval;
	strinfo.dwRate = 1000;

	// set AVI save options
	opts.cbFormat = sizeof(birgb);
	opts.fccType = streamtypeVIDEO;
	opts.fccHandler = compvars.fccHandler;
	opts.dwKeyFrameEvery = compvars.lKey;
	opts.dwQuality = compvars.lQ;
	opts.dwBytesPerSecond = compvars.lDataRate<<10;
	opts.dwFlags = AVICOMPRESSF_VALID | AVICOMPRESSF_KEYFRAMES | AVICOMPRESSF_DATARATE;
	opts.dwInterleaveEvery = 0;
	opts.lpFormat = &birgb;
	opts.cbParms = compvars.cbState;
	opts.lpParms = compvars.lpState;


	AVIFileInit();

	if(AVIFileOpen(&gaf, sfdest, OF_CREATE | OF_WRITE, NULL) != 0)
		return FALSE;

	if(AVIFileCreateStream(gaf, &ps, &strinfo) != 0)
	{
		AVIFileRelease(gaf);
		return FALSE;
	}

	if(AVIMakeCompressedStream(&psCompressed, ps, &opts, NULL) != 0)
	{
		AVIFileRelease(gaf);
		return FALSE;
	}

	if(AVIStreamSetFormat(psCompressed, 0, &birgb, birgb.biSize) != 0)
	{
		AVIFileRelease(gaf);
		return FALSE;
	}

	return TRUE;
}



void AVIKill()
{
	if (ps)
		AVIStreamClose(ps);

	if (psCompressed)
		AVIStreamClose(psCompressed);

	if (gaf)
		AVIFileClose(gaf);

	AVIFileExit();
	ICCompressorFree(&compvars);
}



void ConvertLocalTGA()
{
	long k=0, l=0, w, h, bp;
	char ttmp[1024], szFichier[1024];
	HANDLE hFile=0;
	char *tgabuf=NULL, *rawbuf=NULL, *blpbuf=NULL;
	DWORD nn,r;

	while(gLoadedTextures[l][0]!=0) ++l;
	
	for(k=0; k<l; ++k)
	{
		ZeroMemory(&szFichier, 1024);
		lstrcpy(szFichier, gLoadedTextures[k]);
		utilChangeFileExt(szFichier, "TGA", 1024);
		ZeroMemory(&ttmp, 1024);
		if((lstrcmp(gLoadedExternFilePath, "")!=0)&&(bShowingMDX == TRUE))
			utilAddBkSlash(gLoadedExternFilePath, ttmp, 1024);
		lstrcat(ttmp, szFichier);
		hFile=CreateFile(ttmp, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
		if (hFile==INVALID_HANDLE_VALUE)
		{			
			ZeroMemory(&ttmp, 1024);
			lstrcpy(ttmp, mpqpath);
			lstrcat(ttmp, szFichier);

			hFile=CreateFile(ttmp, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
			if (hFile==INVALID_HANDLE_VALUE)
				continue;
		}
		
		nn = GetFileSize(hFile, NULL);
		tgabuf = (char*)malloc_func(nn);
		ReadFile(hFile, tgabuf, nn, &r, NULL);
		CloseHandle(hFile);
		w = h = bp = 0;
		nn = LoadTGA(tgabuf, &w, &h, &bp, NULL, NULL);
		if((bp != 32)||(nn <= 0))
		{
			free_func(tgabuf);
			continue;
		}
		rawbuf = (char*)malloc_func(nn);
		LoadTGA(tgabuf, &w, &h, &bp, rawbuf, NULL);
		HorizFlip(rawbuf, w*bp/8, h);
		free_func(tgabuf);
		nn = BuildBLP(rawbuf, w, h, bp, NULL, glastqual);
		blpbuf = (char*)malloc_func(nn);
		BuildBLP(rawbuf, w, h, bp, blpbuf, glastqual);
		free_func(rawbuf);

		utilChangeFileExt(ttmp, "BLP", 1024);
		DeleteFile(ttmp);
		hFile=CreateFile(ttmp, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
		if(hFile == INVALID_HANDLE_VALUE)
		{
			free_func(blpbuf);
			continue;
		}
		WriteFile(hFile, blpbuf, nn, &r, NULL);
		CloseHandle(hFile);
		free_func(blpbuf);
	}
}


void CreateTB()
{
	TBBUTTON bb[27];
	ZeroMemory(&bb, sizeof(bb));

	int k=0, l=0;

	for(k=0; k<27; ++k)
	{
		switch(k)
		{
			case 0:
				bb[k].iBitmap = l++;
				bb[k].fsState = TBSTATE_ENABLED;
				bb[k].fsStyle = TBSTYLE_BUTTON;
				bb[k].idCommand = ID_FICHIER_OUVRIR;
				break;

			case 1:
				bb[k].iBitmap = l++;
				bb[k].fsState = TBSTATE_ENABLED;
				bb[k].fsStyle = TBSTYLE_BUTTON;
				bb[k].idCommand = ID_OPTIONS_CHEMINDESTEXTURES;
				break;

			case 2:
			case 5:
			case 9:
			case 12:
			case 16:
			case 23:
				bb[k].iBitmap = 0;
				bb[k].fsState = 0;
				bb[k].fsStyle = TBSTYLE_SEP;
				bb[k].idCommand = 0;
				break;

			case 3:
				bb[k].iBitmap = l++;
				bb[k].fsState = TBSTATE_ENABLED;
				bb[k].fsStyle = TBSTYLE_BUTTON;
				bb[k].idCommand = ID_OPTIONS_FICHIERSDEWAR3MPQ;
				break;

			case 4:
				bb[k].iBitmap = l++;
				bb[k].fsState = TBSTATE_ENABLED;
				bb[k].fsStyle = TBSTYLE_BUTTON;
				bb[k].idCommand = ID_OPTIONS_REGISTRE;
				break;

			case 6:
				bb[k].iBitmap = l++;
				bb[k].fsState = TBSTATE_ENABLED;
				bb[k].fsStyle = TBSTYLE_BUTTON;
				bb[k].idCommand = ID_VIEW_TAKESNAPSHOT;
				break;

			case 7:
				bb[k].iBitmap = l++;
				bb[k].fsState = TBSTATE_ENABLED;
				bb[k].fsStyle = TBSTYLE_BUTTON;
				bb[k].idCommand = ID_RENDER_CHANGEBACKGROUNDCOLOR;
				break;

			case 8:
				bb[k].iBitmap = l++;
				bb[k].fsState = TBSTATE_ENABLED;
				bb[k].fsStyle = TBSTYLE_BUTTON;
				bb[k].idCommand = ID_ANIMATION_COULEURDELQUIPE;
				break;
				
			case 10:
				bb[k].iBitmap = l++;
				bb[k].fsState = TBSTATE_ENABLED;
				bb[k].fsStyle = TBSTYLE_BUTTON;
				bb[k].idCommand = ID_VIEW_RESETVIEW;
				break;

			case 11:
				bb[k].iBitmap = l++;
				bb[k].fsState = TBSTATE_ENABLED;
				bb[k].fsStyle = TBSTYLE_BUTTON;
				bb[k].idCommand = ID_VUE_RECHARGERLESTEXTURES;
				break;

			case 13:
				bb[k].iBitmap = l++;
				bb[k].fsState = TBSTATE_ENABLED;
				bb[k].fsStyle = TBSTYLE_BUTTON;
				bb[k].idCommand = ID_RENDER_POINTS;
				break;

			case 14:
				bb[k].iBitmap = l++;
				bb[k].fsState = TBSTATE_ENABLED;
				bb[k].fsStyle = TBSTYLE_BUTTON;
				bb[k].idCommand = ID_RENDER_WIREFRAME;
				break;

			case 15:
				bb[k].iBitmap = l++;
				bb[k].fsState = TBSTATE_ENABLED;
				bb[k].fsStyle = TBSTYLE_BUTTON;
				bb[k].idCommand = ID_RENDER_FILL;
				break;

			case 17:
				bb[k].iBitmap = l++;
				bb[k].fsState = TBSTATE_ENABLED;
				bb[k].fsStyle = TBSTYLE_BUTTON;
				bb[k].idCommand = ID_VIEW_FINDINMPQ;
				break;

			case 18:
				bb[k].iBitmap = l++;
				bb[k].fsState = TBSTATE_ENABLED;
				bb[k].fsStyle = TBSTYLE_BUTTON;
				bb[k].idCommand = ID_CURRENTFILE_EXTRACTMDX;
				break;

			case 19:
				bb[k].iBitmap = l++;
				bb[k].fsState = TBSTATE_ENABLED;
				bb[k].fsStyle = TBSTYLE_BUTTON;
				bb[k].idCommand = ID_CURRENTFILE_EXTRACTBLP;
				break;

			case 20:
				bb[k].iBitmap = l++;
				bb[k].fsState = TBSTATE_ENABLED;
				bb[k].fsStyle = TBSTYLE_BUTTON;
				bb[k].idCommand = ID_CURRENTFILE_EXTRACTUSEDTEXTURES;
				break;

			case 21:
				bb[k].iBitmap = l++;
				bb[k].fsState = TBSTATE_ENABLED;
				bb[k].fsStyle = TBSTYLE_BUTTON;
				bb[k].idCommand = ID_CONVERT_BMPTGAORJPGBLP;
				break;

			case 22:
				bb[k].iBitmap = l++;
				bb[k].fsState = TBSTATE_ENABLED;
				bb[k].fsStyle = TBSTYLE_BUTTON;
				bb[k].idCommand = ID_CONVERT_BLPBMPTGAORJPG;
				break;

			case 24:
				bb[k].iBitmap = l++;
				bb[k].fsState = TBSTATE_ENABLED;
				bb[k].fsStyle = TBSTYLE_BUTTON;
				bb[k].idCommand = ID_HELP_SHOWHELPF1;
				break;

			case 25:
				bb[k].iBitmap = l++;
				bb[k].fsState = TBSTATE_ENABLED;
				bb[k].fsStyle = TBSTYLE_BUTTON;
				bb[k].idCommand = ID_AIDE_PROPOS;
				break;

			case 26:
				bb[k].iBitmap = l++;
				bb[k].fsState = TBSTATE_ENABLED;
				bb[k].fsStyle = TBSTYLE_BUTTON;
				bb[k].idCommand = ID_FICHIER_QUITTER;
				break;
		}

	}

	ghtb=CreateToolbarEx(dlg, WS_CHILD + TBSTYLE_TOOLTIPS, 10002, 0, NULL, 0, NULL, 0, 32, 32, 32, 32, sizeof(TBBUTTON));
	ghil = ImageList_Create(32, 32, ILC_MASK + ILC_COLOR24, 27, 50);
	HBITMAP hbmptb = LoadBitmap(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_BITMAP1));
	ImageList_AddMasked(ghil, hbmptb, 0x00808080);
	SendMessage(ghtb, TB_SETIMAGELIST, 0, (LPARAM)(HIMAGELIST)ghil);
	SendMessage(ghtb, TB_ADDBUTTONS, (WPARAM) (UINT) 27, (LPARAM) (LPTBBUTTON) &bb);
	ShowWindow(ghtb, SW_SHOWNORMAL);
	Resize(dlg);
}





DWORD GetValidFilesCount(char *spath)
{
	WIN32_FIND_DATA w;
	char tmp[1024];
	long k=0;
	BOOL b = TRUE;
	sprintf(tmp, "%s\\*.*", spath);
	HANDLE hf = FindFirstFile(tmp, &w);
	while((hf != INVALID_HANDLE_VALUE)&&(b==TRUE))
	{
		if(ISBLP(w.cFileName)||ISMODEL(w.cFileName)||(w.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)&&(lstrcmp(w.cFileName, ".")!=0)&&(lstrcmp(w.cFileName, "..")!=0))
			++k;
		b = FindNextFile(hf, &w);
	}
	return k;
}



DWORD GetDriveCount()
{
	char tmp[5];
	ZeroMemory(&tmp, 5);
	lstrcpy(tmp, "A:\\");
	int k=0, i=0, j=0;
	for(k='A'; k<'Z'+1; ++k)
	{
		tmp[0]=k;
		j = GetDriveType(tmp);
		if (/*(j != DRIVE_UNKNOWN)&&(j != DRIVE_NO_ROOT_DIR)*/1)
			++i;
	}
	return i;
}


HTREEITEM InsertWhere(HWND htree, HTREEITEM hparent, long isdir, char *stext)
{
	HTREEITEM hprev=TVI_FIRST, hlast = TreeView_GetChild(htree, hparent);
	char tmp[1024];
	if(hlast==NULL) return hprev;

	TVITEM it;
	it.mask = TVIF_HANDLE + TVIF_PARAM + TVIF_TEXT;
	it.hItem = hlast;
	it.pszText = tmp;
	it.cchTextMax = 1024;
	TreeView_GetItem(htree, &it);

	while(hlast != NULL)
	{
		if(it.lParam != isdir)
		{
			hprev = hlast;
			hlast=TreeView_GetNextSibling(htree, hlast);

			it.mask = TVIF_HANDLE + TVIF_PARAM + TVIF_TEXT;
			it.hItem = hlast;
			it.pszText = tmp;
			it.cchTextMax = 1024;
			TreeView_GetItem(htree, &it);			
			continue;
		}

		if (lstrcmpi(stext, it.pszText) >= 0)
		{
			hprev = hlast;
			hlast=TreeView_GetNextSibling(htree, hlast);
			if(hlast==NULL) continue;

			it.mask = TVIF_HANDLE + TVIF_PARAM + TVIF_TEXT;
			it.hItem = hlast;
			it.pszText = tmp;
			it.cchTextMax = 1024;
			TreeView_GetItem(htree, &it);
			if(it.lParam != isdir) return hprev;
			continue;
		}