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

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

模拟服务器

开发平台：

Visual C++

WHWilTexture.cpp：源码内容
  1. /******************************************************************************************************************
  2.                                                                                                                    
  3. 葛碘疙:
  5. 累己磊:
  6. 累己老:
  8. [老磊][荐沥磊] : 荐沥 郴侩
  9.                                                                                                                    
  10. *******************************************************************************************************************/
  11. #include "StdAfx.h"
  14. struct WILTextureContainer
  15. {
  16.     WILTextureContainer* m_pNext;
  18.     TCHAR   m_strWilFileName[80];
  19. INT m_nIdx;
  20. WORD* m_pwData; // Surface肺 肺爹矫懦锭父 蔼捞 沥狼等促. 弊寇浚 亲惑 NULL捞促.<---???
  21.     DWORD   m_dwFlags;
  22.     DWORD   m_dwWidth;
  23.     DWORD   m_dwHeight;
  24.     LPDIRECTDRAWSURFACE7 m_pddsSurface;
  26. public:
  27. //  HRESULT LoadImageData();
  28.     HRESULT Restore(LPDIRECT3DDEVICE7 pd3dDevice);
  29.     HRESULT CopyDataToSurface();
  30. HRESULT CopyDataToSurfaceToSurface();
  32.     WILTextureContainer(TCHAR* strWilFileName, INT nIndex, DWORD dwFlags);
  33.     ~WILTextureContainer();
  34. };
  35. static WILTextureContainer* g_ptcWILTextureList = NULL;
  38. class CD3DWILTextureManager
  39. {
  40. public:
  41.     CD3DWILTextureManager () {}
  42.     ~CD3DWILTextureManager() { if ( g_ptcWILTextureList ) delete g_ptcWILTextureList; }
  43. };
  45. CD3DWILTextureManager g_StaticWILTextureEngine;
  48. struct TEXTURESEARCHINFO
  49. {
  50.     DWORD dwDesiredBPP;
  51.     BOOL  bUseAlpha;
  52.     BOOL  bUsePalette;
  53.     BOOL  bFoundGoodFormat;
  55.     DDPIXELFORMAT* pddpf;
  56. };
  59. static HRESULT CALLBACK TextureSearchCallback(DDPIXELFORMAT* pddpf, VOID* param)
  60. {
  61.     if ( NULL==pddpf || NULL==param )
  62.         return DDENUMRET_OK;
  64.     TEXTURESEARCHINFO* ptsi = (TEXTURESEARCHINFO*)param;
  66.     if ( pddpf->dwFlags & (DDPF_LUMINANCE|DDPF_BUMPLUMINANCE|DDPF_BUMPDUDV) )
  67.         return DDENUMRET_OK;
  69.     if ( ptsi->bUsePalette )
  70.     {
  71.         if( !(pddpf->dwFlags & DDPF_PALETTEINDEXED8) )
  72.             return DDENUMRET_OK;
  73.         memcpy(ptsi->pddpf, pddpf, sizeof(DDPIXELFORMAT));
  74.         ptsi->bFoundGoodFormat = TRUE;
  75.         return DDENUMRET_CANCEL;
  76.     }
  78.     if ( pddpf->dwRGBBitCount < 16 )
  79.         return DDENUMRET_OK;
  81.     if ( pddpf->dwFourCC != 0 )
  82.         return DDENUMRET_OK;
  84.     if( pddpf->dwRGBAlphaBitMask == 0x0000f000 )
  85.         return DDENUMRET_OK;
  87.     if ( (ptsi->bUseAlpha==TRUE) && !(pddpf->dwFlags&DDPF_ALPHAPIXELS) )
  88.         return DDENUMRET_OK;
  89.     if ( (ptsi->bUseAlpha==FALSE) && (pddpf->dwFlags&DDPF_ALPHAPIXELS) )
  90.         return DDENUMRET_OK;
  92.     if ( pddpf->dwRGBBitCount == ptsi->dwDesiredBPP )
  93.     {
  94.         memcpy(ptsi->pddpf, pddpf, sizeof(DDPIXELFORMAT));
  95.         ptsi->bFoundGoodFormat = TRUE;
  96.         return DDENUMRET_CANCEL;
  97.     }
  99.     return DDENUMRET_OK;
  100. }
  103. static WILTextureContainer* FindWilTexture(TCHAR* strWilFileName, INT nIdx)
  104. {
  105.     WILTextureContainer* ptcWILTexture = g_ptcWILTextureList;
  107.     while ( ptcWILTexture )
  108.     {
  109.         if ( !lstrcmpi(strWilFileName, ptcWILTexture->m_strWilFileName) &&
  110.  nIdx == ptcWILTexture->m_nIdx )
  111. {
  112.             return ptcWILTexture;
  113. }
  114.         ptcWILTexture = ptcWILTexture->m_pNext;
  115.     }
  117.     return NULL;
  118. }
  121. BOOL D3DWILTextr_IsTextrExisted(TCHAR* strWilFileName, INT nIdx)
  122. {
  123.     if ( NULL != FindWilTexture(strWilFileName, nIdx) )
  124.         return TRUE;
  125. return FALSE;
  126. }
  129. WILTextureContainer::WILTextureContainer(TCHAR* strWilFileName, INT nIndex, DWORD dwFlags)
  130. {
  131.     lstrcpy(m_strWilFileName, strWilFileName);
  132. m_nIdx = nIndex;
  133.     m_dwWidth = 0;
  134.     m_dwHeight = 0;
  135.     m_dwFlags = dwFlags;
  136.     m_pddsSurface = NULL;
  137. m_pwData = NULL;
  138.     m_pNext = g_ptcWILTextureList;
  139.     g_ptcWILTextureList = this;
  140. }
  143. WILTextureContainer::~WILTextureContainer()
  144. {
  145.     SAFE_RELEASE( m_pddsSurface );
  147.     if ( g_ptcWILTextureList == this )
  148.         g_ptcWILTextureList = m_pNext;
  149.     else
  150.     {
  151.         for ( WILTextureContainer* ptc = g_ptcWILTextureList; ptc; ptc=ptc->m_pNext )
  152.             if ( ptc->m_pNext == this )
  153.                 ptc->m_pNext = m_pNext;
  154.     }
  155. }
  158. HRESULT WILTextureContainer::Restore(LPDIRECT3DDEVICE7 pd3dDevice)
  159. {
  160.     SAFE_RELEASE(m_pddsSurface);
  162.     if( NULL == pd3dDevice )
  163.         return DDERR_INVALIDPARAMS;
  165.     D3DDEVICEDESC7 ddDesc;
  166.     if ( FAILED(pd3dDevice->GetCaps(&ddDesc)) )
  167.         return E_FAIL;
  169.     DDSURFACEDESC2 ddsd;
  170.     D3DUtil_InitSurfaceDesc( ddsd );
  171.     ddsd.dwFlags         = DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|
  172.                            /*DDSD_PIXELFORMAT|*/DDSD_TEXTURESTAGE;
  173.     ddsd.ddsCaps.dwCaps  = DDSCAPS_TEXTURE;
  174.     ddsd.dwTextureStage  = 0;
  175.     ddsd.dwWidth         = m_dwWidth;
  176.     ddsd.dwHeight        = m_dwHeight;
  178.     if ( ddDesc.deviceGUID == IID_IDirect3DHALDevice || ddDesc.deviceGUID == IID_IDirect3DTnLHalDevice )
  179.         ddsd.ddsCaps.dwCaps2 = DDSCAPS2_TEXTUREMANAGE;
  180.     else
  181.         ddsd.ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
  183. // Setting Power of 2
  184.     if ( ddDesc.dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_POW2 )
  185.     {
  186.         for ( ddsd.dwWidth =1; m_dwWidth>ddsd.dwWidth;   ddsd.dwWidth<<=1 );
  187.         for ( ddsd.dwHeight=1; m_dwHeight>ddsd.dwHeight; ddsd.dwHeight<<=1 );
  188.     }
  190.     DWORD dwMaxWidth  = ddDesc.dwMaxTextureWidth;
  191.     DWORD dwMaxHeight = ddDesc.dwMaxTextureHeight;
  192.     ddsd.dwWidth  = min(ddsd.dwWidth,  (dwMaxWidth  ? dwMaxWidth  : 256));
  193.     ddsd.dwHeight = min(ddsd.dwHeight, (dwMaxHeight ? dwMaxHeight : 256));
  195. // 流荤阿屈狼 咆胶苗甫 瘤盔窍瘤 臼绰促搁...
  196.     if ( ddDesc.dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_SQUAREONLY )
  197.     {
  198.         if ( ddsd.dwWidth > ddsd.dwHeight ) ddsd.dwHeight = ddsd.dwWidth;
  199.         else                                ddsd.dwWidth  = ddsd.dwHeight;
  200.     }
  203. // 咆胶苗 侨伎器杆技泼...
  204.     TEXTURESEARCHINFO tsi;
  205.     tsi.bFoundGoodFormat = FALSE;
  206.     tsi.pddpf            = &ddsd.ddpfPixelFormat;
  207.     tsi.dwDesiredBPP     = 16;
  208.     tsi.bUsePalette      = ( 16 <= 8 );
  209.     tsi.bUseAlpha        = FALSE;
  210.     tsi.dwDesiredBPP  = 16;
  212.     pd3dDevice->EnumTextureFormats( TextureSearchCallback, &tsi );
  214.     if( FALSE == tsi.bFoundGoodFormat )
  215.     {
  216. return E_FAIL;
  217.     }
  219.     LPDIRECTDRAW7        pDD;
  220.     LPDIRECTDRAWSURFACE7 pddsRender;
  221.     pd3dDevice->GetRenderTarget(&pddsRender);
  222.     pddsRender->GetDDInterface((VOID**)&pDD);
  223.     pddsRender->Release();
  225.     HRESULT hr = pDD->CreateSurface(&ddsd, &m_pddsSurface, NULL);
  227.     pDD->Release();
  229.     if( FAILED(hr) )
  230.         return hr;
  232. if ( ddsd.dwWidth == m_dwWidth && ddsd.dwHeight == m_dwHeight )
  233. CopyDataToSurface();
  234. else
  235. CopyDataToSurfaceToSurface();
  237. // 拿矾虐甫 技泼茄促.
  238. DDSetColorKey(m_pddsSurface, RGB(0, 0, 0));
  240.     return S_OK;
  241. }
  244. HRESULT WILTextureContainer::CopyDataToSurfaceToSurface()
  245. {
  246. LPDIRECTDRAW7 pDD;
  247.     m_pddsSurface->GetDDInterface((VOID**)&pDD);
  249.     DDSURFACEDESC2 ddsd;
  250.     ddsd.dwSize = sizeof(ddsd);
  251.     m_pddsSurface->GetSurfaceDesc(&ddsd);
  252.     ddsd.dwFlags         = DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|//DDSD_PIXELFORMAT|
  253.                            DDSD_TEXTURESTAGE;
  254.     ddsd.ddsCaps.dwCaps  = DDSCAPS_TEXTURE|DDSCAPS_SYSTEMMEMORY;
  255.     ddsd.ddsCaps.dwCaps2 = 0L;
  256.     ddsd.dwWidth         = m_dwWidth;
  257.     ddsd.dwHeight        = m_dwHeight;
  259.     LPDIRECTDRAWSURFACE7 pddsTempSurface;
  260.     HRESULT hr;
  261.     if ( FAILED(hr = pDD->CreateSurface(&ddsd, &pddsTempSurface, NULL) ) )
  262.     {
  263.         pDD->Release();
  264.         return NULL;
  265.     }
  267.     while ( pddsTempSurface->Lock(NULL, &ddsd, 0, 0) == DDERR_WASSTILLDRAWING );
  269.     DWORD lPitch = ddsd.lPitch;
  270.     WORD* pwData = (WORD*)ddsd.lpSurface;
  277. RECT rc;
  278. SetRect(&rc, 0, 0, m_dwWidth, m_dwHeight);
  280. WORD* pwdDst = pwData;
  282. INT nWidthStart = 0;
  283. INT nWidthEnd = 0;
  284. INT nCurrWidth  = 0;
  285. INT nCntCopyWord = 0;
  286. INT nYCnt =0;
  287. INT nLastWidth = 0;
  289. // y绵 努府俏.
  290. for ( nYCnt=0 ; nYCnt < rc.top ; nYCnt++ )
  291. {
  292. nWidthEnd += m_pwData[nWidthStart];
  293. nWidthStart++;
  294. nWidthEnd++;
  295. nWidthStart = nWidthEnd;
  296. }
  298. // y绵俊 措秦辑 角力肺 风俏矫懦 Count父阑 沥茄促.
  299. for ( nYCnt=rc.top ; nYCnt < rc.bottom ; nYCnt++ )
  300. {
  301. // 茄扼牢狼 辨捞甫 掘绢柯促.(窜困绰 况靛)
  302. nWidthEnd += m_pwData[nWidthStart];
  303. nWidthStart++;
  305. // 扼牢狼 辨捞父怒 拳搁俊 谎妨霖促.
  306. for ( INT x = nWidthStart; x < nWidthEnd ; )
  307. {
  308. if ( m_pwData[x] == 0xC0 )
  309. {
  310. x++;
  311. nCntCopyWord = m_pwData[x];
  312. x++;
  313. nCurrWidth += nCntCopyWord;
  314. }
  315. else if ( m_pwData[x] == 0xC1 )
  316. {
  317. x++;
  318. nCntCopyWord = m_pwData[x];
  319. x++;
  321. nLastWidth = nCurrWidth;
  322. nCurrWidth += nCntCopyWord;
  324. if ( rc.left > nCurrWidth || rc.right < nLastWidth )
  325. {
  326. x += nCntCopyWord;
  327. }
  328. else
  329. {
  330. // rc.left痢阑 扁霖栏肺 墨乔且 康开捞 吧赴 版快.
  331. if ( nLastWidth < rc.left && rc.left <= nCurrWidth )
  332. {
  333. x += (rc.left-nLastWidth);
  334. memcpy(&pwdDst[((nYCnt) * (ddsd.lPitch >> 1)) + (rc.left)], &m_pwData[x], sizeof(WORD)*(nCurrWidth-rc.left));
  335. x += (nCurrWidth-rc.left);
  336. }
  337. // rc.right痢阑 扁霖栏肺 墨乔且 康开捞 吧赴 版快.
  338. else if ( nLastWidth <= rc.right && rc.right < nCurrWidth )
  339. {
  340. memcpy(&pwdDst[((nYCnt) * (ddsd.lPitch >> 1)) + (nLastWidth)], &m_pwData[x], sizeof(WORD)*(rc.right-nLastWidth));
  341. x += nCntCopyWord;
  342. }
  343. else
  344. {
  345. memcpy(&pwdDst[((nYCnt) * (ddsd.lPitch >> 1)) + (nLastWidth)], &m_pwData[x], sizeof(WORD)*nCntCopyWord);
  346. x += nCntCopyWord;
  347. }
  348. }
  349. }
  350. }
  351. // 扼牢狼 场阑 促澜 扼牢狼 矫累栏肺 颗败霖促.
  352. nWidthEnd++;
  354. nWidthStart = nWidthEnd;
  355. nCurrWidth = 0;
  356. }
  360.     
  363. pddsTempSurface->Unlock(0);
  364.     m_pddsSurface->Blt(NULL, pddsTempSurface, NULL, DDBLT_WAIT, NULL);
  365.     pddsTempSurface->Release();
  366.     pDD->Release();
  368.     return S_OK;
  369. }
  372. HRESULT WILTextureContainer::CopyDataToSurface()
  373. {
  374. /*  
  375. LPDIRECTDRAW7 pDD;
  376.     m_pddsSurface->GetDDInterface((VOID**)&pDD);
  378.     DDSURFACEDESC2 ddsd;
  379.     ddsd.dwSize = sizeof(ddsd);
  380.     m_pddsSurface->GetSurfaceDesc(&ddsd);
  381.     ddsd.dwFlags         = DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|//DDSD_PIXELFORMAT|
  382.                            DDSD_TEXTURESTAGE;
  383.     ddsd.ddsCaps.dwCaps  = DDSCAPS_TEXTURE|DDSCAPS_SYSTEMMEMORY;
  384.     ddsd.ddsCaps.dwCaps2 = 0L;
  385.     ddsd.dwWidth         = m_dwWidth;
  386.     ddsd.dwHeight        = m_dwHeight;
  388.     LPDIRECTDRAWSURFACE7 pddsTempSurface;
  389.     HRESULT hr;
  390.     if ( FAILED(hr = pDD->CreateSurface(&ddsd, &pddsTempSurface, NULL) ) )
  391.     {
  392.         pDD->Release();
  393.         return NULL;
  394.     }
  396.     while ( pddsTempSurface->Lock(NULL, &ddsd, 0, 0) == DDERR_WASSTILLDRAWING );
  398.     DWORD lPitch = ddsd.lPitch;
  399.     WORD* pwData = (WORD*)ddsd.lpSurface;
  400. memcpy(pwData, m_pwData, sizeof(WORD)*m_dwWidth*m_dwHeight);
  402.     pddsTempSurface->Unlock(0);
  404.     m_pddsSurface->Blt(NULL, pddsTempSurface, NULL, DDBLT_WAIT, NULL);
  406.     pddsTempSurface->Release();
  407.     pDD->Release();
  408. */
  410. RECT rc;
  411. DDSURFACEDESC2 ddsd;
  413. SetRect(&rc, 0, 0, m_dwWidth, m_dwHeight);
  415. ddsd.dwSize = sizeof(DDSURFACEDESC2);
  416. ddsd.lpSurface = NULL;
  418. m_pddsSurface->Lock(NULL, &ddsd, DDLOCK_WAIT, NULL);
  419. if ( !ddsd.lpSurface )
  420. return NULL;
  422. WORD* pwdDst;
  424. pwdDst = (WORD*)ddsd.lpSurface;
  426. INT nWidthStart = 0;
  427. INT nWidthEnd = 0;
  428. INT nCurrWidth  = 0;
  429. INT nCntCopyWord = 0;
  430. INT nYCnt =0;
  431. INT nLastWidth = 0;
  433. // y绵 努府俏.
  434. for ( nYCnt=0 ; nYCnt < rc.top ; nYCnt++ )
  435. {
  436. nWidthEnd += m_pwData[nWidthStart];
  437. nWidthStart++;
  438. nWidthEnd++;
  439. nWidthStart = nWidthEnd;
  440. }
  442. // y绵俊 措秦辑 角力肺 风俏矫懦 Count父阑 沥茄促.
  443. for ( nYCnt=rc.top ; nYCnt < rc.bottom ; nYCnt++ )
  444. {
  445. // 茄扼牢狼 辨捞甫 掘绢柯促.(窜困绰 况靛)
  446. nWidthEnd += m_pwData[nWidthStart];
  447. nWidthStart++;
  449. // 扼牢狼 辨捞父怒 拳搁俊 谎妨霖促.
  450. for ( INT x = nWidthStart; x < nWidthEnd ; )
  451. {
  452. if ( m_pwData[x] == 0xC0 )
  453. {
  454. x++;
  455. nCntCopyWord = m_pwData[x];
  456. x++;
  457. nCurrWidth += nCntCopyWord;
  458. }
  459. else if ( m_pwData[x] == 0xC1 )
  460. {
  461. x++;
  462. nCntCopyWord = m_pwData[x];
  463. x++;
  465. nLastWidth = nCurrWidth;
  466. nCurrWidth += nCntCopyWord;
  468. if ( rc.left > nCurrWidth || rc.right < nLastWidth )
  469. {
  470. x += nCntCopyWord;
  471. }
  472. else
  473. {
  474. // rc.left痢阑 扁霖栏肺 墨乔且 康开捞 吧赴 版快.
  475. if ( nLastWidth < rc.left && rc.left <= nCurrWidth )
  476. {
  477. x += (rc.left-nLastWidth);
  478. memcpy(&pwdDst[((nYCnt) * (ddsd.lPitch >> 1)) + (rc.left)], &m_pwData[x], sizeof(WORD)*(nCurrWidth-rc.left));
  479. x += (nCurrWidth-rc.left);
  480. }
  481. // rc.right痢阑 扁霖栏肺 墨乔且 康开捞 吧赴 版快.
  482. else if ( nLastWidth <= rc.right && rc.right < nCurrWidth )
  483. {
  484. memcpy(&pwdDst[((nYCnt) * (ddsd.lPitch >> 1)) + (nLastWidth)], &m_pwData[x], sizeof(WORD)*(rc.right-nLastWidth));
  485. x += nCntCopyWord;
  486. }
  487. else
  488. {
  489. memcpy(&pwdDst[((nYCnt) * (ddsd.lPitch >> 1)) + (nLastWidth)], &m_pwData[x], sizeof(WORD)*nCntCopyWord);
  490. x += nCntCopyWord;
  491. }
  492. }
  493. }
  494. }
  495. // 扼牢狼 场阑 促澜 扼牢狼 矫累栏肺 颗败霖促.
  496. nWidthEnd++;
  498. nWidthStart = nWidthEnd;
  499. nCurrWidth = 0;
  500. }
  502. m_pddsSurface->Unlock(NULL);
  503.     return S_OK;
  504. }
  507. /*
  508. HRESULT D3DTextr_CreateWILTextureFromFile(TCHAR* strWilFileName, INT nIndex, DWORD dwFlags)
  509. {
  510.     if ( NULL == strWilFileName )
  511.         return E_INVALIDARG;
  513.     if ( NULL != FindWilTexture(strWilFileName, nIndex) )
  514.         return S_OK;
  516.     WILTextureContainer* ptcWILTexture = new WILTextureContainer(strWilFileName, dwFlags);
  517.     if ( NULL == ptcWILTexture )
  518.         return E_OUTOFMEMORY;
  520.     if ( FAILED(ptcWILTexture->LoadImageData()) )
  521.     {
  522.         delete ptcWILTexture;
  523.         return E_FAIL;
  524.     }
  526. //  ptcWILTexture->m_dwWidth  = ;
  527. //  ptcWILTexture->m_dwHeight = ;
  529.     return S_OK;
  530. }
  531. */
  534. BOOL D3DWILTextr_CreateEmptyTexture(TCHAR* strWilFileName, INT nIndex, 
  535.    DWORD dwWidth, DWORD dwHeight, WORD* pwData, DWORD dwFlags)
  536. {
  537.     if ( NULL == strWilFileName )
  538.         return FALSE;
  540.     if ( NULL != FindWilTexture(strWilFileName, nIndex) )
  541.         return FALSE;
  543.     WILTextureContainer* ptcWILTexture = new WILTextureContainer(strWilFileName, nIndex, dwFlags);
  545.     if ( NULL == ptcWILTexture )
  546.         return FALSE;
  548.     ptcWILTexture->m_dwWidth  = dwWidth;
  549.     ptcWILTexture->m_dwHeight = dwHeight;
  550. ptcWILTexture->m_pwData   = pwData;
  552.     return TRUE;
  553. }
  556. HRESULT D3DWILTextr_Restore(TCHAR* strWilFileName, INT nIndex, LPDIRECT3DDEVICE7 pd3dDevice)
  557. {
  558.     WILTextureContainer* ptcWILTexture = FindWilTexture(strWilFileName, nIndex);
  559.     if ( NULL == ptcWILTexture )
  560.         return DDERR_NOTFOUND;
  562.     return ptcWILTexture->Restore(pd3dDevice);
  563. }
  566. LPDIRECTDRAWSURFACE7 D3DWILTextr_RestoreEx(TCHAR* strWilFileName, INT nIndex, LPDIRECT3DDEVICE7 pd3dDevice)
  567. {
  568.     WILTextureContainer* ptcWILTexture = FindWilTexture(strWilFileName, nIndex);
  570. if ( ptcWILTexture )
  571. {
  572. if ( ptcWILTexture->m_pddsSurface )
  573. {
  574. return ptcWILTexture->m_pddsSurface;
  575. }
  576. else
  577. {
  578. if ( (ptcWILTexture->Restore(pd3dDevice) == S_OK) )
  579. {
  580. return ptcWILTexture->m_pddsSurface;
  581. }
  582. else
  583. return NULL;
  584. }
  585. }
  587. return NULL;
  589. }
  592. HRESULT D3DWILTextr_RestoreAllTextures(LPDIRECT3DDEVICE7 pd3dDevice)
  593. {
  594.     WILTextureContainer* ptcWILTexture = g_ptcWILTextureList;
  596.     while ( ptcWILTexture && ptcWILTexture->m_pddsSurface )
  597.     {
  598.         D3DWILTextr_Restore(ptcWILTexture->m_strWilFileName, ptcWILTexture->m_nIdx, pd3dDevice);
  599.         ptcWILTexture = ptcWILTexture->m_pNext;
  600.     }
  602.     return S_OK;
  603. }
  606. HRESULT D3DWILTextr_Invalidate(TCHAR* strWilFileName, INT nIndex)
  607. {
  608.     WILTextureContainer* ptcWILTexture = FindWilTexture(strWilFileName, nIndex);
  609.     if ( NULL == ptcWILTexture )
  610.         return DDERR_NOTFOUND;
  612.     SAFE_RELEASE(ptcWILTexture->m_pddsSurface);
  614.     return S_OK;
  615. }
  618. HRESULT D3DWILTextr_InvalidateAllTextures()
  619. {
  620.     WILTextureContainer* ptcWILTexture = g_ptcWILTextureList;
  622.     while( ptcWILTexture )
  623.     {
  624.         SAFE_RELEASE(ptcWILTexture->m_pddsSurface);
  625.         ptcWILTexture = ptcWILTexture->m_pNext;
  626.     }
  628.     return S_OK;
  629. }
  631. HRESULT D3DWILTextr_DestroyAllTextures()
  632. {
  633.     WILTextureContainer* ptcWILTexture = g_ptcWILTextureList;
  634. WILTextureContainer* ptcWILMextTexture = NULL;
  636.     while( ptcWILTexture )
  637.     {
  638.         ptcWILMextTexture = ptcWILTexture->m_pNext;
  640. SAFE_DELETE(ptcWILTexture);
  642. ptcWILTexture = ptcWILMextTexture;
  644.     }
  645.     return S_OK;
  646. }
  648. HRESULT D3DWILTextr_DestroyTexture(TCHAR* strWilFileName, INT nIndex)
  649. {
  650.     WILTextureContainer* ptcWILTexture = FindWilTexture(strWilFileName, nIndex);
  652.     SAFE_DELETE(ptcWILTexture);
  654.     return S_OK;
  655. }
  658. LPDIRECTDRAWSURFACE7 D3DWILTextr_GetSurface(TCHAR* strWilFileName, INT nIndex)
  659. {
  660.     WILTextureContainer* ptcWILTexture = FindWilTexture(strWilFileName, nIndex);
  662.     return ptcWILTexture ? ptcWILTexture->m_pddsSurface : NULL;
  663. }
  666. /*
  667. POINT D3DWILTextr_GetImageSize(TCHAR* strWilFileName, INT nIndex)
  668. {
  669. POINT ptSize = {0 , 0};
  670.     WILTextureContainer* ptcWILTexture = FindWilTexture(strWilFileName, nIndex);
  672. if ( ptcWILTexture )
  673. {
  674. ptSize.x = ptcWILTexture->m_dwWidth; 
  675. ptSize.y = ptcWILTexture->m_dwHeight;
  676. }
  677.     return ptSize;
  678. }
  679. */
  681. INT GetRandomNum(INT nFrom, INT nTo)
  682. {
  683. INT nRandNum = 0;
  685. INT nRand = ((INT)rand()-(INT)rand());
  687. if ( nRand < 0 )
  688. nRand = -nRand;
  690. nRandNum = nRand % (nTo-nFrom+1) + nFrom;
  692. return nRandNum;
  693. }