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

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

模拟服务器

开发平台：

Visual C++

WHDXGraphic.cpp：源码内容
  1. /******************************************************************************************************************
  2.                                                                                                                    
  3. 葛碘疙:
  5. 累己磊:
  6. 累己老:
  8. [老磊][荐沥磊] : 荐沥 郴侩
  9.                                                                                                                    
  10. *******************************************************************************************************************/
  13. #include "stdafx.h"
  14. #include "WHEngine.h"
  17. /******************************************************************************************************************
  19. CWHDXGraphicWindow Functions
  21. *******************************************************************************************************************/
  24. static BYTE g_bNumDevices = 0;
  25. static DXG_ENUM_DEVICEINFO g_stDXGEnumDeviceInfo[_MAX_DEVICES];
  27. static INT DXGModesSortCallback(const VOID* arg1, const VOID* arg2);
  28. static BOOL WINAPI DXGDriverEnumCallbackEx(GUID* pGUID, LPSTR szDesc, LPSTR szName, LPVOID pContext, HMONITOR hm);
  29. static HRESULT WINAPI DXGEnumDisplayModeCallback(DDSURFACEDESC2* pddsd, VOID* pParentInfo);
  30. static HRESULT WINAPI DXG3DDeviceEnumCallback(TCHAR* szDesc, TCHAR* szName, D3DDEVICEDESC7* pDesc, VOID* pParentInfo);
  31. static HRESULT WINAPI DXGEnumZBufferFormatsCallback(DDPIXELFORMAT* pddpf, VOID* pContext);
  35. CWHDXGraphicWindow* CWHDXGraphicWindow::m_pxDXGWnd = NULL;
  37. CWHDXGraphicWindow* GetDXGWindowPtr()
  38. {
  39. return CWHDXGraphicWindow::m_pxDXGWnd;
  40. }
  43. /******************************************************************************************************************
  45. 窃荐疙 : CWHDXGraphicWindow::CWHDXGraphicWindow()
  47. 累己磊 : 
  48. 累己老 : 
  50. 格利   : 
  51. 涝仿   : WORD wWidth
  52.          WORD wHeight
  53.          WORD wBpp
  54. 免仿   : 
  56. [老磊][荐沥磊] : 荐沥郴侩
  58. *******************************************************************************************************************/
  59. CWHDXGraphicWindow::CWHDXGraphicWindow(WORD wWidth, WORD wHeight, WORD wBpp)
  60. {
  61. m_pDD = NULL;
  62. m_pD3D = NULL;
  63. m_hDefGameFont = NULL;
  64. m_pd3dDevice = NULL;
  65. m_pddsZBuffer = NULL;
  66.     m_pddsFrontBuffer = NULL;
  67.     m_pddsBackBuffer = NULL;
  68. // 俊叼飘扩档快 免仿阑 困秦辑 努府欺甫 技泼茄促.
  69. m_lpcClipper = NULL;
  71. m_stDisplayInfo.wWidth = wWidth;
  72. m_stDisplayInfo.wHeight = wHeight;
  73. m_stDisplayInfo.wBPP = wBpp;
  74. m_bScreenModeFlag = _DXG_SCREENMODE_WINDOW;
  75. m_bDeviceModeFlag = _DXG_DEVICEMODE_PRIMARY;
  77. SetRect(&m_rcWindow, 0, 0, 0, 0);
  78. ZeroMemory(&m_stBitsMaskInfo, sizeof(DXG_MASKINFO));
  80. m_pxDXGWnd = this;
  82. m_bIsWindowActive = FALSE;
  83. m_bIsWindowReady = FALSE;
  85. m_dwTextureTotal = 0;
  86. m_dwTextureFree = 0;
  87. m_dwVideoTotal = 0;
  88. m_dwVideoFree = 0;
  90. m_pxDefProcess = NULL;
  91. }
  94. VOID CWHDXGraphicWindow::UsedAndFreeMemoryCheck()
  95. {
  96. DDSCAPS2     ddsCaps2; 
  98. ZeroMemory(&ddsCaps2, sizeof(ddsCaps2));
  100. ddsCaps2.dwCaps = DDSCAPS_TEXTURE;
  101. m_pDD->GetAvailableVidMem(&ddsCaps2, &m_dwTextureTotal, &m_dwTextureFree); 
  103. ZeroMemory(&ddsCaps2, sizeof(ddsCaps2));
  105. ddsCaps2.dwCaps = DDSCAPS_VIDEOMEMORY;
  106. m_pDD->GetAvailableVidMem(&ddsCaps2, &m_dwVideoTotal, &m_dwVideoFree); 
  107. } 
  110. /******************************************************************************************************************
  112. 窃荐疙 : CWHDXGraphicWindow::~CWHDXGraphicWindow()
  114. 累己磊 : 
  115. 累己老 : 
  117. 格利   : 
  118. 免仿   : 
  120. [老磊][荐沥磊] : 荐沥郴侩
  122. *******************************************************************************************************************/
  123. CWHDXGraphicWindow::~CWHDXGraphicWindow()
  124. {
  125. FreeDXGEnumModeResources();
  126.     DestroyDXGObjects();
  128. m_pxDefProcess = NULL;
  129. m_pxDXGWnd = NULL;
  130. }
  133. /******************************************************************************************************************
  135. 窃荐疙 : CWHDXGraphicWindow::Create()
  137. 累己磊 : 
  138. 累己老 : 
  140. 格利   : 
  141. 涝仿   : LPTSTR lpCaption
  142.          CHAR *pszMenuName
  143.          BYTE bScreenModeFlag
  144.          BYTE bDeviceModeFlag
  145. 免仿   : BOOL 
  147. [老磊][荐沥磊] : 荐沥郴侩
  149. *******************************************************************************************************************/
  150. BOOL CWHDXGraphicWindow::Create(HINSTANCE hInst, LPTSTR lpCaption, CHAR *pszMenuName, CHAR* pszIconName, BYTE bScreenModeFlag, BYTE bDeviceModeFlag)
  151. {
  152. DWORD dwStyle;
  154. if ( !CWHWindow::Create(hInst, lpCaption, pszMenuName, pszIconName) )
  155. {
  156. MessageBox(m_hWnd, TEXT("[CWHDXGraphicWindow::Create]") TEXT("Window create failed."), "MirDXG", MB_ICONERROR | MB_OK);
  157. return FALSE;
  158. }
  160. m_bScreenModeFlag = bScreenModeFlag;
  161. m_bDeviceModeFlag = bDeviceModeFlag;
  163. if ( m_bScreenModeFlag & _DXG_SCREENMODE_WINDOW )
  164. {
  165. dwStyle  = GetWindowStyle(m_hWnd);
  166. dwStyle &= ~WS_POPUP;
  167. dwStyle |= WS_POPUP;//WS_OVERLAPPED | WS_CAPTION | WS_THICKFRAME | WS_MINIMIZEBOX | WS_SYSMENU;
  168. SetWindowLong(m_hWnd, GWL_STYLE, dwStyle);
  169. }
  170. else
  171. {
  172. dwStyle  = GetWindowStyle(m_hWnd);
  173. dwStyle &= ~dwStyle;
  174. dwStyle |= WS_POPUP;
  175. SetWindowLong(m_hWnd, GWL_STYLE, dwStyle);
  176. }
  178. HRESULT hr;
  179. if ( hr = SUCCEEDED(DirectDrawEnumerateEx(DXGDriverEnumCallbackEx, NULL,
  180.   DDENUM_ATTACHEDSECONDARYDEVICES | DDENUM_DETACHEDSECONDARYDEVICES | DDENUM_NONDISPLAYDEVICES)) )
  181. {
  182. if ( hr = SUCCEEDED(CreateDXG()) )
  183. {
  184. m_bIsWindowReady = TRUE;
  185. CreateDefFont();
  186. return TRUE;
  187. }
  188. else
  189. {
  190. MessageBox(m_hWnd, TEXT("[CWHDXGraphicWindow::Create]") TEXT("DirectGraphic create failed."), "MirDXG", MB_ICONERROR | MB_OK);
  191. return FALSE;
  192. }
  193. }
  195. return FALSE;
  196. }
  199. /******************************************************************************************************************
  201. 窃荐疙 : CWHDXGraphicWindow::MainWndProcDXG()
  203. 累己磊 : 
  204. 累己老 : 
  206. 格利   : 
  207. 涝仿   : HWND hWnd
  208.          UINT uMsg
  209.          WPARAM wParam
  210.          LPARAM lParam
  211. 免仿   : LRESULT 
  213. [老磊][荐沥磊] : 荐沥郴侩
  215. *******************************************************************************************************************/
  216. LRESULT CWHDXGraphicWindow::MainWndProcDXG(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
  217. {
  218. switch (uMsg)
  219. {
  220. case WM_SYSKEYDOWN:
  221. return OnSysKeyDown(wParam, lParam);
  223. case WM_MOVE:
  224. return OnMove(wParam, lParam);
  226. case WM_SIZE:
  227. return OnSize(wParam, lParam);
  229. case WM_DESTROY:
  230. return OnDestroy();
  232.         case WM_SETCURSOR:
  233. return OnSetCursor();   
  235.  //      case WM_GETMINMAXINFO:
  236. // return OnGetMinMaxInfo(wParam, lParam);
  238. default:
  239. break;
  240. }
  242.     return CWHWindow::MainWndProc(hWnd, uMsg, wParam, lParam);
  243. }
  246. LRESULT CWHDXGraphicWindow::OnGetMinMaxInfo(WPARAM wParam, LPARAM lParam)
  247. {
  248. if ( m_hWnd )
  249. {
  250. MINMAXINFO* pMinMax = (MINMAXINFO*) lParam;
  252. DWORD dwFrameWidth    = GetSystemMetrics( SM_CXSIZEFRAME );
  253. DWORD dwFrameHeight   = GetSystemMetrics( SM_CYSIZEFRAME );
  254. DWORD dwMenuHeight;
  255. if( GetMenu( m_hWnd ) )
  256. dwMenuHeight    = GetSystemMetrics( SM_CYMENU );
  257. else
  258. dwMenuHeight    = 0;
  260. DWORD dwCaptionHeight = GetSystemMetrics( SM_CYCAPTION );
  262. pMinMax->ptMinTrackSize.x = m_stDisplayInfo.wWidth  + dwFrameWidth * 2;
  263. pMinMax->ptMinTrackSize.y = m_stDisplayInfo.wHeight + dwFrameHeight * 2 + 
  264. dwMenuHeight + dwCaptionHeight;
  266. pMinMax->ptMaxTrackSize.x = pMinMax->ptMinTrackSize.x;
  267. pMinMax->ptMaxTrackSize.y = pMinMax->ptMinTrackSize.y;
  268. }
  270.     return 0L;
  271. }
  274. LRESULT CWHDXGraphicWindow::OnSetCursor()
  275. {
  276.     SetCursor(LoadCursor(NULL, IDC_ARROW));
  277.     return 0L;
  278. }
  282. /******************************************************************************************************************
  284. 窃荐疙 : CWHDXGraphicWindow::OnSize()
  286. 累己磊 : 
  287. 累己老 : 
  289. 格利   : 
  290. 涝仿   : WPARAM wParam
  291.          LPARAM lParam
  292. 免仿   : LRESULT 
  294. [老磊][荐沥磊] : 荐沥郴侩
  296. *******************************************************************************************************************/
  297. LRESULT CWHDXGraphicWindow::OnSize(WPARAM wParam, LPARAM lParam)
  298. {
  299.     if ( SIZE_MAXHIDE == wParam || SIZE_MINIMIZED == wParam )
  300.         m_bIsWindowActive = FALSE;
  301.     else
  302.         m_bIsWindowActive = TRUE;
  304. UpdateBoundsWnd();
  305.   return 0L;
  306. }
  310. /******************************************************************************************************************
  312. 窃荐疙 : CWHDXGraphicWindow::OnMove()
  314. 累己磊 : 
  315. 累己老 : 
  317. 格利   : 
  318. 涝仿   : WPARAM wParam
  319.          LPARAM lParam
  320. 免仿   : LRESULT 
  322. [老磊][荐沥磊] : 荐沥郴侩
  324. *******************************************************************************************************************/
  325. LRESULT CWHDXGraphicWindow::OnMove(WPARAM wParam, LPARAM lParam)
  326. {
  327. UpdateBoundsWnd();
  328. return 0L;
  329. }
  332. /******************************************************************************************************************
  334. 窃荐疙 : CWHDXGraphicWindow::OnDestroy()
  336. 累己磊 : 
  337. 累己老 : 
  339. 格利   : 
  340. 免仿   : BOOL 
  342. [老磊][荐沥磊] : 荐沥郴侩
  344. *******************************************************************************************************************/
  345. LRESULT CWHDXGraphicWindow::OnDestroy()
  346. {
  347. return CWHWindow::OnDestroy();
  348. }
  351. /******************************************************************************************************************
  353. 窃荐疙 : CWHDXGraphicWindow::OnSysKeyDown()
  355. 累己磊 : 
  356. 累己老 : 
  358. 格利   : 
  359. 涝仿   : WPARAM wParam
  360.          LPARAM lParam
  361. 免仿   : LRESULT 
  363. [老磊][荐沥磊] : 荐沥郴侩
  365. *******************************************************************************************************************/
  366. LRESULT CWHDXGraphicWindow::OnSysKeyDown(WPARAM wParam, LPARAM lParam)
  367. {
  368. if ( wParam == VK_RETURN )
  369. {
  370. m_bIsWindowReady = FALSE;
  372.   D3DTextr_InvalidateAllTextures();
  374. D3DWILTextr_InvalidateAllTextures();
  375. D3DWILTextr_DestroyAllTextures();
  377. if ( m_bScreenModeFlag & _DXG_SCREENMODE_WINDOW )
  378. {
  379. if ( FAILED(ResetDXG(_SCREEN_WIDTH, _SCREEN_HEIGHT, _SCREEN_BPP, _DXG_SCREENMODE_FULLSCREEN, _DXG_DEVICEMODE_PRIMARY|_DXG_DEVICEMODE_D3D)) )
  380. {
  381. MessageBox(m_hWnd, TEXT("DirectDraw RESETUP failed!!!") TEXT("The Program will now exit."), TEXT("MirDXG"), MB_ICONERROR | MB_OK);
  382. }
  383. }
  384. else
  385. {
  386. if ( FAILED(ResetDXG(_SCREEN_WIDTH, _SCREEN_HEIGHT, _SCREEN_BPP, _DXG_SCREENMODE_WINDOW, _DXG_DEVICEMODE_PRIMARY|_DXG_DEVICEMODE_D3D)) )
  387. {
  388. MessageBox(m_hWnd, TEXT("DirectDraw RESETUP failed!!!") TEXT("The Program will now exit."), TEXT("MirDXG"), MB_ICONERROR | MB_OK);
  389. }
  390. }
  392. D3DTextr_RestoreAllTextures(m_pd3dDevice);
  394. m_bIsWindowReady = TRUE;
  395. }
  397. return 0L;
  398. }
  401. /******************************************************************************************************************
  403. 窃荐疙 : CWHDXGraphicWindow::FindDriverAndDevice()
  405. 累己磊 : 
  406. 累己老 : 
  408. 格利   : 
  409. 免仿   : DWORD 
  411. [老磊][荐沥磊] : 荐沥郴侩
  413. *******************************************************************************************************************/
  414. BYTE CWHDXGraphicWindow::FindDriverAndDevice()
  415. {
  416. BYTE bNum = 0;
  417. CHAR bCnt;
  418.  
  419. if ( m_bDeviceModeFlag & _DXG_DEVICEMODE_PRIMARY )
  420. {
  421. for ( bCnt = 0; bCnt < g_bNumDevices; bCnt++ )
  422. {
  423. if ( !g_stDXGEnumDeviceInfo[bCnt].pDriverGUID )
  424. {
  425. if ( g_stDXGEnumDeviceInfo[bCnt].f3DHardware ) return bCnt;
  426. else bNum = bCnt;
  427. }
  428. }
  429. }
  430. else
  431. {
  432. for ( bCnt = g_bNumDevices-1; bCnt >= 0; bCnt-- )
  433. {
  434. // 厚叼坷 墨靛啊 2俺捞惑
  435. if( g_bNumDevices > 2 )
  436. {
  437. if ( g_stDXGEnumDeviceInfo[0].dwNumModes != g_stDXGEnumDeviceInfo[bCnt].dwNumModes )
  438. {
  439. if ( g_stDXGEnumDeviceInfo[bCnt].f3DHardware ) return bCnt;
  440. else
  441. {
  442. bNum = bCnt;
  443. break;
  444. }
  445. }
  446. }
  447. else
  448. {
  449. if ( g_stDXGEnumDeviceInfo[bCnt].f3DHardware ) return bCnt;
  450. else bNum = bCnt;
  451. }
  452. }
  453. }
  455. return bNum;
  456. }
  459. /******************************************************************************************************************
  461. 窃荐疙 : CWHDXGraphicWindow::DestroyDXGObjects()
  463. 累己磊 : 
  464. 累己老 : 
  466. 格利   : 
  467. 免仿   : HRESULT 
  469. [老磊][荐沥磊] : 荐沥郴侩
  471. *******************************************************************************************************************/
  472. HRESULT CWHDXGraphicWindow::DestroyDXGObjects()
  473. {
  474. HRESULT hr;
  475. LONG lDDRefCnt  = 0L;
  476.     LONG lD3DRefCnt = 0L;
  478. if ( !(m_bScreenModeFlag & _DXG_SCREENMODE_WINDOW) )
  479. {
  480. if ( FAILED(hr = m_pDD->RestoreDisplayMode()) )
  481. return E_FAIL;
  482. }
  483.     if ( m_pDD )
  484. {
  485. if ( FAILED(hr = m_pDD->SetCooperativeLevel(m_hWnd, DDSCL_NORMAL)) )
  486. return E_FAIL;
  487. }
  489.     if ( m_pd3dDevice )
  490. {
  491.         if ( 0 < ( lD3DRefCnt = m_pd3dDevice->Release() ) )
  492. return E_FAIL;
  493. }
  494.     m_pd3dDevice = NULL;
  496.     SAFE_RELEASE(m_pddsBackBuffer);
  497.     SAFE_RELEASE(m_pddsFrontBuffer);
  498.     SAFE_RELEASE(m_pddsZBuffer);
  499. // 俊叼飘扩档快 免仿阑 困秦辑 努府欺甫 技泼茄促.
  500. SAFE_RELEASE(m_lpcClipper);
  501.     SAFE_RELEASE(m_pD3D);
  503.     if ( m_pDD )
  504.     {
  505.         if ( 0 < ( lDDRefCnt = m_pDD->Release() ) )
  506. INT nAAAAAA = 0;
  507. // return E_FAIL;
  508.     }
  509.     m_pDD = NULL;
  511. if ( m_hDefGameFont != NULL )
  512. {
  513. DeleteObject(m_hDefGameFont);
  514. m_hDefGameFont = NULL; 
  515. }
  517. return S_OK;
  518. //    return ( lDDRefCnt==0 && lD3DRefCnt==0 ) ? S_OK : E_FAIL;
  519. }
  522. /******************************************************************************************************************
  524. 窃荐疙 : CWHDXGraphicWindow::FreeDXGEnumModeResources()
  526. 累己磊 : 
  527. 累己老 : 
  529. 格利   : 
  530. 免仿   : VOID 
  532. [老磊][荐沥磊] : 荐沥郴侩
  534. *******************************************************************************************************************/
  535. VOID CWHDXGraphicWindow::FreeDXGEnumModeResources()
  536. {
  537.     for ( BYTE bCnt = 0; bCnt < g_bNumDevices; bCnt++ )
  538.     {
  539.         SAFE_DELETE( g_stDXGEnumDeviceInfo[bCnt].pddsdModes );
  540.     }
  541. }
  544. /******************************************************************************************************************
  546. 窃荐疙 : CWHDXGraphicWindow::CreateDXG()
  548. 累己磊 : 
  549. 累己老 : 
  551. 格利   : 
  552. 免仿   : HRESULT 
  554. [老磊][荐沥磊] : 荐沥郴侩
  556. *******************************************************************************************************************/
  557. HRESULT CWHDXGraphicWindow::CreateDXG() 
  558. {
  559.     HRESULT hr;
  561. BYTE bSelecedDevice = FindDriverAndDevice();
  563. if ( SUCCEEDED(hr = DirectDrawCreateEx(g_stDXGEnumDeviceInfo[bSelecedDevice].pDriverGUID, (VOID**)&m_pDD, IID_IDirectDraw7, NULL)) ) 
  564. {
  565. if ( m_bScreenModeFlag & _DXG_SCREENMODE_WINDOW )
  566. {
  567. if ( FAILED(hr = m_pDD->SetCooperativeLevel(m_hWnd, DDSCL_NORMAL)) )
  568. return E_FAIL;
  569. }
  570. else
  571. {
  572. if ( FAILED(hr = m_pDD->SetCooperativeLevel(m_hWnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_ALLOWREBOOT)) )
  573. return E_FAIL;
  575. if ( FAILED(hr = m_pDD->SetDisplayMode(m_stDisplayInfo.wWidth, m_stDisplayInfo.wHeight, m_stDisplayInfo.wBPP, 0, 0)) )
  576. return E_FAIL;
  577. }
  579. if ( FAILED(hr == CreatePrimarySurface()) )
  580. {
  581. MessageBox(m_hWnd, TEXT("[CWHDXGraphicWindow::CreateDXG]") TEXT("Primary surface create failed."), TEXT("MirDXG"), MB_ICONERROR | MB_OK);
  582. return E_FAIL;
  583. }
  585. UpdateBoundsWnd();
  587. if ( m_bDeviceModeFlag & _DXG_DEVICEMODE_D3D )
  588. {
  589. if ( FAILED( hr = m_pDD->QueryInterface(IID_IDirect3D7, (VOID**)&m_pD3D)) )
  590. return E_FAIL;
  592. if ( FAILED(hr = m_pD3D->CreateDevice(*g_stDXGEnumDeviceInfo[bSelecedDevice].pDeviceGUID, m_pddsBackBuffer, &m_pd3dDevice)) )
  593. return E_FAIL;
  595. D3DVIEWPORT7 d3dVP = { 0, 0, m_stDisplayInfo.wWidth, m_stDisplayInfo.wHeight, 0.0f, 1.0f };
  597. if ( FAILED( hr = m_pd3dDevice->SetViewport(&d3dVP)) ) return hr;
  599. if ( m_bDeviceModeFlag & _DXG_DEVICEMODE_ZBUFFER )
  600. {
  601. if ( FAILED(hr = CreateZBuffer(g_stDXGEnumDeviceInfo[bSelecedDevice].pDeviceGUID)) )
  602. {
  603. MessageBox(m_hWnd, TEXT("[CWHDXGraphicWindow::CreateDXG]") TEXT("ZBuffer create failed."), TEXT("MirDXG"), MB_ICONERROR | MB_OK);
  604. return E_FAIL;
  605. }
  606. }
  607. }
  609. m_stBitsMaskInfo = GetRGBMaskInfoIN16Bits(m_pddsBackBuffer);
  610. Init3DDeviceObjects();
  612. return S_OK;
  613. }
  615. return hr;
  616. }
  619. /******************************************************************************************************************
  621. 窃荐疙 : CDXGraphic::ResetDXG()
  623. 累己磊 : 
  624. 累己老 : 
  626. 格利   : 
  627. 涝仿   : WORD wWidth
  628.          WORD wHeight
  629.          WORD wBPP
  630.          BYTE bScreenModeFlag
  631.          BYTE bDeviceModeFlag
  632. 免仿   : HRESULT 
  634. [老磊][荐沥磊] : 荐沥郴侩
  636. *******************************************************************************************************************/
  637. HRESULT CWHDXGraphicWindow::ResetDXG(WORD wWidth, WORD wHeight, WORD wBPP, BYTE bScreenModeFlag, BYTE bDeviceModeFlag)
  638. {
  639.     HRESULT hr;
  640.     DWORD dwStyle;
  642. if ( m_bDeviceModeFlag == bDeviceModeFlag && m_bScreenModeFlag == bScreenModeFlag && 
  643.  m_stDisplayInfo.wWidth == wWidth && m_stDisplayInfo.wHeight == wHeight && m_stDisplayInfo.wBPP == wBPP )
  644. return E_FAIL;     
  646.     if ( FAILED(DestroyDXGObjects()) )
  647. {
  648. MessageBox(m_hWnd, TEXT("[CWHDXGraphicWindow::ResetDXG]") TEXT("DirectGraphic reset failed."), "MirDXG", MB_ICONERROR | MB_OK);
  649. return E_FAIL;
  650. }
  652. m_stDisplayInfo.wWidth = wWidth;
  653. m_stDisplayInfo.wHeight = wHeight;
  654. m_stDisplayInfo.wBPP = wBPP;
  655. m_bScreenModeFlag = bScreenModeFlag;
  656. m_bDeviceModeFlag = bDeviceModeFlag;
  658. if ( m_bScreenModeFlag & _DXG_SCREENMODE_WINDOW )
  659. {
  660. dwStyle  = GetWindowStyle(m_hWnd);
  661. dwStyle &= ~WS_POPUP;
  662. dwStyle |= WS_OVERLAPPED | WS_CAPTION | WS_THICKFRAME | WS_MINIMIZEBOX | WS_SYSMENU;
  663. SetWindowLong(m_hWnd, GWL_STYLE, dwStyle);
  664. }
  665. else
  666. {
  667. dwStyle  = GetWindowStyle(m_hWnd);
  668. dwStyle &= ~dwStyle;
  669. dwStyle |= WS_POPUP;
  670. SetWindowLong(m_hWnd, GWL_STYLE, dwStyle);
  671. }
  673. if ( hr = FAILED(CreateDXG()) )
  674. {
  675. MessageBox(m_hWnd, TEXT("[CWHDXGraphicWindow::ResetDXG]") TEXT("DirectGraphic create failed."), "MirDXG", MB_ICONERROR | MB_OK);
  676. return E_FAIL;
  677. }
  679. CreateDefFont();
  681. return S_OK;
  682. }
  685. /******************************************************************************************************************
  687. 窃荐疙 : CWHDXGraphicWindow::CreatePrimarySurface()
  689. 累己磊 : 
  690. 累己老 : 
  692. 格利   : 
  693. 免仿   : HRESULT 
  695. [老磊][荐沥磊] : 荐沥郴侩
  697. *******************************************************************************************************************/
  698. HRESULT CWHDXGraphicWindow::CreatePrimarySurface()
  699. {
  700.     DDSURFACEDESC2 ddsd;
  701.     HRESULT hr;
  703. ZeroMemory(&ddsd, sizeof(ddsd));
  704. ddsd.dwSize = sizeof(ddsd);
  706. if ( m_bScreenModeFlag & _DXG_SCREENMODE_WINDOW )
  707. {
  708. RECT rcWork;
  709. RECT rcTemp;
  711.     GetWindowRect(m_hWnd, &rcTemp);
  713. // 努扼捞攫飘康开狼 农扁甫 棱绰何盒篮 扩档快狼 积己苞 包访捞 乐促.
  714. // 拳搁秦惑档 溜, 努扼捞攫飘 荤阿屈 康开狼 农扁甫 掘绢柯促.
  715. SetRect(&rcTemp, 0, 0, m_stDisplayInfo.wWidth, m_stDisplayInfo.wHeight);
  717. // 努扼捞攫飘 荤阿屈 康开农扁俊辑 扩档快 傈眉康开狼 农扁肺 函券茄促.
  718. AdjustWindowRectEx(&rcTemp, GetWindowStyle(m_hWnd), GetMenu(m_hWnd) != NULL, GetWindowExStyle(m_hWnd));
  720. // 扩档快 傈眉康开农扁肺 扩档快甫 技泼茄促. 窜 矫累谅钎绰 公矫等促.
  721. SetWindowPos(m_hWnd, NULL, 0, 0, rcTemp.right-rcTemp.left, rcTemp.bottom-rcTemp.top,
  722.  SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
  724. // HWND_NOTOPMOST甫 技泼窍扁 困秦辑捞促.
  725. SetWindowPos(m_hWnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
  727. // 官帕拳搁康开狼 农扁甫 掘绢柯促..
  728. SystemParametersInfo(SPI_GETWORKAREA, 0, &rcWork, 0);
  729. GetWindowRect(m_hWnd, &rcTemp);
  730. if ( rcTemp.left < rcWork.left ) rcTemp.left = rcWork.left;
  731. if ( rcTemp.top  < rcWork.top ) rcTemp.top  = rcWork.top;
  733. // 扩档快狼 矫累谅钎甫 技泼茄促.
  734. SetWindowPos(m_hWnd, NULL, rcTemp.left, rcTemp.top, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
  735.     
  736. ddsd.dwFlags        = DDSD_CAPS;
  737. ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
  739. if ( FAILED(hr = m_pDD->CreateSurface(&ddsd, &m_pddsFrontBuffer, NULL)) ) return E_FAIL;
  741. ddsd.dwFlags        = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
  742. ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
  744. if ( m_bDeviceModeFlag & _DXG_DEVICEMODE_D3D )
  745. ddsd.ddsCaps.dwCaps |= DDSCAPS_3DDEVICE;
  747. ddsd.dwWidth    = m_stDisplayInfo.wWidth;
  748. ddsd.dwHeight   = m_stDisplayInfo.wHeight;
  750. if ( FAILED(hr = m_pDD->CreateSurface(&ddsd, &m_pddsBackBuffer, NULL)) ) return E_FAIL;
  751. }
  752. else
  753. {
  754. ddsd.dwFlags           = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
  755. ddsd.ddsCaps.dwCaps    = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;
  756. ddsd.dwBackBufferCount = 1;
  757. if ( m_bDeviceModeFlag & _DXG_DEVICEMODE_D3D )
  758. ddsd.ddsCaps.dwCaps |= DDSCAPS_3DDEVICE;
  760. if ( FAILED(hr = m_pDD->CreateSurface(&ddsd, &m_pddsFrontBuffer, NULL)) ) return E_FAIL;
  762. DDSCAPS2 ddscaps;
  763. ZeroMemory(&ddscaps, sizeof(ddscaps));
  764. ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
  766. if ( FAILED(hr = m_pddsFrontBuffer->GetAttachedSurface(&ddscaps, &m_pddsBackBuffer)) )
  767. return E_FAIL;
  768. }
  770. // 俊叼飘扩档快 免仿阑 困秦辑 努府欺甫 技泼茄促.////////////////////////////////////////////////////////////////
  771. if ( FAILED(hr = m_pDD->CreateClipper(0, &m_lpcClipper, NULL)) ) return E_FAIL;
  772. if ( FAILED(hr = m_lpcClipper->SetHWnd(0, m_hWnd)) )
  773. {
  774. m_lpcClipper->Release();
  775. return E_FAIL;
  776. }
  777. if ( FAILED(hr = m_pddsFrontBuffer->SetClipper(m_lpcClipper)) )
  778. {
  779. m_lpcClipper->Release();
  780. return E_FAIL;
  781. }
  782.     m_pDD->FlipToGDISurface();
  783. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  785. return S_OK;
  786. }
  789. /******************************************************************************************************************
  791. 窃荐疙 : CWHDXGraphicWindow::UpdateBoundsWnd()
  793. 累己磊 : 
  794. 累己老 : 
  796. 格利   : 
  797. 免仿   : VOID 
  799. [老磊][荐沥磊] : 荐沥郴侩
  801. *******************************************************************************************************************/
  802. VOID CWHDXGraphicWindow::UpdateBoundsWnd()
  803. {
  804. if ( m_bScreenModeFlag & _DXG_SCREENMODE_WINDOW )
  805. {
  806.         GetClientRect(m_hWnd, &m_rcWindow);
  807.         ClientToScreen(m_hWnd, (POINT*)&m_rcWindow);
  808.         ClientToScreen(m_hWnd, (POINT*)&m_rcWindow+1);
  809.     }
  810.     else
  811.     {
  812.         SetRect(&m_rcWindow, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
  813.     }
  814. }
  817. /******************************************************************************************************************
  819. 窃荐疙 : CWHDXGraphicWindow::CreateZBuffer()
  821. 累己磊 : 
  822. 累己老 : 
  824. 格利   : 
  825. 涝仿   : GUID* pDeviceGUID
  826. 免仿   : HRESULT 
  828. [老磊][荐沥磊] : 荐沥郴侩
  830. *******************************************************************************************************************/
  831. HRESULT CWHDXGraphicWindow::CreateZBuffer(GUID* pDeviceGUID)
  832. {
  833.     HRESULT hr;
  835.     D3DDEVICEDESC7 ddDesc;
  836.     m_pd3dDevice->GetCaps(&ddDesc);
  837.     if (ddDesc.dpcTriCaps.dwRasterCaps & D3DPRASTERCAPS_ZBUFFERLESSHSR)
  838.         return S_OK;
  840.     DDSURFACEDESC2 ddsd;
  841. ZeroMemory(&ddsd, sizeof(DDSURFACEDESC2));
  842.     ddsd.dwSize = sizeof(ddsd);
  843.     m_pddsBackBuffer->GetSurfaceDesc(&ddsd);
  845.     ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_PIXELFORMAT;
  846.     ddsd.ddsCaps.dwCaps = DDSCAPS_ZBUFFER;
  847.     ddsd.ddpfPixelFormat.dwSize = 0;
  849.     if ( FAILED(hr = m_pD3D->EnumZBufferFormats(*pDeviceGUID, DXGEnumZBufferFormatsCallback, (VOID*)&ddsd.ddpfPixelFormat)) )
  850.         return E_FAIL;
  852.     if ( 0 == ddsd.ddpfPixelFormat.dwSize )
  853.     {
  854.         ddsd.ddpfPixelFormat.dwRGBBitCount = 16;
  855.         if ( FAILED(hr = m_pD3D->EnumZBufferFormats(*pDeviceGUID, DXGEnumZBufferFormatsCallback,  (VOID*)&ddsd.ddpfPixelFormat)) )
  856.         return E_FAIL;
  857.         if ( 0 == ddsd.ddpfPixelFormat.dwSize )
  858.         return E_FAIL;
  859.     }
  861.     if ( FAILED(hr = m_pDD->CreateSurface(&ddsd, &m_pddsZBuffer, NULL)) ) return E_FAIL;
  862.     if ( FAILED(hr = m_pddsBackBuffer->AddAttachedSurface(m_pddsZBuffer)) )     return E_FAIL;
  864.     if ( FAILED(hr = m_pd3dDevice->SetRenderTarget(m_pddsBackBuffer, 0L)) )
  865.     {
  866.         return E_FAIL;
  867.     }
  869.     return S_OK;
  870. }
  873. HRESULT CWHDXGraphicWindow::Init3DDeviceObjects()
  874. {
  875.     // Set the transform matrices
  876.     D3DMATRIX matWorld, matView, matProj;
  878. // 泅犁 800*600拳搁俊 嘎霸 3D 谅钎拌甫 汲沥茄促.
  879.   D3DVECTOR vEyePt    = D3DVECTOR(0, 0, -300.0f);
  880.     D3DVECTOR vLookatPt = D3DVECTOR(0, 0, 0);
  881.     D3DVECTOR vUpVec    = D3DVECTOR(0, 1, 0);
  882.     D3DUtil_SetIdentityMatrix(matWorld);
  883.     D3DUtil_SetViewMatrix(matView, vEyePt, vLookatPt, vUpVec);
  884.     D3DUtil_SetProjectionMatrix(matProj, g_PI/2, float(600.0f/800.0f), -1.0f, 1.0f);
  886. // MATRIAL狼 檬扁拳甫 汲沥茄促.
  887.     D3DMATERIAL7 mtrl;
  888. ZeroMemory(&mtrl, sizeof(mtrl));
  889. mtrl.diffuse.r = mtrl.diffuse.g = mtrl.diffuse.b = 0.1f;
  890. mtrl.ambient.r = mtrl.ambient.g = mtrl.ambient.b = 1.0f;
  891.     m_pd3dDevice->SetMaterial(&mtrl);
  893. if ( !m_pd3dDevice )
  894. return E_FAIL;
  896.     m_pd3dDevice->SetTransform(D3DTRANSFORMSTATE_WORLD,      &matWorld);
  897.     m_pd3dDevice->SetTransform(D3DTRANSFORMSTATE_VIEW,       &matView);
  898.     m_pd3dDevice->SetTransform(D3DTRANSFORMSTATE_PROJECTION, &matProj);
  900. // RenderState狼 檬扁蔼 汲沥.
  901. m_pd3dDevice->SetRenderState(D3DRENDERSTATE_AMBIENT, 0xFFFFFFFF);
  902.     m_pd3dDevice->SetRenderState(D3DRENDERSTATE_DITHERENABLE, FALSE); 
  903. m_pd3dDevice->SetRenderState(D3DRENDERSTATE_CULLMODE, D3DCULL_NONE); 
  904. m_pd3dDevice->SetRenderState(D3DRENDERSTATE_ZENABLE, D3DZB_FALSE);
  905. m_pd3dDevice->SetRenderState(D3DRENDERSTATE_FILLMODE, D3DFILL_SOLID);
  906. // m_pd3dDevice->SetRenderState(D3DRENDERSTATE_FILLMODE, D3DFILL_WIREFRAME);
  907. // m_pd3dDevice->SetRenderState(D3DRENDERSTATE_SHADEMODE, D3DSHADE_GOURAUD);
  909.     // TextureStageState狼 檬扁蔼 汲沥.
  910. m_pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
  911.     m_pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE); 
  912.     m_pd3dDevice->SetTextureStageState(0, D3DTSS_COLOROP,   D3DTOP_MODULATE);
  913.     m_pd3dDevice->SetTextureStageState(0, D3DTSS_MINFILTER, D3DTFN_POINT); 
  914.     m_pd3dDevice->SetTextureStageState(0, D3DTSS_MAGFILTER, D3DTFG_POINT);
  915. m_pd3dDevice->SetTextureStageState(0, D3DTSS_MIPFILTER, D3DTFP_NONE);
  917.     return S_OK;
  918. }
  921. /******************************************************************************************************************
  923. 窃荐疙 : CWHDXGraphicWindow::CreateGameFont()
  925. 累己磊 : 
  926. 累己老 : 
  928. 格利   : 
  929. 涝仿   : LPCSTR szFontName
  930.          INT nXsize
  931.          INT nYsize
  932.          BYTE bFontType
  933. 免仿   : VOID 
  935. [老磊][荐沥磊] : 荐沥郴侩
  937. *******************************************************************************************************************/
  938. HFONT CWHDXGraphicWindow::CreateGameFont(LPCSTR szFontName, INT nHeight, INT nWidth, INT nWeight, BOOL bItalic, BOOL bULine, BOOL bStrikeOut, DWORD dwCharSet)
  939. {
  940. INT nYsize;
  942. // 迄飘农扁 嘎眠扁.
  943. if ( m_pddsBackBuffer )
  944. {
  945. HDC hDC;
  946. m_pddsBackBuffer->GetDC(&hDC);
  947. nYsize = -MulDiv(nHeight, GetDeviceCaps(hDC, LOGPIXELSY), 72); 
  948. m_pddsBackBuffer->ReleaseDC(hDC);
  949. }
  951. return CreateFont(nYsize, nWidth, 0, 0, nWeight, bItalic, bULine, bStrikeOut, dwCharSet, 
  952.   OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, 
  953.   DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN, szFontName);
  955. }
  956. VOID CWHDXGraphicWindow::CreateDefFont()
  957. {
  958. // 捞固 扁夯迄飘啊 积己登绢 乐栏搁 货肺 父甸荐 乐档废 Clear.
  959. if ( m_hDefGameFont != NULL )
  960. {
  961. DeleteObject(m_hDefGameFont); 
  962. m_hDefGameFont = NULL;
  963. }
  965. m_hDefGameFont = CreateGameFont("奔覆", 9);
  966. }
  970. VOID CWHDXGraphicWindow::StringPlus(CHAR* szResult, CHAR* szSrc, ...)
  971. {
  972. INT nCnt = 0;
  974. va_list vaMarker;
  975. CHAR* pszString;
  978. // ZeroMemory(szResult, strlen(szResult));
  979. va_start(vaMarker, szSrc);
  980. pszString = szSrc;
  982. while ( TRUE )
  983. {
  984. strcpy(&szResult[strlen(szResult)], pszString);
  985. if ( !strcmp(pszString,  "") ) break;
  986. pszString = (CHAR*)va_arg(vaMarker, CHAR*);
  987. }
  989. va_end(vaMarker);
  990. }
  993. CHAR* CWHDXGraphicWindow::IntToStr(INT nNum)
  994. {
  995. static CHAR szResult[MAX_PATH];
  996. ZeroMemory(szResult, MAX_PATH);
  997. _itoa(nNum, szResult, 10);
  998. return szResult;
  999. }
  1004. /******************************************************************************************************************
  1006. 窃荐疙 : CWHDXGraphicWindow::PutsHan()
  1008. 累己磊 : 
  1009. 累己老 : 
  1011. 格利   : 
  1012. 涝仿   : LPDIRECTDRAWSURFACE7 pSurface
  1013.          INT nX
  1014.          INT nY
  1015.          COLORREF foreColor
  1016.          COLORREF backColor
  1017.          CHAR* szFormat
  1018.          ...
  1019. 免仿   : VOID 
  1021. [老磊][荐沥磊] : 荐沥郴侩
  1023. *******************************************************************************************************************/
  1024. VOID CWHDXGraphicWindow::PutsHan(LPDIRECTDRAWSURFACE7 pSurface, INT nX, INT nY, COLORREF foreColor, COLORREF backColor, CHAR* szText, HFONT hFont)
  1025. {
  1026. HDC hDC;
  1027. HFONT hOldFont;
  1029.     if (NULL == pSurface)
  1030. pSurface = m_pddsBackBuffer;
  1032.     if ( NULL == pSurface )
  1033. return;
  1035. if ( NULL == hFont )
  1036. hFont = m_hDefGameFont;
  1038. HRESULT hr = pSurface->GetDC(&hDC);
  1040. if (backColor == RGB( 0, 0, 0 )) SetBkMode(hDC, TRANSPARENT);
  1041. else SetBkColor(hDC, backColor);
  1043. hOldFont = (HFONT)SelectObject(hDC, hFont);
  1045. SetTextColor(hDC, foreColor);
  1047. TextOut(hDC, nX, nY, szText, strlen(szText));
  1049. SelectObject(hDC, hOldFont);
  1051. if ( hFont != m_hDefGameFont )
  1052. DeleteObject(hFont);
  1054. pSurface->ReleaseDC(hDC);
  1055. }
  1058. /******************************************************************************************************************
  1060. 窃荐疙 : CWHDXGraphicWindow::PutsHan()
  1062. 累己磊 : 
  1063. 累己老 : 
  1065. 格利   : 
  1066. 涝仿   : LPDIRECTDRAWSURFACE7 pSurface
  1067.          INT nX
  1068.          INT nY
  1069.          COLORREF foreColor
  1070.          COLORREF backColor
  1071.          CHAR* szFormat
  1072.          ...
  1073. 免仿   : VOID 
  1075. [老磊][荐沥磊] : 荐沥郴侩
  1077. *******************************************************************************************************************/
  1078. VOID CWHDXGraphicWindow::PutsHan(LPDIRECTDRAWSURFACE7 pSurface, RECT rc, COLORREF foreColor, COLORREF backColor, CHAR* szText, HFONT hFont)
  1079. {
  1080. HDC hDC;
  1081. HFONT hOldFont;
  1083.     if (NULL == pSurface)
  1084. pSurface = m_pddsBackBuffer;
  1086.     if ( NULL == pSurface )
  1087. return;
  1089. if ( NULL == hFont )
  1090. hFont = m_hDefGameFont;
  1092. HRESULT hr = pSurface->GetDC(&hDC);
  1094. if (backColor == RGB( 0, 0, 0 )) SetBkMode(hDC, TRANSPARENT);
  1095. else SetBkColor(hDC, backColor);
  1097. hOldFont = (HFONT)SelectObject(hDC, hFont);
  1099. SetTextColor(hDC, foreColor);
  1101. DrawText(hDC, szText, -1, &rc, DT_CENTER|DT_SINGLELINE);
  1103. SelectObject(hDC, hOldFont);
  1105. if ( hFont != m_hDefGameFont )
  1106. DeleteObject(hFont);
  1108. pSurface->ReleaseDC(hDC);
  1109. }
  1112. SIZE CWHDXGraphicWindow::GetStrLength(LPDIRECTDRAWSURFACE7 pSurface, HFONT hFont, CHAR* szFormat, ...)
  1113. {
  1114. HDC hDC;
  1115. va_list arg;
  1116.     CHAR szBuf[1024];
  1117. SIZE sSize;
  1119. sSize.cx = 0;
  1120. sSize.cy = 0;
  1122. HFONT hOldFont;
  1124. if ( NULL == pSurface )
  1125. pSurface = m_pddsBackBuffer;
  1127.     if ( NULL == pSurface ) return sSize;
  1129. if ( NULL == hFont )
  1130. hFont = m_hDefGameFont;
  1132. HRESULT hr = pSurface->GetDC(&hDC);
  1134. va_start(arg, szFormat);
  1135.     vsprintf(szBuf, szFormat, arg);
  1136.     va_end(arg);
  1138. hOldFont = (HFONT)SelectObject(hDC, hFont);
  1140. GetTextExtentPoint32(hDC,szBuf,strlen(szBuf),&sSize);
  1142. SelectObject(hDC, hOldFont);
  1144. pSurface->ReleaseDC(hDC);
  1146. return sSize;
  1147. }
  1150. /*BOOL CWHDXGraphicWindow::StringDivideLen(INT nDivideLen, INT& nDividedLine, CHAR* szSrc,CDLList<CHAR*>* m_pxpStr)
  1151. {
  1152. CHAR szTmpCheck[MAX_PATH];
  1153. CHAR szResult[MAX_PATH];
  1155. nDividedLine = 1;
  1157. INT nStartLen = 0;
  1158. INT nEndLen = 0;
  1159. INT nResultLen = 0;
  1160. INT nWordCheck = 0;
  1162. if ( szSrc[0] != NULL )
  1163. {
  1164. ZeroMemory(szResult,MAX_PATH);
  1166. for ( INT nCnt = 0; nCnt < (INT)strlen(szSrc); nCnt++)
  1167. {
  1168. ZeroMemory(szTmpCheck, MAX_PATH);
  1169. nEndLen = nCnt+1;
  1171. // 泅犁何盒鳖瘤狼 巩磊凯阑 佬绰促.
  1172. memcpy(&szTmpCheck, &szSrc[nStartLen], nEndLen-nStartLen);
  1173. INT nsLen;
  1174. nsLen = strlen(szTmpCheck);
  1176. // 泅犁鳖瘤 佬绢柯 何盒捞 倾侩承捞甫 逞绢脊阑锭.
  1177. if (nsLen > nDivideLen )
  1178. {
  1179. // 泅犁 2官捞飘 巩磊扼搁. 
  1180. if ( szSrc[nEndLen-1] < 0 )
  1181. {
  1182. // 泅犁 菊俊巩磊啊 2官捞飘 巩磊啊 酒聪扼搁
  1183. if ( !(nWordCheck%2) )
  1184. {
  1185. nStartLen += strlen(szTmpCheck)-1;
  1186. nCnt--;
  1187. CHAR* pszNewLine;
  1188. pszNewLine = new CHAR[nResultLen+1];
  1189. memcpy(pszNewLine,szResult,nResultLen);
  1190. pszNewLine[nResultLen]=NULL;
  1191. m_pxpStr->AddNode(pszNewLine);
  1192. nResultLen = 0;
  1193. nDividedLine++;
  1194. }
  1195. else
  1196. {
  1197. nStartLen += strlen(szTmpCheck)-2;
  1198. nCnt -= 2;
  1199. CHAR* pszNewLine;
  1200. pszNewLine = new CHAR[nResultLen];
  1201. memcpy(pszNewLine,szResult,nResultLen-1);
  1202. pszNewLine[nResultLen-1]=NULL;
  1203. m_pxpStr->AddNode(pszNewLine);
  1204. nResultLen = 0;
  1205. nDividedLine++;
  1206. nWordCheck--;
  1207. }
  1208. }
  1209. // 1官捞飘 巩磊. 
  1210. // 泅犁焊促 茄官捞飘菊何盒鳖瘤父 绊妨秦林搁 等促.
  1211. else
  1212. {
  1213. nStartLen += strlen(szTmpCheck)-1;
  1214. nCnt--;
  1215. CHAR* pszNewLine;
  1216. pszNewLine = new CHAR[nResultLen+1];
  1217. memcpy(pszNewLine,szResult,nResultLen);
  1218. pszNewLine[nResultLen]=NULL;
  1219. m_pxpStr->AddNode(pszNewLine);
  1220. nResultLen=0;
  1221. nDividedLine++;
  1222. }
  1223. }
  1224. else if(szSrc[nEndLen-1]=='n') // 碍力俺青     n栏肺窍搁  Error ????
  1225. {
  1226. nStartLen += strlen(szTmpCheck)-1;
  1227. CHAR* pszNewLine;
  1228. pszNewLine = new CHAR[nResultLen+1];
  1229. memcpy(pszNewLine,szResult,nResultLen);
  1230. pszNewLine[nResultLen]=NULL;
  1231. m_pxpStr->AddNode(pszNewLine);
  1232. nResultLen=0;
  1233. nDividedLine++;
  1234. }
  1235. else
  1236. {
  1237. if ( szSrc[nEndLen-1] < 0 )
  1238. nWordCheck++;
  1240. szResult[nResultLen] = szSrc[nEndLen-1];
  1241. nResultLen++;
  1242. }
  1243. }
  1244. if(nResultLen!=0)
  1245. {
  1246. CHAR* pszNewLine;
  1247. pszNewLine = new CHAR[nResultLen+1];
  1248. memcpy(pszNewLine,szResult,nResultLen);
  1249. pszNewLine[nResultLen]=NULL;
  1250. m_pxpStr->AddNode(pszNewLine);
  1251. nDividedLine++;
  1252. nResultLen=0;
  1253. }
  1254. return TRUE;
  1255. }
  1256. return FALSE;
  1257. }
  1258. */
  1261. BOOL CWHDXGraphicWindow::StringDivide(INT nDivideWidth, INT& nDividedLine, CHAR* szSrc, CHAR* szResult)
  1262. {
  1263. CHAR szTmpCheck[MAX_PATH];
  1265. nDividedLine = 1;
  1267. INT nStartLen = 0;
  1268. INT nEndLen = 0;
  1269. INT nResultLen = 0;
  1271. INT nWordCheck = 0;
  1273. if ( szSrc[0] != NULL )
  1274. {
  1275. ZeroMemory(szResult, MAX_PATH);
  1277. for ( INT nCnt = 0; nCnt < (INT)strlen(szSrc); nCnt++)
  1278. {
  1279. ZeroMemory(szTmpCheck, MAX_PATH);
  1281. nEndLen = nCnt+1;
  1283. // 父距俊 臂磊农扁啊 弥措 臂磊农扁甫 逞绢啊搁 弥措摹肺 嘎苗霖促.
  1284. if ( nEndLen >= MAX_PATH )
  1285. {
  1286. szResult[MAX_PATH-1] = NULL;
  1287. break;
  1288. }
  1290. // 泅犁何盒鳖瘤狼 巩磊凯阑 佬绰促.
  1291. memcpy(&szTmpCheck, &szSrc[nStartLen], nEndLen-nStartLen);
  1293. SIZE sizeLen;
  1294. sizeLen = GetStrLength(NULL, NULL, szTmpCheck);
  1296. // 泅犁鳖瘤 佬绢柯 何盒捞 倾侩承捞甫 逞绢脊阑锭.
  1297. if ( sizeLen.cx > nDivideWidth )
  1298. {
  1299. // 泅犁 2官捞飘 巩磊扼搁. 
  1300. if ( szSrc[nEndLen-1] < 0 )
  1301. {
  1302. // 泅犁 菊俊巩磊啊 2官捞飘 巩磊啊 酒聪扼搁
  1303. if ( !(nWordCheck%2) )
  1304. {
  1305. nStartLen += strlen(szTmpCheck)-1;
  1306. nCnt--;
  1307. szResult[nResultLen] = '`';
  1308. nResultLen++;
  1309. nDividedLine++;
  1310. }
  1311. else
  1312. {
  1313. nStartLen += strlen(szTmpCheck)-2;
  1314. nCnt -= 2;
  1315. szResult[nResultLen-1] = '`';
  1316. nDividedLine++;
  1317. nWordCheck--;
  1318. }
  1319. }
  1320. // 1官捞飘 巩磊. 
  1321. // 泅犁焊促 茄官捞飘菊何盒鳖瘤父 绊妨秦林搁 等促.
  1322. else
  1323. {
  1324. nStartLen += strlen(szTmpCheck)-1;
  1325. nCnt--;
  1326. szResult[nResultLen] = '`';
  1327. nResultLen++;
  1328. nDividedLine++;
  1329. }
  1330. }
  1331. else
  1332. {
  1333. if ( szSrc[nEndLen-1] < 0 )
  1334. nWordCheck++;
  1336. szResult[nResultLen] = szSrc[nEndLen-1];
  1337. nResultLen++;
  1338. }
  1339. }
  1340. return TRUE;
  1341. }
  1342. return FALSE;
  1344. }
  1347. /******************************************************************************************************************
  1349. 窃荐疙 : CWHDXGraphicWindow::GetRGBMaskInfoIN16Bits()
  1351. 累己磊 : 
  1352. 累己老 : 
  1354. 格利   : 
  1355. 涝仿   : LPDIRECTDRAWSURFACE7 pSurface
  1356. 免仿   : DXG_MASKINFO 
  1358. [老磊][荐沥磊] : 荐沥郴侩
  1360. *******************************************************************************************************************/
  1361. DXG_MASKINFO CWHDXGraphicWindow::GetRGBMaskInfoIN16Bits(LPDIRECTDRAWSURFACE7 pSurface)
  1362. {
  1363. DDPIXELFORMAT ddpf;
  1364. DXG_MASKINFO stRGBMaskInfo;
  1366. ZeroMemory(&stRGBMaskInfo, sizeof(DXG_MASKINFO));
  1368. if ( pSurface == NULL ) pSurface = m_pddsBackBuffer;
  1370.     if ( pSurface )
  1371. {
  1372. memset(&ddpf, 0, sizeof(ddpf));
  1373. ddpf.dwSize = sizeof(ddpf);
  1374. ddpf.dwFlags = DDPF_RGB;
  1375. pSurface->GetPixelFormat(&ddpf);
  1377. stRGBMaskInfo.dwRMask = ddpf.dwRBitMask;
  1378. stRGBMaskInfo.dwGMask = ddpf.dwGBitMask;
  1379. stRGBMaskInfo.dwBMask = ddpf.dwBBitMask;
  1381. DWORD dwCnt;
  1382. DWORD dwMask;
  1383. for ( dwCnt = 0, dwMask = ddpf.dwRBitMask; !( dwMask & 1 ); dwCnt++, dwMask >>= 1 );
  1384. stRGBMaskInfo.bRShift = (BYTE) dwCnt;
  1385. for ( dwCnt = 0; ( ( dwMask>>dwCnt ) & 1 ); dwCnt++ );
  1386. stRGBMaskInfo.bRCnt = (BYTE) dwCnt;
  1388. for ( dwCnt = 0, dwMask = ddpf.dwGBitMask; !( dwMask & 1 ); dwCnt++, dwMask >>= 1 );
  1389. stRGBMaskInfo.bGShift = (BYTE) dwCnt;
  1390. for ( dwCnt = 0; ( ( dwMask>>dwCnt ) & 1 ); dwCnt++ );
  1391. stRGBMaskInfo.bGCnt = (BYTE) dwCnt;
  1393. for ( dwCnt = 0, dwMask = ddpf.dwBBitMask; !( dwMask & 1 ); dwCnt++, dwMask >>= 1 );
  1394. stRGBMaskInfo.bBShift = (BYTE) dwCnt;
  1395. for ( dwCnt = 0; ( ( dwMask>>dwCnt ) & 1 ); dwCnt++ );
  1396. stRGBMaskInfo.bBCnt = (BYTE) dwCnt;
  1397. }
  1399. return stRGBMaskInfo;
  1400. }
  1404. ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  1405. // 弊府绰 窃荐甸 葛澜.
  1407. WORD CWHDXGraphicWindow::ConvertColor24To16(COLORREF dwColor)
  1408. {
  1409. WORD wRet;
  1411. INT nRed  = RGB_GETRED(dwColor);
  1412. INT nGreen = RGB_GETGREEN(dwColor);
  1413. INT nBlue   = RGB_GETBLUE(dwColor);
  1415. nRed = (nRed*(1<<m_stBitsMaskInfo.bRCnt))/(1<<8);
  1416. nGreen = (nGreen*(1<<m_stBitsMaskInfo.bGCnt))/(1<<8);
  1417. nBlue = (nBlue*(1<<m_stBitsMaskInfo.bBCnt))/(1<<8);
  1419. wRet = (nRed << m_stBitsMaskInfo.bRShift) | (nGreen << m_stBitsMaskInfo.bGShift) | (nBlue << m_stBitsMaskInfo.bBShift); 
  1420. return wRet;
  1421. }
  1424. /******************************************************************************************************************
  1426. 窃荐疙 : CWHDXGraphicWindow::DrawWithGDI()
  1428. 累己磊 : 
  1429. 累己老 : 
  1431. 格利   : 
  1432. 涝仿   : RECT rc
  1433.          LPDIRECTDRAWSURFACE7 pSurface
  1434.          DWORD dwColor
  1435.          DWORD dwPenStyleFlg
  1436.          BYTE bKind
  1437. 免仿   : HRESULT 
  1439. [老磊][荐沥磊] : 荐沥郴侩
  1441. *******************************************************************************************************************/
  1442. HRESULT CWHDXGraphicWindow::DrawWithGDI(RECT rc, LPDIRECTDRAWSURFACE7 pSurface, DWORD dwColor, BYTE bKind)
  1443. {
  1444. POINT pt;
  1445. HDC hDC;
  1446. HPEN hPen, hOldPen;
  1447. HBRUSH hBrush, hOldBrush;
  1448. HRESULT hr;
  1450. if ( pSurface == NULL )
  1451. {
  1452. pSurface = m_pddsBackBuffer;
  1453. }
  1455. if ( pSurface == NULL )
  1456. return E_FAIL;
  1458. if ( FAILED(hr = pSurface->GetDC(&hDC)) )
  1459. {
  1460. return E_FAIL;
  1461. }
  1463. switch ( bKind )
  1464. {
  1465. case 0:
  1466. {
  1467. hPen = CreatePen(PS_SOLID, NULL, dwColor);
  1469. hOldPen = (HPEN)SelectObject(hDC, hPen);
  1471. MoveToEx(hDC, rc.left, rc.top, &pt);
  1472. LineTo(hDC, rc.right, rc.bottom);
  1474. SelectObject(hDC, hOldPen);
  1475. DeleteObject(hPen);
  1476. }
  1477. break;
  1478. case 1:
  1479. {
  1480. hBrush = CreateSolidBrush(dwColor);
  1482. hOldBrush = (HBRUSH)SelectObject(hDC, hBrush);
  1484. FrameRect(hDC, &rc, hBrush);
  1486. SelectObject(hDC, hOldBrush);
  1487. DeleteObject(hBrush);
  1488. }
  1489. break;
  1490. case 2:
  1491. {
  1492. hBrush = CreateSolidBrush(dwColor);
  1494. hOldBrush = (HBRUSH)SelectObject(hDC, hBrush);
  1496. FillRect(hDC, &rc, hBrush);
  1498. SelectObject(hDC, hOldBrush);
  1499. DeleteObject(hBrush);
  1500. }
  1501. break;
  1502. default:
  1503. break;
  1504. }
  1506. pSurface->ReleaseDC(hDC);
  1508. return S_OK;
  1509. }
  1512. /******************************************************************************************************************
  1514. 窃荐疙 : CWHDXGraphicWindow::DrawSprite()
  1516. 累己磊 : 
  1517. 累己老 : 
  1519. 格利   : 老馆利牢 弊府扁. 茄侨伎究 弊赴促. 胶农赴康开 努府俏, 家胶康开 努府俏
  1520. 涝仿   : INT nX
  1521.          INT nY
  1522.          INT nXSize
  1523.          INT nYSize
  1524.          WORD* pwSrc
  1525. 免仿   : VOID 
  1527. [老磊][荐沥磊] : 荐沥郴侩
  1529. *******************************************************************************************************************/
  1530. BOOL CWHDXGraphicWindow::DrawWithImage(INT nX, INT nY, INT nXSize, INT nYSize, WORD* pwSrc)
  1531. {
  1532. RECT rc;
  1533. DDSURFACEDESC2 ddsd;
  1535. INT nWidth = nXSize;
  1536. INT nHeight = nYSize;
  1537. INT nXOffset = 0;
  1538. INT nYOffset = 0;
  1539. INT nStartX = 0;
  1540. INT nStartY = 0;
  1541. INT nEndX = m_stDisplayInfo.wWidth -1;
  1542. INT nEndY = m_stDisplayInfo.wHeight-1;
  1544. if ( m_pddsBackBuffer != NULL )
  1545. {
  1546. if (nX < nStartX )
  1547. { 
  1548. nXOffset = nStartX - nX;
  1549. nWidth  = nXSize - nXOffset;
  1550. }
  1551. if ( (nX+nXSize-1) > nEndX )
  1552. nWidth  = nEndX - nX - nXOffset + 1;
  1554. if ( nY < nStartY )
  1555. { 
  1556. nYOffset = nStartY - nY;
  1557. nHeight = nYSize - nYOffset;
  1558. }
  1559. if ( (nY+nYSize-1) > nEndY )
  1560. nHeight = nEndY - nY - nYOffset + 1;
  1562. if ( (nWidth > 0) && (nHeight > 0) )
  1563. {
  1564. rc.left = nXOffset;
  1565. rc.right = nXOffset + nWidth;
  1566. rc.top = nYOffset;
  1567. rc.bottom = nYOffset + nHeight;
  1569. ddsd.dwSize = sizeof(DDSURFACEDESC2);
  1570. ddsd.lpSurface = NULL;
  1572. m_pddsBackBuffer->Lock(NULL, &ddsd, DDLOCK_WAIT, NULL);
  1573. if ( !ddsd.lpSurface ) return FALSE;
  1574. WORD* pwdDst;
  1575. pwdDst = (WORD*)ddsd.lpSurface;
  1577. for ( INT y=rc.top ; y < rc.bottom ; y++ )
  1578. {
  1579. for ( INT x=rc.left ; x < rc.right ; x++ )
  1580. {
  1581. if ( pwSrc[y * nXSize + x] != 0 )
  1582. {
  1583. pwdDst[((y+nY) * (ddsd.lPitch >> 1)) + (nX+x)] = pwSrc[y * nXSize + x];
  1584. }
  1585. }
  1586. }
  1588. m_pddsBackBuffer->Unlock(NULL);
  1589. }
  1590. return TRUE;
  1591. }
  1592. return FALSE;
  1593. }
  1596. BOOL CWHDXGraphicWindow::DrawWithImagePerLineClipRgn(INT nX, INT nY, INT nXSize, INT nYSize, WORD* pwSrc, WORD wClipWidth, WORD wClipHeight)
  1597. {
  1598. RECT rc;
  1599. DDSURFACEDESC2 ddsd;
  1601. INT nWidth = nXSize;
  1602. INT nHeight = nYSize;
  1603. INT nXOffset = 0;
  1604. INT nYOffset = 0;
  1605. INT nStartX = 0;
  1606. INT nStartY = 0;
  1607. INT nEndX = wClipWidth  - 1;
  1608. INT nEndY = wClipHeight - 1;
  1610. if ( m_pddsBackBuffer != NULL )
  1611. {
  1612. if (nX < nStartX )
  1613. { 
  1614. nXOffset = nStartX - nX;
  1615. nWidth  = nXSize - nXOffset;
  1616. }
  1617. if ( (nX+nXSize-1) > nEndX )
  1618. nWidth  = nEndX - nX - nXOffset + 1;
  1619. if ( nY < nStartY )
  1620. { 
  1621. nYOffset = nStartY - nY;
  1622. nHeight = nYSize - nYOffset;
  1623. }
  1624. if ( (nY+nYSize-1) > nEndY )
  1625. nHeight = nEndY - nY - nYOffset + 1;
  1627. if ( (nWidth > 0) && (nHeight > 0) )
  1628. {
  1629. rc.left = nXOffset;
  1630. rc.right = nXOffset + nWidth;
  1631. rc.top = nYOffset;
  1632. rc.bottom = nYOffset + nHeight;
  1634. ddsd.dwSize = sizeof(DDSURFACEDESC2);
  1635. ddsd.lpSurface = NULL;
  1637. m_pddsBackBuffer->Lock(NULL, &ddsd, DDLOCK_WAIT, NULL);
  1638. if ( !ddsd.lpSurface ) return FALSE;
  1639. WORD* pwdDst;
  1640. pwdDst = (WORD*)ddsd.lpSurface;
  1642. for ( INT y=rc.top ; y < rc.bottom ; y++ )
  1643. {
  1644. memcpy(&pwdDst[((y+nY) * (ddsd.lPitch >> 1)) + (nX + rc.left)], &pwSrc[y * nXSize + rc.left], (rc.right-rc.left)*2);
  1645. }
  1647. m_pddsBackBuffer->Unlock(NULL);
  1648. }
  1649. return TRUE;
  1650. }
  1651. return FALSE;
  1652. }
  1656. /******************************************************************************************************************
  1658. 窃荐疙 : CWHDXGraphicWindow::DrawWithSurface()
  1660. 累己磊 : 
  1661. 累己老 : 
  1663. 格利   : 
  1664. 涝仿   : LPDIRECTDRAWSURFACE7 pddsSrc
  1665.          RECT* prcSrc
  1666.          RECT* prcDst
  1667. 免仿   : BOOL 
  1669. [老磊][荐沥磊] : 荐沥郴侩
  1671. *******************************************************************************************************************/
  1672. BOOL CWHDXGraphicWindow::DrawWithSurface(INT nX, INT nY, INT nXSize, INT nYSize, LPDIRECTDRAWSURFACE7 pddsSrc)
  1673. {
  1674. RECT rc;
  1675. RECT rcDst;
  1676. INT nXOffset = 0;
  1677. INT nYOffset = 0;
  1678. INT nWidth = nXSize;
  1679. INT nHeight = nYSize;
  1680. INT nStartX = 0;
  1681. INT nStartY = 0;
  1683. INT nEndX = m_stDisplayInfo.wWidth -1;
  1684. INT nEndY = m_stDisplayInfo.wHeight-1;;
  1687. if ( m_pddsBackBuffer != NULL )
  1688. {
  1689. if (nX < nStartX )
  1690. { 
  1691. nXOffset = nStartX - nX;
  1692. nWidth = nXSize - nXOffset;
  1693. }
  1694. if ( (nX+nXSize-1) > nEndX )
  1695. nWidth = nEndX - nX - nXOffset + 1;
  1696. if ( nY < nStartY )
  1697. { 
  1698. nYOffset = nStartY - nY;
  1699. nHeight = nYSize - nYOffset;
  1700. }
  1701. if ( (nY+nYSize-1) > nEndY )
  1702. nHeight = nEndY - nY - nYOffset + 1;
  1704. if ( (nWidth > 0) && (nHeight > 0) )
  1705. {
  1706. rc.left  = nXOffset;
  1707. rc.right  = nXOffset+nWidth;
  1708. rc.top  = nYOffset;
  1709. rc.bottom  = nYOffset+nHeight;
  1711. rcDst.left  = rc.left+nX;
  1712. rcDst.top  = rc.top+nY;
  1713. rcDst.right  = rc.right+nX;
  1714. rcDst.bottom = rc.bottom+nY;
  1716. m_pddsBackBuffer->Blt(&rcDst, pddsSrc, &rc, DDBLT_WAIT|DDBLT_KEYSRC, NULL);
  1717. }
  1718. return TRUE;
  1719. }
  1720. return FALSE;
  1721. }
  1724. BOOL CWHDXGraphicWindow::DrawWithImageForCompMemToMem(INT nX, INT nY, INT nXSize, INT nYSize, WORD* pwSrc, INT nDstXSize, INT nDstYSize, WORD* pwDst, WORD wChooseColor1, WORD wChooseColor2)
  1725. {
  1726. RECT rc;
  1728. INT nWidth = nXSize;
  1729. INT nHeight = nYSize;
  1730. INT nXOffset = 0;
  1731. INT nYOffset = 0;
  1732. INT nStartX = 0;
  1733. INT nStartY = 0;
  1734. INT nEndX = nDstXSize - 1;
  1735. INT nEndY = nDstYSize - 1;
  1737. if ( pwDst != NULL )
  1738. {
  1739. if (nX < nStartX )
  1740. { 
  1741. nXOffset = nStartX - nX;
  1742. nWidth = nXSize - nXOffset;
  1743. }
  1744. if ( (nX+nXSize-1) > nEndX )
  1745. nWidth = nEndX - nX - nXOffset + 1;
  1746. if ( nY < nStartY ) { 
  1747. nYOffset = nStartY - nY;
  1748. nHeight = nYSize - nYOffset;
  1749. }
  1750. if ( (nY+nYSize-1) > nEndY )
  1751. nHeight = nEndY - nY - nYOffset + 1;
  1753. if ( (nWidth > 0) && (nHeight > 0) )
  1754. {
  1755. rc.left = nXOffset;
  1756. rc.right = nXOffset+nWidth;
  1757. rc.top = nYOffset;
  1758. rc.bottom = nYOffset+nHeight;
  1760. INT nWidthStart = 0;
  1761. INT nWidthEnd = 0;
  1762. INT nCurrWidth  = 0;
  1763. INT nCntCopyWord = 0;
  1764. INT nYCnt =0;
  1765. INT nLastWidth = 0;
  1767. FLOAT rBlueRate, rGreenRate, bRedRate;
  1768. BYTE  bRedSrc, bGreenSrc, bBlueSrc;
  1769. BYTE  bRedWantedColor, bGreenWantedColor, bBlueWantedColor;
  1770. WORD  wPixel;
  1772. // y绵 努府俏.
  1773. for ( nYCnt=0 ; nYCnt < rc.top ; nYCnt++ )
  1774. {
  1775. nWidthEnd += pwSrc[nWidthStart];
  1776. nWidthStart++;
  1777. nWidthEnd++;
  1778. nWidthStart = nWidthEnd;
  1779. }
  1781. // y绵俊 措秦辑 角力肺 风俏矫懦 Count父阑 沥茄促.
  1782. for ( nYCnt=rc.top ; nYCnt < rc.bottom ; nYCnt++ )
  1783. {
  1784. // 茄扼牢狼 辨捞甫 掘绢柯促.(窜困绰 况靛)
  1785. nWidthEnd += pwSrc[nWidthStart];
  1786. nWidthStart++;
  1788. // 扼牢狼 辨捞父怒 拳搁俊 谎妨霖促.
  1789. for ( INT x = nWidthStart; x < nWidthEnd ; )
  1790. {
  1791. if ( pwSrc[x] == 0xC0 )
  1792. {
  1793. x++;
  1794. nCntCopyWord = pwSrc[x];
  1795. x++;
  1796. nCurrWidth += nCntCopyWord;
  1797. }
  1798. else if ( pwSrc[x] == 0xC1 )
  1799. {
  1800. x++;
  1801. nCntCopyWord = pwSrc[x];
  1802. x++;
  1804. nLastWidth = nCurrWidth;
  1805. nCurrWidth += nCntCopyWord;
  1807. if ( rc.left > nCurrWidth || rc.right < nLastWidth )
  1808. {
  1809. x += nCntCopyWord;
  1810. }
  1811. else
  1812. {
  1813. // rc.left痢阑 扁霖栏肺 墨乔且 康开捞 吧赴 版快.
  1814. if ( nLastWidth < rc.left && rc.left <= nCurrWidth )
  1815. {
  1816. x += (rc.left-nLastWidth);
  1817. memcpy(&pwDst[((nYCnt+nY) * nDstXSize) + (rc.left+nX)], &pwSrc[x], sizeof(WORD)*(nCurrWidth-rc.left));
  1818. x += (nCurrWidth-rc.left);
  1819. }
  1820. // rc.right痢阑 扁霖栏肺 墨乔且 康开捞 吧赴 版快.
  1821. else if ( nLastWidth <= rc.right && rc.right < nCurrWidth )
  1822. {
  1823. memcpy(&pwDst[((nYCnt+nY) * nDstXSize) + (nLastWidth+nX)], &pwSrc[x], sizeof(WORD)*(rc.right-nLastWidth));
  1824. x += nCntCopyWord;
  1825. }
  1826. else
  1827. {
  1828. memcpy(&pwDst[((nYCnt+nY) * nDstXSize) + (nLastWidth+nX)], &pwSrc[x], sizeof(WORD)*nCntCopyWord);
  1829. x += nCntCopyWord;
  1830. }
  1831. }
  1832. }
  1833. else if ( pwSrc[x] == 0xC2 || pwSrc[x] == 0xC3 )
  1834. {
  1835. WORD wDyingKind, wChooseColor;
  1836. wDyingKind = pwSrc[x];
  1837. switch ( wDyingKind )
  1838. {
  1839. case 0xC2: 
  1840. wChooseColor = wChooseColor1;
  1841. break;
  1842. case 0xC3: 
  1843. wChooseColor = wChooseColor2;
  1844. break;
  1845. }
  1846. x++;
  1847. nCntCopyWord = pwSrc[x];
  1848. x++;
  1850. nLastWidth = nCurrWidth;
  1851. nCurrWidth += nCntCopyWord;
  1853. if ( rc.left > nCurrWidth || rc.right < nLastWidth )
  1854. {
  1855. x += nCntCopyWord;
  1856. }
  1857. else
  1858. {
  1859. // rc.left痢阑 扁霖栏肺 墨乔且 康开捞 吧赴 版快.
  1860. if ( nLastWidth < rc.left && rc.left <= nCurrWidth )
  1861. {
  1862. x += (rc.left-nLastWidth);
  1863. for ( INT nCheck = 0; nCheck < nCurrWidth-rc.left; nCheck++ )
  1864. {
  1865. wPixel   = wChooseColor;
  1866. bBlueWantedColor  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  1867. bGreenWantedColor = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  1868. bRedWantedColor   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  1870. wPixel   = pwSrc[x+nCheck];
  1871. bBlueSrc  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  1872. bGreenSrc = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  1873. bRedSrc   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  1875. rBlueRate = (FLOAT)((FLOAT)bBlueSrc / (FLOAT)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift));
  1876. rGreenRate = (FLOAT)((FLOAT)bGreenSrc / (FLOAT)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift));
  1877. bRedRate = (FLOAT)((FLOAT)bRedSrc / (FLOAT)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift));
  1879. bBlueWantedColor = (BYTE)(((FLOAT)bBlueWantedColor*rBlueRate));
  1880. bGreenWantedColor = (BYTE)(((FLOAT)bGreenWantedColor*rGreenRate));
  1881. bRedWantedColor = (BYTE)(((FLOAT)bRedWantedColor*bRedRate));
  1883. if ( bBlueWantedColor > (m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift) )
  1884. bBlueWantedColor = (BYTE)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift);
  1885. if ( bGreenWantedColor > (m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift) )
  1886. bGreenWantedColor = (BYTE)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift);
  1887. if ( bRedWantedColor > (m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift) )
  1888. bRedWantedColor = (BYTE)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift);
  1890. pwDst[((nYCnt+nY) * nDstXSize) + (nLastWidth+nX+nCheck)] = ((bRedWantedColor  <<m_stBitsMaskInfo.bRShift) |
  1891.     (bGreenWantedColor<<m_stBitsMaskInfo.bGShift) |
  1892. (bBlueWantedColor <<m_stBitsMaskInfo.bBShift));
  1893. }
  1894. x += (nCurrWidth-rc.left);
  1895. }
  1896. // rc.right痢阑 扁霖栏肺 墨乔且 康开捞 吧赴 版快.
  1897. else if ( nLastWidth <= rc.right && rc.right < nCurrWidth )
  1898. {
  1899. for ( INT nCheck = 0; nCheck < rc.right-nLastWidth; nCheck++ )
  1900. {
  1901. wPixel   = wChooseColor;
  1902. bBlueWantedColor  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  1903. bGreenWantedColor = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  1904. bRedWantedColor   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  1906. wPixel   = pwSrc[x+nCheck];
  1907. bBlueSrc  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  1908. bGreenSrc = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  1909. bRedSrc   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  1911. rBlueRate = (FLOAT)((FLOAT)bBlueSrc / (FLOAT)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift));
  1912. rGreenRate = (FLOAT)((FLOAT)bGreenSrc / (FLOAT)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift));
  1913. bRedRate = (FLOAT)((FLOAT)bRedSrc / (FLOAT)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift));
  1915. bBlueWantedColor = (BYTE)(((FLOAT)bBlueWantedColor*rBlueRate));
  1916. bGreenWantedColor = (BYTE)(((FLOAT)bGreenWantedColor*rGreenRate));
  1917. bRedWantedColor = (BYTE)(((FLOAT)bRedWantedColor*bRedRate));
  1919. if ( bBlueWantedColor > (m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift) )
  1920. bBlueWantedColor = (BYTE)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift);
  1921. if ( bGreenWantedColor > (m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift) )
  1922. bGreenWantedColor = (BYTE)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift);
  1923. if ( bRedWantedColor > (m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift) )
  1924. bRedWantedColor = (BYTE)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift);
  1926. pwDst[((nYCnt+nY) * nDstXSize) + (nLastWidth+nX+nCheck)] = ((bRedWantedColor  <<m_stBitsMaskInfo.bRShift) |
  1927. (bGreenWantedColor<<m_stBitsMaskInfo.bGShift) |
  1928. (bBlueWantedColor <<m_stBitsMaskInfo.bBShift));
  1929. }
  1930. x += nCntCopyWord;
  1931. }
  1932. else
  1933. {
  1934. for ( INT nCheck = 0; nCheck < nCntCopyWord; nCheck++ )
  1935. {
  1936. wPixel   = wChooseColor;
  1937. bBlueWantedColor  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  1938. bGreenWantedColor = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  1939. bRedWantedColor   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  1941. wPixel   = pwSrc[x+nCheck];
  1942. bBlueSrc  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  1943. bGreenSrc = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  1944. bRedSrc   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  1946. rBlueRate = (FLOAT)((FLOAT)bBlueSrc / (FLOAT)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift));
  1947. rGreenRate = (FLOAT)((FLOAT)bGreenSrc / (FLOAT)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift));
  1948. bRedRate = (FLOAT)((FLOAT)bRedSrc / (FLOAT)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift));
  1950. bBlueWantedColor = (BYTE)(((FLOAT)bBlueWantedColor*rBlueRate));
  1951. bGreenWantedColor = (BYTE)(((FLOAT)bGreenWantedColor*rGreenRate));
  1952. bRedWantedColor = (BYTE)(((FLOAT)bRedWantedColor*bRedRate));
  1954. if ( bBlueWantedColor > (m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift) )
  1955. bBlueWantedColor = (BYTE)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift);
  1956. if ( bGreenWantedColor > (m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift) )
  1957. bGreenWantedColor = (BYTE)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift);
  1958. if ( bRedWantedColor > (m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift) )
  1959. bRedWantedColor = (BYTE)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift);
  1961. pwDst[((nYCnt+nY) * nDstXSize) + (nLastWidth+nX+nCheck)] = ((bRedWantedColor  <<m_stBitsMaskInfo.bRShift) |
  1962. (bGreenWantedColor<<m_stBitsMaskInfo.bGShift) |
  1963. (bBlueWantedColor <<m_stBitsMaskInfo.bBShift));
  1964. }
  1965. x += nCntCopyWord;
  1966. }
  1967. }
  1968. }
  1969. }
  1970. // 扼牢狼 场阑 促澜 扼牢狼 矫累栏肺 颗败霖促.
  1971. nWidthEnd++;
  1973. nWidthStart = nWidthEnd;
  1974. nCurrWidth = 0;
  1975. }
  1976. }
  1978. m_pddsBackBuffer->Unlock(NULL);
  1979. return TRUE;
  1980. }
  1981. return FALSE;
  1982. }
  1985. BOOL CWHDXGraphicWindow::DrawWithImageForComp(INT nX, INT nY, RECT rcSrc, WORD* pwSrc, WORD wChooseColor1, WORD wChooseColor2)
  1986. {
  1987. RECT rc;
  1988. DDSURFACEDESC2 ddsd;
  1990. INT nWidth = rcSrc.right-rcSrc.left;
  1991. INT nHeight = rcSrc.bottom-rcSrc.top;
  1992. INT nXOffset = rcSrc.left;
  1993. INT nYOffset = rcSrc.top;
  1994. INT nStartX = 0;
  1995. INT nStartY = 0;
  1996. INT nEndX = m_stDisplayInfo.wWidth -1;
  1997. INT nEndY = m_stDisplayInfo.wHeight-1;
  1999. if ( m_pddsBackBuffer != NULL )
  2000. {
  2001. if (nX < nStartX )
  2002. { 
  2003. nXOffset += nStartX - nX;
  2004. nWidth  = rcSrc.right - nXOffset;
  2005. }
  2006. if ( (nX+rcSrc.right-rcSrc.left-1) > nEndX )
  2007. nWidth = nEndX - nX - nXOffset + 1;
  2008. if ( nY < nStartY )
  2009. { 
  2010. nYOffset += nStartY - nY;
  2011. nHeight  = rcSrc.bottom - nYOffset;
  2012. }
  2013. if ( (nY+rcSrc.bottom-rcSrc.top-1) > nEndY )
  2014. nHeight = nEndY - nY - nYOffset + 1;
  2017. if ( (nWidth > 0) && (nHeight > 0) )
  2018. {
  2019. rc.left = nXOffset;
  2020. rc.right = nXOffset+nWidth;
  2021. rc.top = nYOffset;
  2022. rc.bottom = nYOffset+nHeight;
  2024. ddsd.dwSize = sizeof(DDSURFACEDESC2);
  2025. ddsd.lpSurface = NULL;
  2027. m_pddsBackBuffer->Lock(NULL, &ddsd, DDLOCK_WAIT, NULL);
  2028. if ( !ddsd.lpSurface ) return FALSE;
  2029. WORD* pwdDst;
  2030. pwdDst = (WORD*)ddsd.lpSurface;
  2032. INT nWidthStart = 0;
  2033. INT nWidthEnd = 0;
  2034. INT nCurrWidth  = 0;
  2035. INT nCntCopyWord = 0;
  2036. INT nYCnt =0;
  2037. INT nLastWidth = 0;
  2039. FLOAT rBlueRate, rGreenRate, bRedRate;
  2040. BYTE  bRedSrc, bGreenSrc, bBlueSrc;
  2041. BYTE  bRedWantedColor, bGreenWantedColor, bBlueWantedColor;
  2042. WORD  wPixel;
  2044. // y绵 努府俏.
  2045. for ( nYCnt=0 ; nYCnt < rc.top ; nYCnt++ )
  2046. {
  2047. nWidthEnd += pwSrc[nWidthStart];
  2048. nWidthStart++;
  2049. nWidthEnd++;
  2050. nWidthStart = nWidthEnd;
  2051. }
  2053. // y绵俊 措秦辑 角力肺 风俏矫懦 Count父阑 沥茄促.
  2054. for ( nYCnt=rc.top ; nYCnt < rc.bottom ; nYCnt++ )
  2055. {
  2056. // 茄扼牢狼 辨捞甫 掘绢柯促.(窜困绰 况靛)
  2057. nWidthEnd += pwSrc[nWidthStart];
  2058. nWidthStart++;
  2060. // 扼牢狼 辨捞父怒 拳搁俊 谎妨霖促.
  2061. for ( INT x = nWidthStart; x < nWidthEnd ; )
  2062. {
  2063. if ( pwSrc[x] == 0xC0 )
  2064. {
  2065. x++;
  2066. nCntCopyWord = pwSrc[x];
  2067. x++;
  2068. nCurrWidth += nCntCopyWord;
  2069. }
  2070. else if ( pwSrc[x] == 0xC1 )
  2071. {
  2072. x++;
  2073. nCntCopyWord = pwSrc[x];
  2074. x++;
  2076. nLastWidth = nCurrWidth;
  2077. nCurrWidth += nCntCopyWord;
  2079. if ( rc.left > nCurrWidth || rc.right < nLastWidth )
  2080. {
  2081. x += nCntCopyWord;
  2082. }
  2083. else
  2084. {
  2085. // rc.left痢阑 扁霖栏肺 墨乔且 康开捞 吧赴 版快.
  2086. if ( nLastWidth < rc.left && rc.left <= nCurrWidth )
  2087. {
  2088. x += (rc.left-nLastWidth);
  2089. memcpy(&pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (rc.left+nX)], &pwSrc[x], sizeof(WORD)*(nCurrWidth-rc.left));
  2090. x += (nCurrWidth-rc.left);
  2091. }
  2092. // rc.right痢阑 扁霖栏肺 墨乔且 康开捞 吧赴 版快.
  2093. else if ( nLastWidth <= rc.right && rc.right < nCurrWidth )
  2094. {
  2095. memcpy(&pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (nLastWidth+nX)], &pwSrc[x], sizeof(WORD)*(rc.right-nLastWidth));
  2096. x += nCntCopyWord;
  2097. }
  2098. else
  2099. {
  2100. memcpy(&pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (nLastWidth+nX)], &pwSrc[x], sizeof(WORD)*nCntCopyWord);
  2101. x += nCntCopyWord;
  2102. }
  2103. }
  2104. }
  2105. else if ( pwSrc[x] == 0xC2 || pwSrc[x] == 0xC3 )
  2106. {
  2107. WORD wDyingKind, wChooseColor;
  2108. wDyingKind = pwSrc[x];
  2109. switch ( wDyingKind )
  2110. {
  2111. case 0xC2: 
  2112. wChooseColor = wChooseColor1;
  2113. break;
  2114. case 0xC3: 
  2115. wChooseColor = wChooseColor2;
  2116. break;
  2117. }
  2118. x++;
  2119. nCntCopyWord = pwSrc[x];
  2120. x++;
  2122. nLastWidth = nCurrWidth;
  2123. nCurrWidth += nCntCopyWord;
  2125. if ( rc.left > nCurrWidth || rc.right < nLastWidth )
  2126. {
  2127. x += nCntCopyWord;
  2128. }
  2129. else
  2130. {
  2131. // rc.left痢阑 扁霖栏肺 墨乔且 康开捞 吧赴 版快.
  2132. if ( nLastWidth < rc.left && rc.left <= nCurrWidth )
  2133. {
  2134. x += (rc.left-nLastWidth);
  2135. for ( INT nCheck = 0; nCheck < nCurrWidth-rc.left; nCheck++ )
  2136. {
  2137. wPixel   = wChooseColor;
  2138. bBlueWantedColor  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  2139. bGreenWantedColor = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  2140. bRedWantedColor   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  2142. wPixel   = pwSrc[x+nCheck];
  2143. bBlueSrc  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  2144. bGreenSrc = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  2145. bRedSrc   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  2147. rBlueRate = (FLOAT)((FLOAT)bBlueSrc / (FLOAT)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift));
  2148. rGreenRate = (FLOAT)((FLOAT)bGreenSrc / (FLOAT)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift));
  2149. bRedRate = (FLOAT)((FLOAT)bRedSrc / (FLOAT)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift));
  2151. bBlueWantedColor = (BYTE)(((FLOAT)bBlueWantedColor*rBlueRate));
  2152. bGreenWantedColor = (BYTE)(((FLOAT)bGreenWantedColor*rGreenRate));
  2153. bRedWantedColor = (BYTE)(((FLOAT)bRedWantedColor*bRedRate));
  2155. if ( bBlueWantedColor > (m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift) )
  2156. bBlueWantedColor = (BYTE)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift);
  2157. if ( bGreenWantedColor > (m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift) )
  2158. bGreenWantedColor = (BYTE)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift);
  2159. if ( bRedWantedColor > (m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift) )
  2160. bRedWantedColor = (BYTE)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift);
  2162. pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (nLastWidth+nX+nCheck)] = ((bRedWantedColor  <<m_stBitsMaskInfo.bRShift) |
  2163.   (bGreenWantedColor<<m_stBitsMaskInfo.bGShift) |
  2164.   (bBlueWantedColor <<m_stBitsMaskInfo.bBShift));
  2165. }
  2166. x += (nCurrWidth-rc.left);
  2167. }
  2168. // rc.right痢阑 扁霖栏肺 墨乔且 康开捞 吧赴 版快.
  2169. else if ( nLastWidth <= rc.right && rc.right < nCurrWidth )
  2170. {
  2171. for ( INT nCheck = 0; nCheck < rc.right-nLastWidth; nCheck++ )
  2172. {
  2173. wPixel   = wChooseColor;
  2174. bBlueWantedColor  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  2175. bGreenWantedColor = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  2176. bRedWantedColor   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  2178. wPixel   = pwSrc[x+nCheck];
  2179. bBlueSrc  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  2180. bGreenSrc = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  2181. bRedSrc   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  2183. rBlueRate = (FLOAT)((FLOAT)bBlueSrc / (FLOAT)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift));
  2184. rGreenRate = (FLOAT)((FLOAT)bGreenSrc / (FLOAT)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift));
  2185. bRedRate = (FLOAT)((FLOAT)bRedSrc / (FLOAT)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift));
  2187. bBlueWantedColor = (BYTE)(((FLOAT)bBlueWantedColor*rBlueRate));
  2188. bGreenWantedColor = (BYTE)(((FLOAT)bGreenWantedColor*rGreenRate));
  2189. bRedWantedColor = (BYTE)(((FLOAT)bRedWantedColor*bRedRate));
  2191. if ( bBlueWantedColor > (m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift) )
  2192. bBlueWantedColor = (BYTE)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift);
  2193. if ( bGreenWantedColor > (m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift) )
  2194. bGreenWantedColor = (BYTE)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift);
  2195. if ( bRedWantedColor > (m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift) )
  2196. bRedWantedColor = (BYTE)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift);
  2198. pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (nLastWidth+nX+nCheck)] = ((bRedWantedColor  <<m_stBitsMaskInfo.bRShift) |
  2199.   (bGreenWantedColor<<m_stBitsMaskInfo.bGShift) |
  2200.   (bBlueWantedColor <<m_stBitsMaskInfo.bBShift));
  2201. }
  2202. x += nCntCopyWord;
  2203. }
  2204. else
  2205. {
  2206. for ( INT nCheck = 0; nCheck < nCntCopyWord; nCheck++ )
  2207. {
  2208. wPixel   = wChooseColor;
  2209. bBlueWantedColor  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  2210. bGreenWantedColor = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  2211. bRedWantedColor   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  2213. wPixel   = pwSrc[x+nCheck];
  2214. bBlueSrc  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  2215. bGreenSrc = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  2216. bRedSrc   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  2218. rBlueRate = (FLOAT)((FLOAT)bBlueSrc / (FLOAT)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift));
  2219. rGreenRate = (FLOAT)((FLOAT)bGreenSrc / (FLOAT)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift));
  2220. bRedRate = (FLOAT)((FLOAT)bRedSrc / (FLOAT)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift));
  2222. bBlueWantedColor = (BYTE)(((FLOAT)bBlueWantedColor*rBlueRate));
  2223. bGreenWantedColor = (BYTE)(((FLOAT)bGreenWantedColor*rGreenRate));
  2224. bRedWantedColor = (BYTE)(((FLOAT)bRedWantedColor*bRedRate));
  2226. if ( bBlueWantedColor > (m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift) )
  2227. bBlueWantedColor = (BYTE)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift);
  2228. if ( bGreenWantedColor > (m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift) )
  2229. bGreenWantedColor = (BYTE)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift);
  2230. if ( bRedWantedColor > (m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift) )
  2231. bRedWantedColor = (BYTE)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift);
  2233. pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (nLastWidth+nX+nCheck)] = ((bRedWantedColor  <<m_stBitsMaskInfo.bRShift) |
  2234.   (bGreenWantedColor<<m_stBitsMaskInfo.bGShift) |
  2235.     (bBlueWantedColor <<m_stBitsMaskInfo.bBShift));
  2236. }
  2237. x += nCntCopyWord;
  2238. }
  2239. }
  2240. }
  2241. }
  2242. // 扼牢狼 场阑 促澜 扼牢狼 矫累栏肺 颗败霖促.
  2243. nWidthEnd++;
  2245. nWidthStart = nWidthEnd;
  2246. nCurrWidth = 0;
  2247. }
  2248. }
  2250. m_pddsBackBuffer->Unlock(NULL);
  2251. return TRUE;
  2252. }
  2253. return FALSE;
  2254. }
  2257. BOOL CWHDXGraphicWindow::DrawWithImageForComp(INT nX, INT nY, INT nXSize, INT nYSize, WORD* pwSrc, WORD wChooseColor1, WORD wChooseColor2)
  2258. {
  2259. RECT rc;
  2260. DDSURFACEDESC2 ddsd;
  2262. INT nWidth = nXSize;
  2263. INT nHeight = nYSize;
  2264. INT nXOffset = 0;
  2265. INT nYOffset = 0;
  2266. INT nStartX = 0;
  2267. INT nStartY = 0;
  2268. INT nEndX = m_stDisplayInfo.wWidth -1;
  2269. INT nEndY = m_stDisplayInfo.wHeight-1;
  2271. if ( m_pddsBackBuffer != NULL )
  2272. {
  2273. if (nX < nStartX )
  2274. { 
  2275. nXOffset = nStartX - nX;
  2276. nWidth = nXSize - nXOffset;
  2277. }
  2278. if ( (nX+nXSize-1) > nEndX )
  2279. nWidth = nEndX - nX - nXOffset + 1;
  2280. if ( nY < nStartY )
  2281. { 
  2282. nYOffset = nStartY - nY;
  2283. nHeight = nYSize - nYOffset;
  2284. }
  2285. if ( (nY+nYSize-1) > nEndY )
  2286. nHeight = nEndY - nY - nYOffset + 1;
  2288. if ( (nWidth > 0) && (nHeight > 0) )
  2289. {
  2290. rc.left = nXOffset;
  2291. rc.right = nXOffset+nWidth;
  2292. rc.top = nYOffset;
  2293. rc.bottom = nYOffset+nHeight;
  2295. ddsd.dwSize = sizeof(DDSURFACEDESC2);
  2296. ddsd.lpSurface = NULL;
  2298. m_pddsBackBuffer->Lock(NULL, &ddsd, DDLOCK_WAIT, NULL);
  2299. if ( !ddsd.lpSurface ) return FALSE;
  2300. WORD* pwdDst;
  2301. pwdDst = (WORD*)ddsd.lpSurface;
  2303. INT nWidthStart = 0;
  2304. INT nWidthEnd = 0;
  2305. INT nCurrWidth  = 0;
  2306. INT nCntCopyWord = 0;
  2307. INT nYCnt =0;
  2308. INT nLastWidth = 0;
  2310. FLOAT rBlueRate, rGreenRate, bRedRate;
  2311. BYTE  bRedSrc, bGreenSrc, bBlueSrc;
  2312. BYTE  bRedWantedColor, bGreenWantedColor, bBlueWantedColor;
  2313. WORD  wPixel;
  2315. // y绵 努府俏.
  2316. for ( nYCnt=0 ; nYCnt < rc.top ; nYCnt++ )
  2317. {
  2318. nWidthEnd += pwSrc[nWidthStart];
  2319. nWidthStart++;
  2320. nWidthEnd++;
  2321. nWidthStart = nWidthEnd;
  2322. }
  2324. // y绵俊 措秦辑 角力肺 风俏矫懦 Count父阑 沥茄促.
  2325. for ( nYCnt=rc.top ; nYCnt < rc.bottom ; nYCnt++ )
  2326. {
  2327. // 茄扼牢狼 辨捞甫 掘绢柯促.(窜困绰 况靛)
  2328. nWidthEnd += pwSrc[nWidthStart];
  2329. nWidthStart++;
  2331. // 扼牢狼 辨捞父怒 拳搁俊 谎妨霖促.
  2332. for ( INT x = nWidthStart; x < nWidthEnd ; )
  2333. {
  2334. if ( pwSrc[x] == 0xC0 )
  2335. {
  2336. x++;
  2337. nCntCopyWord = pwSrc[x];
  2338. x++;
  2339. nCurrWidth += nCntCopyWord;
  2340. }
  2341. else if ( pwSrc[x] == 0xC1 )
  2342. {
  2343. x++;
  2344. nCntCopyWord = pwSrc[x];
  2345. x++;
  2347. nLastWidth = nCurrWidth;
  2348. nCurrWidth += nCntCopyWord;
  2350. if ( rc.left > nCurrWidth || rc.right < nLastWidth )
  2351. {
  2352. x += nCntCopyWord;
  2353. }
  2354. else
  2355. {
  2356. // rc.left痢阑 扁霖栏肺 墨乔且 康开捞 吧赴 版快.
  2357. if ( nLastWidth < rc.left && rc.left <= nCurrWidth )
  2358. {
  2359. x += (rc.left-nLastWidth);
  2360. memcpy(&pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (rc.left+nX)], &pwSrc[x], sizeof(WORD)*(nCurrWidth-rc.left));
  2361. x += (nCurrWidth-rc.left);
  2362. }
  2363. // rc.right痢阑 扁霖栏肺 墨乔且 康开捞 吧赴 版快.
  2364. else if ( nLastWidth <= rc.right && rc.right < nCurrWidth )
  2365. {
  2366. memcpy(&pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (nLastWidth+nX)], &pwSrc[x], sizeof(WORD)*(rc.right-nLastWidth));
  2367. x += nCntCopyWord;
  2368. }
  2369. else
  2370. {
  2371. memcpy(&pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (nLastWidth+nX)], &pwSrc[x], sizeof(WORD)*nCntCopyWord);
  2372. x += nCntCopyWord;
  2373. }
  2374. }
  2375. }
  2376. else if ( pwSrc[x] == 0xC2 || pwSrc[x] == 0xC3 )
  2377. {
  2378. WORD wDyingKind, wChooseColor;
  2379. wDyingKind = pwSrc[x];
  2380. switch ( wDyingKind )
  2381. {
  2382. case 0xC2: 
  2383. wChooseColor = wChooseColor1;
  2384. break;
  2385. case 0xC3: 
  2386. wChooseColor = wChooseColor2;
  2387. break;
  2388. }
  2389. x++;
  2390. nCntCopyWord = pwSrc[x];
  2391. x++;
  2393. nLastWidth = nCurrWidth;
  2394. nCurrWidth += nCntCopyWord;
  2396. if ( rc.left > nCurrWidth || rc.right < nLastWidth )
  2397. {
  2398. x += nCntCopyWord;
  2399. }
  2400. else
  2401. {
  2402. // rc.left痢阑 扁霖栏肺 墨乔且 康开捞 吧赴 版快.
  2403. if ( nLastWidth < rc.left && rc.left <= nCurrWidth )
  2404. {
  2405. x += (rc.left-nLastWidth);
  2406. for ( INT nCheck = 0; nCheck < nCurrWidth-rc.left; nCheck++ )
  2407. {
  2408. wPixel   = wChooseColor;
  2409. bBlueWantedColor  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  2410. bGreenWantedColor = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  2411. bRedWantedColor   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  2413. wPixel   = pwSrc[x+nCheck];
  2414. bBlueSrc  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  2415. bGreenSrc = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  2416. bRedSrc   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  2418. rBlueRate = (FLOAT)((FLOAT)bBlueSrc / (FLOAT)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift));
  2419. rGreenRate = (FLOAT)((FLOAT)bGreenSrc / (FLOAT)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift));
  2420. bRedRate = (FLOAT)((FLOAT)bRedSrc / (FLOAT)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift));
  2422. bBlueWantedColor = (BYTE)(((FLOAT)bBlueWantedColor*rBlueRate));
  2423. bGreenWantedColor = (BYTE)(((FLOAT)bGreenWantedColor*rGreenRate));
  2424. bRedWantedColor = (BYTE)(((FLOAT)bRedWantedColor*bRedRate));
  2426. if ( bBlueWantedColor > (m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift) )
  2427. bBlueWantedColor = (BYTE)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift);
  2428. if ( bGreenWantedColor > (m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift) )
  2429. bGreenWantedColor = (BYTE)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift);
  2430. if ( bRedWantedColor > (m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift) )
  2431. bRedWantedColor = (BYTE)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift);
  2433. pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (nLastWidth+nX+nCheck)] = ((bRedWantedColor  <<m_stBitsMaskInfo.bRShift) |
  2434.   (bGreenWantedColor<<m_stBitsMaskInfo.bGShift) |
  2435.   (bBlueWantedColor <<m_stBitsMaskInfo.bBShift));
  2436. }
  2437. x += (nCurrWidth-rc.left);
  2438. }
  2439. // rc.right痢阑 扁霖栏肺 墨乔且 康开捞 吧赴 版快.
  2440. else if ( nLastWidth <= rc.right && rc.right < nCurrWidth )
  2441. {
  2442. for ( INT nCheck = 0; nCheck < rc.right-nLastWidth; nCheck++ )
  2443. {
  2444. wPixel   = wChooseColor;
  2445. bBlueWantedColor  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  2446. bGreenWantedColor = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  2447. bRedWantedColor   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  2449. wPixel   = pwSrc[x+nCheck];
  2450. bBlueSrc  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  2451. bGreenSrc = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  2452. bRedSrc   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  2454. rBlueRate = (FLOAT)((FLOAT)bBlueSrc / (FLOAT)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift));
  2455. rGreenRate = (FLOAT)((FLOAT)bGreenSrc / (FLOAT)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift));
  2456. bRedRate = (FLOAT)((FLOAT)bRedSrc / (FLOAT)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift));
  2458. bBlueWantedColor = (BYTE)(((FLOAT)bBlueWantedColor*rBlueRate));
  2459. bGreenWantedColor = (BYTE)(((FLOAT)bGreenWantedColor*rGreenRate));
  2460. bRedWantedColor = (BYTE)(((FLOAT)bRedWantedColor*bRedRate));
  2462. if ( bBlueWantedColor > (m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift) )
  2463. bBlueWantedColor = (BYTE)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift);
  2464. if ( bGreenWantedColor > (m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift) )
  2465. bGreenWantedColor = (BYTE)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift);
  2466. if ( bRedWantedColor > (m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift) )
  2467. bRedWantedColor = (BYTE)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift);
  2469. pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (nLastWidth+nX+nCheck)] = ((bRedWantedColor  <<m_stBitsMaskInfo.bRShift) |
  2470.   (bGreenWantedColor<<m_stBitsMaskInfo.bGShift) |
  2471.   (bBlueWantedColor <<m_stBitsMaskInfo.bBShift));
  2472. }
  2473. x += nCntCopyWord;
  2474. }
  2475. else
  2476. {
  2477. for ( INT nCheck = 0; nCheck < nCntCopyWord; nCheck++ )
  2478. {
  2479. wPixel   = wChooseColor;
  2480. bBlueWantedColor  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  2481. bGreenWantedColor = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  2482. bRedWantedColor   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  2484. wPixel   = pwSrc[x+nCheck];
  2485. bBlueSrc  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  2486. bGreenSrc = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  2487. bRedSrc   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  2489. rBlueRate = (FLOAT)((FLOAT)bBlueSrc / (FLOAT)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift));
  2490. rGreenRate = (FLOAT)((FLOAT)bGreenSrc / (FLOAT)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift));
  2491. bRedRate = (FLOAT)((FLOAT)bRedSrc / (FLOAT)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift));
  2493. bBlueWantedColor = (BYTE)(((FLOAT)bBlueWantedColor*rBlueRate));
  2494. bGreenWantedColor = (BYTE)(((FLOAT)bGreenWantedColor*rGreenRate));
  2495. bRedWantedColor = (BYTE)(((FLOAT)bRedWantedColor*bRedRate));
  2497. if ( bBlueWantedColor > (m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift) )
  2498. bBlueWantedColor = (BYTE)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift);
  2499. if ( bGreenWantedColor > (m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift) )
  2500. bGreenWantedColor = (BYTE)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift);
  2501. if ( bRedWantedColor > (m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift) )
  2502. bRedWantedColor = (BYTE)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift);
  2504. pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (nLastWidth+nX+nCheck)] = ((bRedWantedColor  <<m_stBitsMaskInfo.bRShift) |
  2505.   (bGreenWantedColor<<m_stBitsMaskInfo.bGShift) |
  2506.     (bBlueWantedColor <<m_stBitsMaskInfo.bBShift));
  2507. }
  2508. x += nCntCopyWord;
  2509. }
  2510. }
  2511. }
  2512. }
  2513. // 扼牢狼 场阑 促澜 扼牢狼 矫累栏肺 颗败霖促.
  2514. nWidthEnd++;
  2516. nWidthStart = nWidthEnd;
  2517. nCurrWidth = 0;
  2518. }
  2519. }
  2521. m_pddsBackBuffer->Unlock(NULL);
  2522. return TRUE;
  2523. }
  2524. return FALSE;
  2525. }
  2528. BOOL CWHDXGraphicWindow::DrawWithImageForCompClipRgnBase(INT nX, INT nY, INT nXSize, INT nYSize, WORD* pwSrc, WORD wClipWidth, WORD wClipHeight, WORD wChooseColor1, WORD wChooseColor2)
  2529. {
  2530. RECT rc;
  2531. DDSURFACEDESC2 ddsd;
  2533. INT nWidth = nXSize;
  2534. INT nHeight = nYSize;
  2535. INT nXOffset = 0;
  2536. INT nYOffset = 0;
  2537. INT nStartX = 0;
  2538. INT nStartY = 0;
  2539. INT nEndX = wClipWidth -1;
  2540. INT nEndY = wClipHeight-1;
  2542. if ( m_pddsBackBuffer != NULL )
  2543. {
  2544. if (nX < nStartX )
  2545. { 
  2546. nXOffset = nStartX - nX;
  2547. nWidth = nXSize - nXOffset;
  2548. }
  2549. if ( (nX+nXSize-1) > nEndX )
  2550. nWidth = nEndX - nX - nXOffset + 1;
  2551. if ( nY < nStartY )
  2552. { 
  2553. nYOffset = nStartY - nY;
  2554. nHeight = nYSize - nYOffset;
  2555. }
  2556. if ( (nY+nYSize-1) > nEndY )
  2557. nHeight = nEndY - nY - nYOffset + 1;
  2559. if ( (nWidth > 0) && (nHeight > 0) )
  2560. {
  2561. rc.left = nXOffset;
  2562. rc.right = nXOffset+nWidth;
  2563. rc.top = nYOffset;
  2564. rc.bottom = nYOffset+nHeight;
  2566. ddsd.dwSize = sizeof(DDSURFACEDESC2);
  2567. ddsd.lpSurface = NULL;
  2569. m_pddsBackBuffer->Lock(NULL, &ddsd, DDLOCK_WAIT, NULL);
  2570. if ( !ddsd.lpSurface ) return FALSE;
  2571. WORD* pwdDst;
  2572. pwdDst = (WORD*)ddsd.lpSurface;
  2574. INT nWidthStart = 0;
  2575. INT nWidthEnd = 0;
  2576. INT nCurrWidth  = 0;
  2577. INT nCntCopyWord = 0;
  2578. INT nYCnt =0;
  2579. INT nLastWidth = 0;
  2581. FLOAT rBlueRate, rGreenRate, bRedRate;
  2582. BYTE  bRedSrc, bGreenSrc, bBlueSrc;
  2583. BYTE  bRedWantedColor, bGreenWantedColor, bBlueWantedColor;
  2584. WORD  wPixel;
  2586. // y绵 努府俏.
  2587.    for ( nYCnt=0 ; nYCnt < rc.top ; nYCnt++ )
  2588. {
  2589. nWidthEnd += pwSrc[nWidthStart];
  2590. nWidthStart++;
  2591. nWidthEnd++;
  2592. nWidthStart = nWidthEnd;
  2593. }
  2595. // y绵俊 措秦辑 角力肺 风俏矫懦 Count父阑 沥茄促.
  2596. for ( nYCnt=rc.top ; nYCnt < rc.bottom ; nYCnt++ )
  2597. {
  2598. // 茄扼牢狼 辨捞甫 掘绢柯促.(窜困绰 况靛)
  2599. nWidthEnd += pwSrc[nWidthStart];
  2600. nWidthStart++;
  2602. // 扼牢狼 辨捞父怒 拳搁俊 谎妨霖促.
  2603. for ( INT x = nWidthStart; x < nWidthEnd ; )
  2604. {
  2605. if ( pwSrc[x] == 0xC0 )
  2606. {
  2607. x++;
  2608. nCntCopyWord = pwSrc[x];
  2609. x++;
  2610. nCurrWidth += nCntCopyWord;
  2611. }
  2612. else if ( pwSrc[x] == 0xC1 )
  2613. {
  2614. x++;
  2615. nCntCopyWord = pwSrc[x];
  2616. x++;
  2618. nLastWidth = nCurrWidth;
  2619. nCurrWidth += nCntCopyWord;
  2621. if ( rc.left > nCurrWidth || rc.right < nLastWidth )
  2622. {
  2623. x += nCntCopyWord;
  2624. }
  2625. else
  2626. {
  2627. // rc.left痢阑 扁霖栏肺 墨乔且 康开捞 吧赴 版快.
  2628. if ( nLastWidth < rc.left && rc.left <= nCurrWidth )
  2629. {
  2630. x += (rc.left-nLastWidth);
  2631. memcpy(&pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (rc.left+nX)], &pwSrc[x], sizeof(WORD)*(nCurrWidth-rc.left));
  2632. x += (nCurrWidth-rc.left);
  2633. }
  2634. // rc.right痢阑 扁霖栏肺 墨乔且 康开捞 吧赴 版快.
  2635. else if ( nLastWidth <= rc.right && rc.right < nCurrWidth )
  2636. {
  2637. memcpy(&pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (nLastWidth+nX)], &pwSrc[x], sizeof(WORD)*(rc.right-nLastWidth));
  2638. x += nCntCopyWord;
  2639. }
  2640. else
  2641. {
  2642. memcpy(&pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (nLastWidth+nX)], &pwSrc[x], sizeof(WORD)*nCntCopyWord);
  2643. x += nCntCopyWord;
  2644. }
  2645. }
  2646. }
  2647. else if ( pwSrc[x] == 0xC2 || pwSrc[x] == 0xC3 )
  2648. {
  2649. WORD wDyingKind, wChooseColor;
  2650. wDyingKind = pwSrc[x];
  2651. switch ( wDyingKind )
  2652. {
  2653. case 0xC2: 
  2654. wChooseColor = wChooseColor1;
  2655. break;
  2656. case 0xC3: 
  2657. wChooseColor = wChooseColor2;
  2658. break;
  2659. }
  2660. x++;
  2661. nCntCopyWord = pwSrc[x];
  2662. x++;
  2664. nLastWidth = nCurrWidth;
  2665. nCurrWidth += nCntCopyWord;
  2667. if ( rc.left > nCurrWidth || rc.right < nLastWidth )
  2668. {
  2669. x += nCntCopyWord;
  2670. }
  2671. else
  2672. {
  2673. // rc.left痢阑 扁霖栏肺 墨乔且 康开捞 吧赴 版快.
  2674. if ( nLastWidth < rc.left && rc.left <= nCurrWidth )
  2675. {
  2676. x += (rc.left-nLastWidth);
  2677. for ( INT nCheck = 0; nCheck < nCurrWidth-rc.left; nCheck++ )
  2678. {
  2679. wPixel   = wChooseColor;
  2680. bBlueWantedColor  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  2681. bGreenWantedColor = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  2682. bRedWantedColor   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  2684. wPixel   = pwSrc[x+nCheck];
  2685. bBlueSrc  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  2686. bGreenSrc = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  2687. bRedSrc   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  2689. rBlueRate = (FLOAT)((FLOAT)bBlueSrc / (FLOAT)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift));
  2690. rGreenRate = (FLOAT)((FLOAT)bGreenSrc / (FLOAT)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift));
  2691. bRedRate = (FLOAT)((FLOAT)bRedSrc / (FLOAT)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift));
  2693. bBlueWantedColor = (BYTE)(((FLOAT)bBlueWantedColor*rBlueRate));
  2694. bGreenWantedColor = (BYTE)(((FLOAT)bGreenWantedColor*rGreenRate));
  2695. bRedWantedColor = (BYTE)(((FLOAT)bRedWantedColor*bRedRate));
  2697. if ( bBlueWantedColor > (m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift) )
  2698. bBlueWantedColor = (BYTE)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift);
  2699. if ( bGreenWantedColor > (m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift) )
  2700. bGreenWantedColor = (BYTE)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift);
  2701. if ( bRedWantedColor > (m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift) )
  2702. bRedWantedColor = (BYTE)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift);
  2704. pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (nLastWidth+nX+nCheck)] = ((bRedWantedColor  <<m_stBitsMaskInfo.bRShift) |
  2705.   (bGreenWantedColor<<m_stBitsMaskInfo.bGShift) |
  2706.     (bBlueWantedColor <<m_stBitsMaskInfo.bBShift));
  2707. }
  2708. x += (nCurrWidth-rc.left);
  2709. }
  2710. // rc.right痢阑 扁霖栏肺 墨乔且 康开捞 吧赴 版快.
  2711. else if ( nLastWidth <= rc.right && rc.right < nCurrWidth )
  2712. {
  2713. for ( INT nCheck = 0; nCheck < rc.right-nLastWidth; nCheck++ )
  2714. {
  2715. wPixel   = wChooseColor;
  2716. bBlueWantedColor  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  2717. bGreenWantedColor = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  2718. bRedWantedColor   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  2720. wPixel   = pwSrc[x+nCheck];
  2721. bBlueSrc  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  2722. bGreenSrc = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  2723. bRedSrc   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  2725. rBlueRate = (FLOAT)((FLOAT)bBlueSrc / (FLOAT)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift));
  2726. rGreenRate = (FLOAT)((FLOAT)bGreenSrc / (FLOAT)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift));
  2727. bRedRate = (FLOAT)((FLOAT)bRedSrc / (FLOAT)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift));
  2729. bBlueWantedColor = (BYTE)(((FLOAT)bBlueWantedColor*rBlueRate));
  2730. bGreenWantedColor = (BYTE)(((FLOAT)bGreenWantedColor*rGreenRate));
  2731. bRedWantedColor = (BYTE)(((FLOAT)bRedWantedColor*bRedRate));
  2733. if ( bBlueWantedColor > (m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift) )
  2734. bBlueWantedColor = (BYTE)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift);
  2735. if ( bGreenWantedColor > (m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift) )
  2736. bGreenWantedColor = (BYTE)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift);
  2737. if ( bRedWantedColor > (m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift) )
  2738. bRedWantedColor = (BYTE)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift);
  2740. pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (nLastWidth+nX+nCheck)] = ((bRedWantedColor  <<m_stBitsMaskInfo.bRShift) |
  2741.   (bGreenWantedColor<<m_stBitsMaskInfo.bGShift) |
  2742.     (bBlueWantedColor <<m_stBitsMaskInfo.bBShift));
  2743. }
  2744. x += nCntCopyWord;
  2745. }
  2746. else
  2747. {
  2748. for ( INT nCheck = 0; nCheck < nCntCopyWord; nCheck++ )
  2749. {
  2750. wPixel   = wChooseColor;
  2751. bBlueWantedColor  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  2752. bGreenWantedColor = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  2753. bRedWantedColor   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  2755. wPixel   = pwSrc[x+nCheck];
  2756. bBlueSrc  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  2757. bGreenSrc = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  2758. bRedSrc   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  2760. rBlueRate = (FLOAT)((FLOAT)bBlueSrc / (FLOAT)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift));
  2761. rGreenRate = (FLOAT)((FLOAT)bGreenSrc / (FLOAT)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift));
  2762. bRedRate = (FLOAT)((FLOAT)bRedSrc / (FLOAT)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift));
  2764. bBlueWantedColor = (BYTE)(((FLOAT)bBlueWantedColor*rBlueRate));
  2765. bGreenWantedColor = (BYTE)(((FLOAT)bGreenWantedColor*rGreenRate));
  2766. bRedWantedColor = (BYTE)(((FLOAT)bRedWantedColor*bRedRate));
  2768. if ( bBlueWantedColor > (m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift) )
  2769. bBlueWantedColor = (BYTE)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift);
  2770. if ( bGreenWantedColor > (m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift) )
  2771. bGreenWantedColor = (BYTE)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift);
  2772. if ( bRedWantedColor > (m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift) )
  2773. bRedWantedColor = (BYTE)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift);
  2775. pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (nLastWidth+nX+nCheck)] = ((bRedWantedColor  <<m_stBitsMaskInfo.bRShift) |
  2776.   (bGreenWantedColor<<m_stBitsMaskInfo.bGShift) |
  2777.     (bBlueWantedColor <<m_stBitsMaskInfo.bBShift));
  2778. }
  2779. x += nCntCopyWord;
  2780. }
  2781. }
  2782. }
  2783. }
  2784. // 扼牢狼 场阑 促澜 扼牢狼 矫累栏肺 颗败霖促.
  2785. nWidthEnd++;
  2787. nWidthStart = nWidthEnd;
  2788. nCurrWidth = 0;
  2789. }
  2790. }
  2792. m_pddsBackBuffer->Unlock(NULL);
  2793. return TRUE;
  2794. }
  2795. return FALSE;
  2796. }
  2799. BOOL CWHDXGraphicWindow::DrawWithABlendCompDataWithBackBuffer(INT nX, INT nY, 
  2800.   INT nXSize, INT nYSize, WORD* pwSrc,
  2801.   WORD wClipWidth, WORD wClipHeight,
  2802.   WORD wChooseColor1, WORD wChooseColor2, BYTE bOpa)
  2803. {
  2804. RECT rc;
  2805. DDSURFACEDESC2 ddsd;
  2807. INT nWidth = nXSize;
  2808. INT nHeight = nYSize;
  2809. INT nXOffset = 0;
  2810. INT nYOffset = 0;
  2811. INT nStartX = 0;
  2812. INT nStartY = 0;
  2813. INT nEndX = wClipWidth -1;
  2814. INT nEndY = wClipHeight-1;
  2816. WORD wDyingKind, wChooseColor;
  2818. if ( m_pddsBackBuffer != NULL )
  2819. {
  2820. if (nX < nStartX )
  2821. { 
  2822. nXOffset = nStartX - nX;
  2823. nWidth = nXSize - nXOffset;
  2824. }
  2825. if ( (nX+nXSize-1) > nEndX )
  2826. nWidth = nEndX - nX - nXOffset + 1;
  2827. if ( nY < nStartY )
  2828. { 
  2829. nYOffset = nStartY - nY;
  2830. nHeight = nYSize - nYOffset;
  2831. }
  2832. if ( (nY+nYSize-1) > nEndY )
  2833. nHeight = nEndY - nY - nYOffset + 1;
  2835. if ( (nWidth > 0) && (nHeight > 0) )
  2836. {
  2837. rc.left = nXOffset;
  2838. rc.right = nXOffset+nWidth;
  2839. rc.top = nYOffset;
  2840. rc.bottom = nYOffset+nHeight;
  2842. ddsd.dwSize = sizeof(DDSURFACEDESC2);
  2843. ddsd.lpSurface = NULL;
  2845. m_pddsBackBuffer->Lock(NULL, &ddsd, DDLOCK_WAIT, NULL);
  2846. if ( !ddsd.lpSurface ) return FALSE;
  2847. WORD* pwdDst;
  2848. pwdDst = (WORD*)ddsd.lpSurface;
  2850. INT nWidthStart = 0;
  2851. INT nWidthEnd = 0;
  2852. INT nCurrWidth  = 0;
  2853. INT nCntCopyWord = 0;
  2854. INT nYCnt =0;
  2855. INT nLastWidth = 0;
  2857. BYTE bRedDst, bGreenDst, bBlueDst;
  2858. BYTE bRedSrc, bGreenSrc, bBlueSrc;
  2859. BYTE bRedWantedColor, bGreenWantedColor, bBlueWantedColor;
  2860. WORD wPixel;
  2861. FLOAT rBlueRate, rGreenRate, bRedRate;
  2863. // y绵 努府俏.
  2864.    for ( nYCnt=0 ; nYCnt < rc.top ; nYCnt++ )
  2865. {
  2866. nWidthEnd += pwSrc[nWidthStart];
  2867. nWidthStart++;
  2868. nWidthEnd++;
  2869. nWidthStart = nWidthEnd;
  2870. }
  2872. // y绵俊 措秦辑 角力肺 风俏矫懦 Count父阑 沥茄促.
  2873. for ( nYCnt=rc.top ; nYCnt < rc.bottom ; nYCnt++ )
  2874. {
  2875. // 茄扼牢狼 辨捞甫 掘绢柯促.(窜困绰 况靛)
  2876. nWidthEnd += pwSrc[nWidthStart];
  2877. nWidthStart++;
  2879. // 扼牢狼 辨捞父怒 拳搁俊 谎妨霖促.
  2880. for ( INT x = nWidthStart; x < nWidthEnd ; )
  2881. {
  2882. if ( pwSrc[x] == 0xC0 )
  2883. {
  2884. x++;
  2885. nCntCopyWord = pwSrc[x];
  2886. x++;
  2887. nCurrWidth += nCntCopyWord;
  2888. }
  2889. else if ( pwSrc[x] == 0xC1 )
  2890. {
  2891. x++;
  2892. nCntCopyWord = pwSrc[x];
  2893. x++;
  2895. nLastWidth = nCurrWidth;
  2896. nCurrWidth += nCntCopyWord;
  2898. if ( rc.left > nCurrWidth || rc.right < nLastWidth )
  2899. {
  2900. x += nCntCopyWord;
  2901. }
  2902. else
  2903. {
  2904. // rc.left痢阑 扁霖栏肺 墨乔且 康开捞 吧赴 版快.
  2905. if ( nLastWidth < rc.left && rc.left <= nCurrWidth )
  2906. {
  2907. x += (rc.left-nLastWidth);
  2908. for ( INT nCheck = 0; nCheck < nCurrWidth-rc.left; nCheck++ )
  2909. {
  2910. wPixel    = pwSrc[x+nCheck];
  2911. bBlueSrc   = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  2912. bGreenSrc  = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  2913. bRedSrc    = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  2915. wPixel    = pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (rc.left+nX+nCheck)];
  2916. bBlueDst   = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  2917. bGreenDst  = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  2918. bRedDst    = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  2920. bBlueDst   = (BYTE)((bOpa*(bBlueDst -bBlueSrc )+100*bBlueSrc  ) / 100);
  2921. bGreenDst  = (BYTE)((bOpa*(bGreenDst-bGreenSrc)+100*bGreenSrc ) / 100);
  2922. bRedDst    = (BYTE)((bOpa*(bRedDst  -bRedSrc  )+100*bRedSrc   ) / 100);
  2924. pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (rc.left+nX+nCheck)] = ((bRedDst  <<m_stBitsMaskInfo.bRShift) |
  2925.    (bGreenDst<<m_stBitsMaskInfo.bGShift) |
  2926.    (bBlueDst <<m_stBitsMaskInfo.bBShift));
  2927. }
  2928. x += (nCurrWidth-rc.left);
  2929. }
  2930. // rc.right痢阑 扁霖栏肺 墨乔且 康开捞 吧赴 版快.
  2931. else if ( nLastWidth <= rc.right && rc.right < nCurrWidth )
  2932. {
  2933. for ( INT nCheck = 0; nCheck < rc.right-nLastWidth; nCheck++ )
  2934. {
  2935. wPixel    = pwSrc[x+nCheck];
  2936. bBlueSrc   = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  2937. bGreenSrc  = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  2938. bRedSrc    = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  2940. wPixel    = pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (nLastWidth+nX+nCheck)];
  2941. bBlueDst   = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  2942. bGreenDst  = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  2943. bRedDst    = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  2945. bBlueDst   = (BYTE)((bOpa*(bBlueDst -bBlueSrc )+100*bBlueSrc  ) / 100);
  2946. bGreenDst  = (BYTE)((bOpa*(bGreenDst-bGreenSrc)+100*bGreenSrc ) / 100);
  2947. bRedDst    = (BYTE)((bOpa*(bRedDst  -bRedSrc  )+100*bRedSrc   ) / 100);
  2949. pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (nLastWidth+nX+nCheck)] = ((bRedDst  <<m_stBitsMaskInfo.bRShift) |
  2950.       (bGreenDst<<m_stBitsMaskInfo.bGShift) |
  2951.   (bBlueDst <<m_stBitsMaskInfo.bBShift));
  2952. }
  2953. x += nCntCopyWord;
  2954. }
  2955. else
  2956. {
  2957. for ( INT nCheck = 0; nCheck < nCntCopyWord; nCheck++ )
  2958. {
  2959. wPixel    = pwSrc[x+nCheck];
  2960. bBlueSrc   = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  2961. bGreenSrc  = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  2962. bRedSrc    = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  2964. wPixel    = pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (nLastWidth+nX+nCheck)];
  2965. bBlueDst   = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  2966. bGreenDst  = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  2967. bRedDst    = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  2969. bBlueDst   = (BYTE)((bOpa*(bBlueDst -bBlueSrc )+100*bBlueSrc  ) / 100);
  2970. bGreenDst  = (BYTE)((bOpa*(bGreenDst-bGreenSrc)+100*bGreenSrc ) / 100);
  2971. bRedDst    = (BYTE)((bOpa*(bRedDst  -bRedSrc  )+100*bRedSrc   ) / 100);
  2973. pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (nLastWidth+nX+nCheck)] = ((bRedDst  <<m_stBitsMaskInfo.bRShift) |
  2974.       (bGreenDst<<m_stBitsMaskInfo.bGShift) |
  2975.   (bBlueDst <<m_stBitsMaskInfo.bBShift));
  2976. }
  2977. x += nCntCopyWord;
  2978. }
  2979. }
  2980. }
  2981. else if ( pwSrc[x] == 0xC2 || pwSrc[x] == 0xC3 )
  2982. {
  2983. wDyingKind = pwSrc[x];
  2984. switch ( wDyingKind )
  2985. {
  2986. case 0xC2: 
  2987. wChooseColor = wChooseColor1;
  2988. break;
  2989. case 0xC3: 
  2990. wChooseColor = wChooseColor2;
  2991. break;
  2992. }
  2993. x++;
  2994. nCntCopyWord = pwSrc[x];
  2995. x++;
  2997. nLastWidth = nCurrWidth;
  2998. nCurrWidth += nCntCopyWord;
  3000. if ( rc.left > nCurrWidth || rc.right < nLastWidth )
  3001. {
  3002. x += nCntCopyWord;
  3003. }
  3004. else
  3005. {
  3006. // rc.left痢阑 扁霖栏肺 墨乔且 康开捞 吧赴 版快.
  3007. if ( nLastWidth < rc.left && rc.left <= nCurrWidth )
  3008. {
  3009. x += (rc.left-nLastWidth);
  3010. for ( INT nCheck = 0; nCheck < nCurrWidth-rc.left; nCheck++ )
  3011. {
  3012. wPixel   = wChooseColor;
  3013. bBlueWantedColor  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  3014. bGreenWantedColor = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  3015. bRedWantedColor   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  3017. wPixel   = pwSrc[x+nCheck];
  3018. bBlueSrc  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  3019. bGreenSrc = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  3020. bRedSrc   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  3022. rBlueRate = (FLOAT)((FLOAT)bBlueSrc / (FLOAT)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift));
  3023. rGreenRate = (FLOAT)((FLOAT)bGreenSrc / (FLOAT)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift));
  3024. bRedRate = (FLOAT)((FLOAT)bRedSrc / (FLOAT)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift));
  3026. bBlueWantedColor = (BYTE)(((FLOAT)bBlueWantedColor*rBlueRate));
  3027. bGreenWantedColor = (BYTE)(((FLOAT)bGreenWantedColor*rGreenRate));
  3028. bRedWantedColor = (BYTE)(((FLOAT)bRedWantedColor*bRedRate));
  3030. if ( bBlueWantedColor > (m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift) )
  3031. bBlueWantedColor = (BYTE)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift);
  3032. if ( bGreenWantedColor > (m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift) )
  3033. bGreenWantedColor = (BYTE)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift);
  3034. if ( bRedWantedColor > (m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift) )
  3035. bRedWantedColor = (BYTE)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift);
  3038. wPixel  = pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (rc.left+nX+nCheck)];
  3039. bBlueDst   = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  3040. bGreenDst  = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  3041. bRedDst    = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  3043. bBlueDst   = (BYTE)((bOpa*(bBlueDst -bBlueWantedColor )+100*bBlueWantedColor ) / 100);
  3044. bGreenDst  = (BYTE)((bOpa*(bGreenDst-bGreenWantedColor)+100*bGreenWantedColor) / 100);
  3045. bRedDst    = (BYTE)((bOpa*(bRedDst  -bRedWantedColor  )+100*bRedWantedColor  ) / 100);
  3047. pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (rc.left+nX+nCheck)] = ((bRedDst  <<m_stBitsMaskInfo.bRShift) |
  3048.    (bGreenDst<<m_stBitsMaskInfo.bGShift) |
  3049.    (bBlueDst <<m_stBitsMaskInfo.bBShift));
  3050. }
  3051. x += (nCurrWidth-rc.left);
  3052. }
  3053. // rc.right痢阑 扁霖栏肺 墨乔且 康开捞 吧赴 版快.
  3054. else if ( nLastWidth <= rc.right && rc.right < nCurrWidth )
  3055. {
  3056. for ( INT nCheck = 0; nCheck < rc.right-nLastWidth; nCheck++ )
  3057. {
  3058. wPixel   = wChooseColor;
  3059. bBlueWantedColor  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  3060. bGreenWantedColor = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  3061. bRedWantedColor   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  3063. wPixel   = pwSrc[x+nCheck];
  3064. bBlueSrc  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  3065. bGreenSrc = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  3066. bRedSrc   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  3068. rBlueRate = (FLOAT)((FLOAT)bBlueSrc / (FLOAT)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift));
  3069. rGreenRate = (FLOAT)((FLOAT)bGreenSrc / (FLOAT)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift));
  3070. bRedRate = (FLOAT)((FLOAT)bRedSrc / (FLOAT)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift));
  3072. bBlueWantedColor = (BYTE)(((FLOAT)bBlueWantedColor*rBlueRate));
  3073. bGreenWantedColor = (BYTE)(((FLOAT)bGreenWantedColor*rGreenRate));
  3074. bRedWantedColor = (BYTE)(((FLOAT)bRedWantedColor*bRedRate));
  3076. if ( bBlueWantedColor > (m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift) )
  3077. bBlueWantedColor = (BYTE)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift);
  3078. if ( bGreenWantedColor > (m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift) )
  3079. bGreenWantedColor = (BYTE)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift);
  3080. if ( bRedWantedColor > (m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift) )
  3081. bRedWantedColor = (BYTE)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift);
  3084. wPixel  = pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (nLastWidth+nX+nCheck)];
  3085. bBlueDst   = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  3086. bGreenDst  = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  3087. bRedDst    = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  3089. bBlueDst   = (BYTE)((bOpa*(bBlueDst -bBlueWantedColor )+100*bBlueWantedColor ) / 100);
  3090. bGreenDst  = (BYTE)((bOpa*(bGreenDst-bGreenWantedColor)+100*bGreenWantedColor) / 100);
  3091. bRedDst    = (BYTE)((bOpa*(bRedDst  -bRedWantedColor  )+100*bRedWantedColor  ) / 100);
  3093. pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (nLastWidth+nX+nCheck)] = ((bRedDst  <<m_stBitsMaskInfo.bRShift) |
  3094.       (bGreenDst<<m_stBitsMaskInfo.bGShift) |
  3095.   (bBlueDst <<m_stBitsMaskInfo.bBShift));
  3096. }
  3097. x += nCntCopyWord;
  3098. }
  3099. else
  3100. {
  3101. for ( INT nCheck = 0; nCheck < nCntCopyWord; nCheck++ )
  3102. {
  3103. wPixel   = wChooseColor;
  3104. bBlueWantedColor  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  3105. bGreenWantedColor = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  3106. bRedWantedColor   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  3108. wPixel   = pwSrc[x+nCheck];
  3109. bBlueSrc  = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  3110. bGreenSrc = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  3111. bRedSrc   = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  3113. rBlueRate = (FLOAT)((FLOAT)bBlueSrc / (FLOAT)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift));
  3114. rGreenRate = (FLOAT)((FLOAT)bGreenSrc / (FLOAT)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift));
  3115. bRedRate = (FLOAT)((FLOAT)bRedSrc / (FLOAT)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift));
  3117. bBlueWantedColor = (BYTE)(((FLOAT)bBlueWantedColor*rBlueRate));
  3118. bGreenWantedColor = (BYTE)(((FLOAT)bGreenWantedColor*rGreenRate));
  3119. bRedWantedColor = (BYTE)(((FLOAT)bRedWantedColor*bRedRate));
  3121. if ( bBlueWantedColor > (m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift) )
  3122. bBlueWantedColor = (BYTE)(m_stBitsMaskInfo.dwBMask>>m_stBitsMaskInfo.bBShift);
  3123. if ( bGreenWantedColor > (m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift) )
  3124. bGreenWantedColor = (BYTE)(m_stBitsMaskInfo.dwGMask>>m_stBitsMaskInfo.bGShift);
  3125. if ( bRedWantedColor > (m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift) )
  3126. bRedWantedColor = (BYTE)(m_stBitsMaskInfo.dwRMask>>m_stBitsMaskInfo.bRShift);
  3129. wPixel  = pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (nLastWidth+nX+nCheck)];
  3130. bBlueDst   = (BYTE)((wPixel & m_stBitsMaskInfo.dwBMask) >> m_stBitsMaskInfo.bBShift);
  3131. bGreenDst  = (BYTE)((wPixel & m_stBitsMaskInfo.dwGMask) >> m_stBitsMaskInfo.bGShift);
  3132. bRedDst    = (BYTE)((wPixel & m_stBitsMaskInfo.dwRMask) >> m_stBitsMaskInfo.bRShift);
  3134. bBlueDst   = (BYTE)((bOpa*(bBlueDst -bBlueWantedColor )+100*bBlueWantedColor ) / 100);
  3135. bGreenDst  = (BYTE)((bOpa*(bGreenDst-bGreenWantedColor)+100*bGreenWantedColor) / 100);
  3136. bRedDst    = (BYTE)((bOpa*(bRedDst  -bRedWantedColor  )+100*bRedWantedColor  ) / 100);
  3138. pwdDst[((nYCnt+nY) * (ddsd.lPitch >> 1)) + (nLastWidth+nX+nCheck)] = ((bRedDst  <<m_stBitsMaskInfo.bRShift) |
  3139.       (bGreenDst<<m_stBitsMaskInfo.bGShift) |
  3140.   (bBlueDst <<m_stBitsMaskInfo.bBShift));
  3141. }
  3142. x += nCntCopyWord;
  3143. }
  3144. }
  3145. }
  3146. }
  3147. // 扼牢狼 场阑 促澜 扼牢狼 矫累栏肺 颗败霖促.
  3148. nWidthEnd++;