开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
WHImage.cpp
资源名称：Mir2ExCodev1.rar　[点击查看]
上传用户：cydong117
上传日期：2009-11-10
资源大小：638k
文件大小：11k
源码类别：

模拟服务器

开发平台：

Visual C++

WHImage.cpp：源码内容
  1. /******************************************************************************************************************
  2.                                                                                                                    
  3. 葛碘疙:
  5. 累己磊:
  6. 累己老:
  8. [老磊][荐沥磊] : 荐沥 郴侩
  9.                                                                                                                    
  10. *******************************************************************************************************************/
  14. #include "stdafx.h"
  15. #include "WHEngine.h"
  19. /******************************************************************************************************************
  21. 窃荐疙 : CWHImage::CWHImage()
  23. 累己磊 : 
  24. 累己老 : 
  26. 格利   : 
  27. 免仿   : 
  29. [老磊][荐沥磊] : 荐沥郴侩
  31. *******************************************************************************************************************/
  32. CWHImage::CWHImage()
  33. {
  34. m_wWidth = 0;
  35. m_wHeight = 0;
  36. m_shCenterX = 0;;
  37. m_shCenterY = 0;;
  38. m_bBitCount = 0;;
  39. m_pwImage = NULL;
  40. m_dwImageLength = 0;
  41. }
  45. /******************************************************************************************************************
  47. 窃荐疙 : CWHImage::~CWHImage()
  49. 累己磊 : 
  50. 累己老 : 
  52. 格利   : 
  53. 免仿   : 
  55. [老磊][荐沥磊] : 荐沥郴侩
  57. *******************************************************************************************************************/
  58. CWHImage::~CWHImage()
  59. {
  60. DeleteImage();
  61. }
  65. /******************************************************************************************************************
  67. 窃荐疙 : CWHImage::Convert24To16()
  69. 累己磊 : 
  70. 累己老 : 
  72. 格利   : 
  73. 涝仿   : BYTE *pOrgImage
  74.          BYTE bOrgImgBitCount
  75. 免仿   : BOOL 
  77. [老磊][荐沥磊] : 荐沥郴侩
  79. *******************************************************************************************************************/
  80. BOOL CWHImage::Convert24To16(BYTE *pOrgImage, BYTE bOrgImgBitCount)
  81. {
  82. BYTE byRBit, byGBit, byBBit;
  83. WORD wPixel;
  85. int nByteAlignCX = (((m_wWidth * bOrgImgBitCount) + 31) & ~31) >> 3;
  87. for (int nYIdx = 0; nYIdx < m_wHeight; nYIdx++)
  88. {
  89. for (int nXIdx = 0; nXIdx < m_wWidth; nXIdx++)
  90. {
  91. byRBit = pOrgImage[(nXIdx * 3 + 2) + (nYIdx * nByteAlignCX)];
  92. byGBit = pOrgImage[(nXIdx * 3 + 1) + (nYIdx * nByteAlignCX)];
  93. byBBit = pOrgImage[(nXIdx * 3 + 0) + (nYIdx * nByteAlignCX)];
  95. wPixel = ((byRBit >> 3) << 11) | ((byGBit >> 2) << 5) | (byBBit >> 3);
  97. if (((byRBit != 0) || (byGBit != 0) || (byBBit != 0)) && (wPixel == 0))
  98. wPixel = 1;
  100. // 厚飘甘阑 芭操肺 倒覆
  101. m_pwImage[nXIdx + ((m_wHeight - 1) - nYIdx) * m_wWidth] = wPixel;
  102. }
  103. }
  105. return TRUE;
  106. }
  110. /******************************************************************************************************************
  112. 窃荐疙 : CWHImage::LoadBitmap()
  114. 累己磊 : 
  115. 累己老 : 
  117. 格利   : 
  118. 涝仿   : LPCTSTR pszFileName
  119.          BYTE bBitCount
  120. 免仿   : BOOL 
  122. [老磊][荐沥磊] : 荐沥郴侩
  124. *******************************************************************************************************************/
  125. BOOL CWHImage::LoadBitmap(LPCTSTR pszFileName, BOOL fCut, BOOL fCompress, BYTE bBitCount)
  126. {
  127. BITMAPFILEHEADER stFileHeader;
  128. BITMAPINFOHEADER stInfoHeader;
  129. DWORD dwReadSize = 0;
  131. HANDLE hFile = ::CreateFile(pszFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
  132. FILE_ATTRIBUTE_NORMAL, NULL);
  134. if ( hFile )
  135. {
  136. ZeroMemory(&stFileHeader, sizeof(stFileHeader));
  138. ReadFile(hFile, &stFileHeader, sizeof(stFileHeader), &dwReadSize, NULL);
  140. if ( HIBYTE(stFileHeader.bfType) == 'M' && LOBYTE(stFileHeader.bfType) == 'B' )
  141. {
  142. ReadFile(hFile, &stInfoHeader, sizeof(stInfoHeader), &dwReadSize, NULL);
  144. m_wWidth  = (WORD)stInfoHeader.biWidth;
  145. m_wHeight = (WORD)stInfoHeader.biHeight;
  147. m_dwImageLength = m_wWidth*m_wHeight*sizeof(WORD);
  149. if ( stInfoHeader.biBitCount == 24 )
  150. {
  151. m_pwImage = new WORD[sizeof(WORD) * m_wWidth * m_wHeight];
  153. UINT nSize = stFileHeader.bfSize -  sizeof(stFileHeader) -  sizeof(stInfoHeader);
  155. if ( bBitCount != 16 )
  156. {
  157. ReadFile(hFile, m_pwImage, nSize, &dwReadSize, NULL);
  159. CloseHandle(hFile);
  161. if ( fCut ) Optimize();
  162. if ( fCompress ) XOptimize();
  165. return TRUE;
  166. }
  167. else
  168. {
  169. BYTE *pOrgImage = new BYTE[stInfoHeader.biSizeImage];
  171. ReadFile(hFile, pOrgImage, nSize, &dwReadSize, NULL);
  173. Convert24To16(pOrgImage, (BYTE)stInfoHeader.biBitCount);
  175. CloseHandle(hFile);
  177. delete [] pOrgImage;
  179. if ( fCut ) Optimize();
  180. if ( fCompress ) XOptimize();
  182. return TRUE;
  183. }
  184. }
  185. }
  187. CloseHandle(hFile);
  188. }
  190. return FALSE;
  191. }
  195. BOOL CWHImage::Optimize()
  196. {
  197. INT nStartX, nStartY, nEndX, nEndY;
  198. INT nX, nY;
  199. INT nCntX = 0;
  200. INT nCntY = 0;
  202. for ( nY=0; nY<m_wHeight; nY++ )
  203. {
  204. for ( nX=0; nX<m_wWidth; nX++ )
  205. {
  206. if ( *(m_pwImage + nX + (nY * m_wWidth)) != 0 )
  207. {
  208. nStartY = nY;
  209. nX = m_wWidth;
  210. nY = m_wHeight;
  211. }
  212. }
  213. }
  215. for ( nX=0; nX<m_wWidth; nX++ )
  216. {
  217. for ( nY=0; nY<m_wHeight; nY++ )
  218. {
  219. if ( *(m_pwImage + nX + (nY * m_wWidth)) != 0 )
  220. {
  221. nStartX = nX;
  222. nX = m_wWidth;
  223. nY = m_wHeight;
  224. }
  225. }
  226. }
  228. for ( nY=m_wHeight-1; nY>=0; nY-- )
  229. {
  230. for(nX=m_wWidth-1; nX>=0; nX-- )
  231. {
  232. if ( *(m_pwImage + nX + (nY * m_wWidth)) != 0 )
  233. {
  234. nEndY = nY;
  235. nX = -1;
  236. nY = -1;
  237. }
  238. }
  239. }
  241. for ( nX=m_wWidth-1; nX>=0; nX-- )
  242. {
  243. for ( nY=m_wHeight-1; nY>=0; nY-- )
  244. {
  245. if ( *(m_pwImage + nX + (nY * m_wWidth)) != 0 )
  246. {
  247. nEndX = nX;
  248. nX = -1;
  249. nY = -1;
  250. }
  251. }
  252. }
  254. m_shCenterX = m_wWidth /2 - nStartX;
  255. m_shCenterY = m_wHeight /2 - nStartY;
  258. WORD* pwTmpImage = NULL;
  259. WORD wTmpWidth = 0;
  260. WORD wTmpHeight = 0;
  262. wTmpWidth = (nEndX + 1)- nStartX;
  264. while( wTmpWidth % 4 != 0 )
  265. {
  266. nEndX++;
  267. wTmpWidth = (nEndX + 1) - nStartX;
  268. }
  269. wTmpHeight = (nEndY + 1) - nStartY;
  271. pwTmpImage  = new WORD[wTmpWidth * wTmpHeight];
  273. for ( nY=nStartY; nY<(nEndY+1); nY++ )
  274. {
  275. for ( nX=nStartX; nX<(nEndX+1); nX++ )
  276. {
  277. *(pwTmpImage+nCntY+(nCntX*wTmpWidth)) = *(m_pwImage+nX+(nY*m_wWidth));
  278. nCntY++;
  279. }
  280. nCntY = 0;
  281. nCntX++;
  282. }
  284. DeleteImage();
  286. if ( !m_pwImage )
  287. m_pwImage  = new WORD[wTmpWidth * wTmpHeight];
  289. CopyMemory(m_pwImage, pwTmpImage, sizeof(WORD) * wTmpWidth * wTmpHeight);
  291. m_wWidth = wTmpWidth;
  292. m_wHeight = wTmpHeight;
  294. m_dwImageLength = m_wWidth*m_wHeight*sizeof(WORD);
  296. SAFE_DELETE(pwTmpImage);
  298. return TRUE;
  299. }
  302. BOOL CWHImage::XOptimize()
  303. {
  304. INT nTmpMaxLen = m_wWidth * 2;
  305. WORD* pwTmpMaxLineImage = new WORD[nTmpMaxLen];
  307. DWORD dwWordCntPerLine = 0;
  308. WORD  wContinuousCnt = 0;
  309. DWORD dwWordCntPerFile = 0;
  310. DWORD dwWrittenLen = 0;
  312. HANDLE hFile;
  313. hFile = CreateFile("CompTest.tmp", GENERIC_WRITE|GENERIC_READ, FILE_SHARE_WRITE|FILE_SHARE_READ, NULL, 
  314.    CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
  317. INT nAddCnt = 0;
  319. if ( hFile != INVALID_HANDLE_VALUE )
  320. {
  321. for ( INT nY = 0; nY < m_wHeight; nY++ )
  322. {
  323. for ( INT nX = 0; nX < m_wWidth;  )
  324. {
  325. // 扼牢窜困肺 拘绵阑 茄促.
  327. if ( *(m_pwImage+nX+(nY*m_wWidth)) == 0 )
  328. {
  329. while ( (*(m_pwImage+(nX+nAddCnt)+(nY*m_wWidth)) == 0) && (nX+nAddCnt < m_wWidth) )
  330. {
  331. nAddCnt++;
  332. }
  333. pwTmpMaxLineImage[dwWordCntPerLine] = 0XC0;
  334. dwWordCntPerLine++;
  335. pwTmpMaxLineImage[dwWordCntPerLine] = nAddCnt;
  336. dwWordCntPerLine++;
  338. nX += nAddCnt;
  339. nAddCnt = 0;
  340. }
  341. else if ( *(m_pwImage+nX+(nY*m_wWidth)) == 0XFFFF )
  342. {
  343. while ( (*(m_pwImage+(nX+nAddCnt)+(nY*m_wWidth)) == 0XFFFF) && (nX+nAddCnt < m_wWidth) )
  344. {
  345. nAddCnt++;
  346. }
  347. pwTmpMaxLineImage[dwWordCntPerLine] = 0XC1;
  348. dwWordCntPerLine++;
  349. pwTmpMaxLineImage[dwWordCntPerLine] = nAddCnt;
  350. dwWordCntPerLine++;
  352. nX += nAddCnt;
  353. nAddCnt = 0;
  354. }
  355. else
  356. {
  357. while ( (*(m_pwImage+(nX+nAddCnt)+(nY*m_wWidth)) != 0) && (*(m_pwImage+(nX+nAddCnt)+(nY*m_wWidth)) != 0XFFFF) && (nX+nAddCnt < m_wWidth) )
  358. {
  359. nAddCnt++;
  360. }
  361. pwTmpMaxLineImage[dwWordCntPerLine] = 0XC2;
  362. dwWordCntPerLine++;
  363. pwTmpMaxLineImage[dwWordCntPerLine] = nAddCnt;
  364. dwWordCntPerLine++;
  366. while ( nAddCnt > 0 )
  367. {
  368. pwTmpMaxLineImage[dwWordCntPerLine] = *(m_pwImage+nX+(nY*m_wWidth));
  369. dwWordCntPerLine++;
  370. nAddCnt--;
  371. nX++;
  372. }
  373. }
  374. }
  375. nAddCnt = 0;
  376. WriteFile(hFile, &dwWordCntPerLine, sizeof(WORD), &dwWrittenLen, NULL);
  377. WriteFile(hFile, pwTmpMaxLineImage, sizeof(WORD)*dwWordCntPerLine, &dwWrittenLen, NULL);
  378. dwWordCntPerFile += (dwWordCntPerLine+1);
  379. dwWordCntPerLine = 0;
  380. }
  382. SAFE_DELETE(pwTmpMaxLineImage);
  384. SAFE_DELETE(m_pwImage);
  385. m_pwImage  = new WORD[dwWordCntPerFile];
  386. ZeroMemory(m_pwImage, sizeof(WORD)*dwWordCntPerFile);
  387. m_dwImageLength = dwWordCntPerFile;
  389. SetFilePointer(hFile, 0, NULL, FILE_BEGIN);
  390. ReadFile(hFile, m_pwImage, sizeof(WORD)*dwWordCntPerFile, &dwWrittenLen, NULL);
  392. CloseHandle(hFile);
  394. return TRUE;
  395. }
  396. return FALSE;
  397. }
  400. BOOL CWHImage::LoadBitmapFromRes(LPCTSTR lpResName, LPCTSTR lpTypeName, BOOL fCut, BOOL fCompress, BYTE bBitCount)
  401. {
  402. BITMAPFILEHEADER stFileHeader;
  403. BITMAPINFOHEADER stInfoHeader;
  404. DWORD dwReadSize = 0;
  405. DWORD dwCurrMemPos = 0;
  406. HRSRC hRes = FindResource(GetModuleHandle(NULL), lpResName, lpTypeName);
  408. if ( hRes )
  409. {
  410. DWORD dwSize = SizeofResource(GetModuleHandle(NULL), hRes);
  411. HGLOBAL hMem = LoadResource(GetModuleHandle(NULL), hRes);
  412. BYTE* pbData = (BYTE*)LockResource(hMem);
  414. memcpy(&stFileHeader, pbData+dwCurrMemPos, sizeof(stFileHeader));
  415. dwCurrMemPos += sizeof(stFileHeader);
  417. if ( HIBYTE(stFileHeader.bfType) == 'M' && LOBYTE(stFileHeader.bfType) == 'B' )
  418. {
  419. memcpy(&stInfoHeader, pbData+dwCurrMemPos, sizeof(stInfoHeader));
  420. dwCurrMemPos += sizeof(stInfoHeader);
  422. m_wWidth  = (WORD)stInfoHeader.biWidth;
  423. m_wHeight = (WORD)stInfoHeader.biHeight;
  425. m_dwImageLength = m_wWidth*m_wHeight*sizeof(WORD);
  427. if ( stInfoHeader.biBitCount == 24 )
  428. {
  429. m_pwImage = new WORD[sizeof(WORD) * m_wWidth * m_wHeight];
  431. UINT nSize = stFileHeader.bfSize -  sizeof(stFileHeader) -  sizeof(stInfoHeader);
  433. if ( bBitCount != 16 )
  434. {
  435. memcpy(m_pwImage, pbData+dwCurrMemPos, nSize);
  436. dwCurrMemPos += nSize;
  439. if ( fCut ) Optimize();
  440. if ( fCompress ) XOptimize();
  442. return TRUE;
  443. }
  444. else
  445. {
  446. BYTE *pOrgImage = new BYTE[stInfoHeader.biSizeImage];
  448. memcpy(pOrgImage, pbData+dwCurrMemPos, nSize);
  449. dwCurrMemPos += nSize;
  451. Convert24To16(pOrgImage, (BYTE)stInfoHeader.biBitCount);
  453. delete [] pOrgImage;
  455. if ( fCut ) Optimize();
  456. if ( fCompress ) XOptimize();
  458. return TRUE;
  459. }
  460. }
  461. }
  462. }
  464. return FALSE;
  465. }