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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
GSTextureCache.cpp
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：30k
源码类别：

多媒体编程

开发平台：

Visual C++

GSTextureCache.cpp：源码内容
  1. /* 
  2.  * Copyright (C) 2003-2005 Gabest
  3.  * http://www.gabest.org
  4.  *
  5.  *  This Program is free software; you can redistribute it and/or modify
  6.  *  it under the terms of the GNU General Public License as published by
  7.  *  the Free Software Foundation; either version 2, or (at your option)
  8.  *  any later version.
  9.  *   
  10.  *  This Program is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13.  *  GNU General Public License for more details.
  14.  *   
  15.  *  You should have received a copy of the GNU General Public License
  16.  *  along with GNU Make; see the file COPYING.  If not, write to
  17.  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 
  18.  *  http://www.gnu.org/copyleft/gpl.html
  19.  *
  20.  */
  22. #include "StdAfx.h"
  23. #include "GSTextureCache.h"
  24. #include "GSHash.h"
  25. #include "GSRendererHW.h"
  27. //
  29. bool IsRenderTarget(IDirect3DTexture9* pTexture)
  30. {
  31. D3DSURFACE_DESC desc;
  32. memset(&desc, 0, sizeof(desc));
  33. return pTexture && S_OK == pTexture->GetLevelDesc(0, &desc) && (desc.Usage&D3DUSAGE_RENDERTARGET);
  34. }
  36. bool HasSharedBits(DWORD sbp, DWORD spsm, DWORD dbp, DWORD dpsm)
  37. {
  38. if(sbp != dbp) return false;
  40. switch(spsm)
  41. {
  42. case PSM_PSMCT32:
  43. case PSM_PSMCT16:
  44. case PSM_PSMCT16S:
  45. case PSM_PSMT8:
  46. case PSM_PSMT4:
  47. return true;
  48. case PSM_PSMCT24:
  49. return !(dpsm == PSM_PSMT8H || dpsm == PSM_PSMT4HL || dpsm == PSM_PSMT4HH);
  50. case PSM_PSMT8H:
  51. return !(dpsm == PSM_PSMCT24);
  52. case PSM_PSMT4HL:
  53. return !(dpsm == PSM_PSMCT24 || dpsm == PSM_PSMT4HH);
  54. case PSM_PSMT4HH:
  55. return !(dpsm == PSM_PSMCT24 || dpsm == PSM_PSMT4HL);
  56. }
  58. return true;
  59. }
  61. //
  63. GSDirtyRect::GSDirtyRect(DWORD PSM, CRect r)
  64. {
  65. m_PSM = PSM;
  66. m_rcDirty = r;
  67. }
  69. CRect GSDirtyRect::GetDirtyRect(const GIFRegTEX0& TEX0)
  70. {
  71. CRect rcDirty = m_rcDirty;
  73. CSize src = GSLocalMemory::m_psmtbl[m_PSM].bs;
  74. rcDirty.left = (rcDirty.left) & ~(src.cx-1);
  75. rcDirty.right = (rcDirty.right + (src.cx-1) /* + 1 */) & ~(src.cx-1);
  76. rcDirty.top = (rcDirty.top) & ~(src.cy-1);
  77. rcDirty.bottom = (rcDirty.bottom + (src.cy-1) /* + 1 */) & ~(src.cy-1);
  79. if(m_PSM != TEX0.PSM)
  80. {
  81. CSize dst = GSLocalMemory::m_psmtbl[TEX0.PSM].bs;
  82. rcDirty.left = MulDiv(m_rcDirty.left, dst.cx, src.cx);
  83. rcDirty.right = MulDiv(m_rcDirty.right, dst.cx, src.cx);
  84. rcDirty.top = MulDiv(m_rcDirty.top, dst.cy, src.cy);
  85. rcDirty.bottom = MulDiv(m_rcDirty.bottom, dst.cy, src.cy);
  86. }
  88. rcDirty &= CRect(0, 0, 1<<TEX0.TW, 1<<TEX0.TH);
  90. return rcDirty;
  91. }
  93. void GSDirtyRectList::operator = (const GSDirtyRectList& l)
  94. {
  95. RemoveAll();
  96. POSITION pos = l.GetHeadPosition();
  97. while(pos) AddTail(l.GetNext(pos));
  98. }
  100. CRect GSDirtyRectList::GetDirtyRect(const GIFRegTEX0& TEX0)
  101. {
  102. if(IsEmpty()) return CRect(0, 0, 0, 0);
  103. CRect r(INT_MAX, INT_MAX, 0, 0);
  104. POSITION pos = GetHeadPosition();
  105. while(pos) r |= GetNext(pos).GetDirtyRect(TEX0);
  106. return r;
  107. }
  109. //
  111. GSTextureBase::GSTextureBase()
  112. {
  113. m_scale = scale_t(1, 1);
  114. m_fRT = false;
  115. memset(&m_desc, 0, sizeof(m_desc));
  116. }
  118. GSTexture::GSTexture()
  119. {
  120. m_TEX0.TBP0 = ~0;
  121. m_rcValid = CRect(0, 0, 0, 0);
  122. m_dwHash = ~0;
  123. m_nHashDiff = m_nHashSame = 0;
  124. m_rcHash = CRect(0, 0, 0, 0);
  125. m_nBytes = 0;
  126. m_nAge = 0;
  127. m_nVsyncs = 0;
  128. m_fTemp = false;
  129. }
  131. //
  133. GSTextureCache::GSTextureCache()
  134. {
  135. }
  137. GSTextureCache::~GSTextureCache()
  138. {
  139. RemoveAll();
  140. }
  142. HRESULT GSTextureCache::CreateTexture(GSState* s, GSTexture* pt, DWORD PSM, DWORD CPSM)
  143. {
  144. if(!pt || pt->m_pTexture) {ASSERT(0); return E_FAIL;}
  146. int w = 1 << pt->m_TEX0.TW;
  147. int h = 1 << pt->m_TEX0.TH;
  149. int bpp = 0;
  150. D3DFORMAT fmt = D3DFMT_UNKNOWN;
  151. D3DFORMAT palfmt = D3DFMT_UNKNOWN;
  153. switch(PSM)
  154. {
  155. default:
  156. case PSM_PSMCT32:
  157. bpp = 32;
  158. fmt = D3DFMT_A8R8G8B8;
  159. break;
  160. case PSM_PSMCT24:
  161. bpp = 32;
  162. fmt = D3DFMT_X8R8G8B8;
  163. break;
  164. case PSM_PSMCT16:
  165. case PSM_PSMCT16S:
  166. bpp = 16;
  167. fmt = D3DFMT_A1R5G5B5;
  168. break;
  169. case PSM_PSMT8:
  170. case PSM_PSMT4:
  171. case PSM_PSMT8H:
  172. case PSM_PSMT4HL:
  173. case PSM_PSMT4HH:
  174. bpp = 8;
  175. fmt = D3DFMT_L8;
  176. palfmt = CPSM == PSM_PSMCT32 ? D3DFMT_A8R8G8B8 : D3DFMT_A1R5G5B5;
  177. break;
  178. }
  180. pt->m_nBytes = w*h*bpp>>3;
  182. POSITION pos = m_pTexturePool.GetHeadPosition();
  183. while(pos)
  184. {
  185. IDirect3DTexture9* pTexture = m_pTexturePool.GetNext(pos);
  187. D3DSURFACE_DESC desc;
  188. memset(&desc, 0, sizeof(desc));
  189. pTexture->GetLevelDesc(0, &desc);
  191. if(w == desc.Width && h == desc.Height && fmt == desc.Format && !IsTextureInCache(pTexture))
  192. {
  193. pt->m_pTexture = pTexture;
  194. pt->m_desc = desc;
  195. break;
  196. }
  197. }
  199. if(!pt->m_pTexture)
  200. {
  201. while(m_pTexturePool.GetCount() > 20)
  202. m_pTexturePool.RemoveTail();
  204. if(FAILED(s->m_pD3DDev->CreateTexture(w, h, 1, 0, fmt, D3DPOOL_MANAGED, &pt->m_pTexture, NULL)))
  205. return E_FAIL;
  207. pt->m_pTexture->GetLevelDesc(0, &pt->m_desc);
  209. m_pTexturePool.AddHead(pt->m_pTexture);
  210. }
  212. if(bpp == 8)
  213. {
  214. if(FAILED(s->m_pD3DDev->CreateTexture(256, 1, 1, 0, palfmt, D3DPOOL_MANAGED, &pt->m_pPalette, NULL)))
  215. {
  216. pt->m_pTexture = NULL;
  217. return E_FAIL;
  218. }
  219. }
  221. return S_OK;
  222. }
  224. bool GSTextureCache::IsTextureInCache(IDirect3DTexture9* pTexture)
  225. {
  226. POSITION pos = GetHeadPosition();
  227. while(pos)
  228. {
  229. if(GetNext(pos)->m_pTexture == pTexture)
  230. return true;
  231. }
  233. return false;
  234. }
  236. void GSTextureCache::RemoveOldTextures(GSState* s)
  237. {
  238. DWORD nBytes = 0;
  240. POSITION pos = GetHeadPosition();
  241. while(pos) nBytes += GetNext(pos)->m_nBytes;
  243. pos = GetTailPosition();
  244. while(pos && nBytes > 96*1024*1024/*s->m_ddcaps.dwVidMemTotal*/)
  245. {
  246. #ifdef DEBUG_LOG
  247. s->LOG(_T("*TC2 too many textures in cache (%d, %.2f MB)n"), GetCount(), 1.0f*nBytes/1024/1024);
  248. #endif
  249. POSITION cur = pos;
  251. GSTexture* pt = GetPrev(pos);
  252. if(!pt->m_fRT)
  253. {
  254. nBytes -= pt->m_nBytes;
  255. RemoveAt(cur);
  256. delete pt;
  257. }
  258. }
  259. }
  261. static bool RectInRect(const RECT& inner, const RECT& outer)
  262. {
  263. return outer.left <= inner.left && inner.right <= outer.right
  264. && outer.top <= inner.top && inner.bottom <= outer.bottom;
  265. }
  267. static bool RectInRectH(const RECT& inner, const RECT& outer)
  268. {
  269. return outer.top <= inner.top && inner.bottom <= outer.bottom;
  270. }
  272. static bool RectInRectV(const RECT& inner, const RECT& outer)
  273. {
  274. return outer.left <= inner.left && inner.right <= outer.right;
  275. }
  277. bool GSTextureCache::GetDirtyRect(GSState* s, GSTexture* pt, CRect& r)
  278. {
  279. int w = 1 << pt->m_TEX0.TW;
  280. int h = 1 << pt->m_TEX0.TH;
  282. r.SetRect(0, 0, w, h);
  284. // FIXME: kyo's left hand after being selected for player one (PS2-SNK_Vs_Capcom_SVC_Chaos_PAL_CDFull.iso)
  285. // return true;
  287. s->MinMaxUV(w, h, r);
  289. CRect rcDirty = pt->m_rcDirty.GetDirtyRect(pt->m_TEX0);
  290. CRect rcValid = pt->m_rcValid;
  292. #ifdef DEBUG_LOG
  293. s->LOG(_T("*TC2 used %d,%d-%d,%d (%dx%d), valid %d,%d-%d,%d, dirty %d,%d-%d,%dn"), r, w, h, rcValid, rcDirty);
  294. #endif
  296. if(RectInRect(r, rcValid))
  297. {
  298. if(rcDirty.IsRectEmpty()) return false;
  299. else if(RectInRect(rcDirty, r)) r = rcDirty;
  300. else if(RectInRect(rcDirty, rcValid)) r |= rcDirty;
  301. else r = rcValid | rcDirty;
  302. }
  303. else
  304. {
  305. if(RectInRectH(r, rcValid) && (r.left >= rcValid.left || r.right <= rcValid.right))
  306. {
  307. r.top = rcValid.top;
  308. r.bottom = rcValid.bottom;
  309. if(r.left < rcValid.left) r.right = rcValid.left;
  310. else /*if(r.right > rcValid.right)*/ r.left = rcValid.right;
  311. }
  312. else if(RectInRectV(r, rcValid) && (r.top >= rcValid.top || r.bottom <= rcValid.bottom))
  313. {
  314. r.left = rcValid.left;
  315. r.right = rcValid.right;
  316. if(r.top < rcValid.top) r.bottom = rcValid.top;
  317. else /*if(r.bottom > rcValid.bottom)*/ r.top = rcValid.bottom;
  318. }
  319. else
  320. {
  321. r |= rcValid;
  322. }
  323. }
  325. return true;
  326. }
  328. DWORD GSTextureCache::HashTexture(const CRect& r, int pitch, void* bits)
  329. {
  330. // TODO: make the hash more unique
  332. BYTE* p = (BYTE*)bits;
  333. DWORD hash = r.left + r.right + r.top + r.bottom + pitch + *(BYTE*)bits;
  335. if(r.Width() > 0)
  336. {
  337. int size = r.Width()*r.Height();
  338. /*
  339. if(size <= 8*8) return rand(); // :P
  340. else 
  341. */
  342. if(size <= 16*16) hash += hash_crc(r, pitch, p);
  343. else if(size <= 32*32) hash += hash_adler(r, pitch, p);
  344. else hash += hash_checksum(r, pitch, p);
  345. }
  347. return hash;
  348. }
  350. HRESULT GSTextureCache::UpdateTexture(GSState* s, GSTexture* pt, GSLocalMemory::readTexture rt)
  351. {
  352. CRect r;
  353. if(!GetDirtyRect(s, pt, r))
  354. return S_OK;
  356. #ifdef DEBUG_LOG
  357. s->LOG(_T("*TC2 updating texture %d,%d-%d,%d (%dx%d)n"), r.left, r.top, r.right, r.bottom, 1 << pt->m_TEX0.TW, 1 << pt->m_TEX0.TH);
  358. #endif
  360. int bpp = 0;
  362. switch(pt->m_desc.Format)
  363. {
  364. case D3DFMT_A8R8G8B8: bpp = 32; break;
  365. case D3DFMT_X8R8G8B8: bpp = 32; break;
  366. case D3DFMT_A1R5G5B5: bpp = 16; break;
  367. case D3DFMT_L8: bpp = 8; break;
  368. default: ASSERT(0); return E_FAIL;
  369. }
  371. D3DLOCKED_RECT lr;
  372. if(FAILED(pt->m_pTexture->LockRect(0, &lr, &r, D3DLOCK_NO_DIRTY_UPDATE))) {ASSERT(0); return E_FAIL;}
  373. (s->m_lm.*rt)(r, (BYTE*)lr.pBits, lr.Pitch, s->m_ctxt->TEX0, s->m_de.TEXA, s->m_ctxt->CLAMP);
  374. s->m_perfmon.IncCounter(GSPerfMon::c_unswizzle, r.Width()*r.Height()*bpp>>3);
  375. pt->m_pTexture->UnlockRect(0);
  377. pt->m_rcValid |= r;
  378. pt->m_rcDirty.RemoveAll();
  380. const static DWORD limit = 7;
  382. if((pt->m_nHashDiff & limit) && pt->m_nHashDiff >= limit && pt->m_rcHash == pt->m_rcValid) // predicted to be dirty
  383. {
  384. pt->m_nHashDiff++;
  385. }
  386. else
  387. {
  388. if(FAILED(pt->m_pTexture->LockRect(0, &lr, &pt->m_rcValid, D3DLOCK_NO_DIRTY_UPDATE|D3DLOCK_READONLY))) {ASSERT(0); return E_FAIL;}
  389. DWORD dwHash = HashTexture(
  390. CRect((pt->m_rcValid.left>>2)*(bpp>>3), pt->m_rcValid.top, (pt->m_rcValid.right>>2)*(bpp>>3), pt->m_rcValid.bottom), 
  391. lr.Pitch, lr.pBits);
  392. pt->m_pTexture->UnlockRect(0);
  394. if(pt->m_rcHash != pt->m_rcValid)
  395. {
  396. pt->m_nHashDiff = 0;
  397. pt->m_nHashSame = 0;
  398. pt->m_rcHash = pt->m_rcValid;
  399. pt->m_dwHash = dwHash;
  400. }
  401. else
  402. {
  403. if(pt->m_dwHash != dwHash)
  404. {
  405. pt->m_nHashDiff++;
  406. pt->m_nHashSame = 0;
  407. pt->m_dwHash = dwHash;
  408. }
  409. else
  410. {
  411. if(pt->m_nHashDiff < limit) r.SetRect(0, 0, 1, 1);
  412. // else pt->m_dwHash is not reliable, must update
  413. pt->m_nHashDiff = 0;
  414. pt->m_nHashSame++;
  415. }
  416. }
  417. }
  419. pt->m_pTexture->AddDirtyRect(&r);
  420. pt->m_pTexture->PreLoad();
  421. s->m_perfmon.IncCounter(GSPerfMon::c_texture, r.Width()*r.Height()*bpp>>3);
  423. #ifdef DEBUG_LOG
  424. s->LOG(_T("*TC2 texture was updated, valid %d,%dx%d,%dn"), pt->m_rcValid);
  425. #endif
  427. #ifdef DEBUG_SAVETEXTURES   
  428. if(s->m_ctxt->FRAME.Block() == 0x00000 && pt->m_TEX0.TBP0 == 0x02800)
  429. {   
  430. CString fn;   
  431. fn.Format(_T("c:\%08I64x_%I64d_%I64d_%I64d_%I64d_%I64d_%I64d_%I64d-%I64d_%I64d-%I64d.bmp"),   
  432. pt->m_TEX0.TBP0, pt->m_TEX0.PSM, pt->m_TEX0.TBW,   
  433. pt->m_TEX0.TW, pt->m_TEX0.TH,   
  434. pt->m_CLAMP.WMS, pt->m_CLAMP.WMT, pt->m_CLAMP.MINU, pt->m_CLAMP.MAXU, pt->m_CLAMP.MINV, pt->m_CLAMP.MAXV);   
  435. D3DXSaveTextureToFile(fn, D3DXIFF_BMP, pt->m_pTexture, NULL);   
  436. }   
  437. #endif 
  439. return S_OK;
  440. }
  442. GSTexture* GSTextureCache::ConvertRTPitch(GSState* s, GSTexture* pt)
  443. {
  444. if(pt->m_TEX0.TBW == s->m_ctxt->TEX0.TBW)
  445. return pt;
  447. // sfex3 uses this trick (bw: 10 -> 5, wraps the right side below the left)
  448. ASSERT(pt->m_TEX0.TBW > s->m_ctxt->TEX0.TBW); // otherwise scale.x need to be reduced to make the larger texture fit (TODO)
  450. int bw = 64;
  451. int bh = s->m_ctxt->TEX0.PSM == PSM_PSMCT32 || s->m_ctxt->TEX0.PSM == PSM_PSMCT24 ? 32 : 64;
  453. int sw = pt->m_TEX0.TBW << 6;
  455. int dw = s->m_ctxt->TEX0.TBW << 6;
  456. int dh = 1 << s->m_ctxt->TEX0.TH;
  458. // TRACE(_T("ConvertRT: %05x %x %d -> %dn"), (DWORD)s->m_ctxt->TEX0.TBP0, (DWORD)s->m_ctxt->TEX0.PSM, (DWORD)pt->m_TEX0.TBW, (DWORD)s->m_ctxt->TEX0.TBW);
  460. HRESULT hr;
  461. /*
  462. if(s->m_perfmon.GetFrame() > 400)
  463. hr = D3DXSaveTextureToFile(_T("g:/1.bmp"), D3DXIFF_BMP, pt->m_pTexture, NULL);
  464. */
  465. D3DSURFACE_DESC desc;
  466. hr = pt->m_pTexture->GetLevelDesc(0, &desc);
  467. if(FAILED(hr)) return NULL;
  469. CComPtr<IDirect3DTexture9> pRT;
  470. if(FAILED(hr = CreateRT(s, desc.Width, desc.Height, &pRT)))
  471. return NULL;
  473. CComPtr<IDirect3DSurface9> pSrc, pDst;
  474. hr = pRT->GetSurfaceLevel(0, &pSrc);
  475. if(FAILED(hr)) return NULL;
  476. hr = pt->m_pTexture->GetSurfaceLevel(0, &pDst);
  477. if(FAILED(hr)) return NULL;
  479. hr = s->m_pD3DDev->StretchRect(pDst, NULL, pSrc, NULL, D3DTEXF_POINT);
  480. if(FAILED(hr)) return NULL;
  482. scale_t scale(pt->m_pTexture);
  484. for(int dy = 0; dy < dh; dy += bh)
  485. {
  486. for(int dx = 0; dx < dw; dx += bw)
  487. {
  488. int o = dy * dw / bh + dx;
  490. int sx = o % sw;
  491. int sy = o / sw;
  493. // TRACE(_T("%d,%d - %d,%d  <=  %d,%d - %d,%dn"), dx, dy, dx + bw, dy + bh, sx, sy, sx + bw, sy + bh);
  495. CRect src, dst;
  497. src.left = (LONG)(scale.x * sx + 0.5f);
  498. src.top = (LONG)(scale.y * sy + 0.5f);
  499. src.right = (LONG)(scale.x * (sx + bw) + 0.5f);
  500. src.bottom = (LONG)(scale.y * (sy + bh) + 0.5f);
  502. dst.left = (LONG)(scale.x * dx + 0.5f);
  503. dst.top = (LONG)(scale.y * dy + 0.5f);
  504. dst.right = (LONG)(scale.x * (dx + bw) + 0.5f);
  505. dst.bottom = (LONG)(scale.y * (dy + bh) + 0.5f);
  507. hr = s->m_pD3DDev->StretchRect(pSrc, src, pDst, dst, D3DTEXF_POINT);
  509. // TODO: this is quite a lot of StretchRect call, do it with one DrawPrimUP
  510. }
  511. }
  513. pt->m_TEX0.TW = s->m_ctxt->TEX0.TW;
  514. pt->m_TEX0.TBW = s->m_ctxt->TEX0.TBW;
  515. /*
  516. if(s->m_perfmon.GetFrame() > 400)
  517. hr = D3DXSaveTextureToFile(_T("g:/2.bmp"), D3DXIFF_BMP, pt->m_pTexture, NULL);
  518. */
  520. return pt;
  521. }
  523. GSTexture* GSTextureCache::ConvertRTWidthHeight(GSState* s, GSTexture* pt)
  524. {
  525. int tw = pt->m_scale.x * (1 << s->m_ctxt->TEX0.TW);
  526. int th = pt->m_scale.y * (1 << s->m_ctxt->TEX0.TH);
  528. int rw = pt->m_desc.Width;
  529. int rh = pt->m_desc.Height;
  531. if(tw != rw || th != rh)
  532. //if(tw < rw && th <= rh || tw <= rw && th < rh)
  533. {
  534. GSTexture* pt2 = new GSTexture();
  536. pt2->m_pPalette = pt->m_pPalette;
  537. pt2->m_fRT = pt->m_pPalette == NULL;
  538. pt2->m_scale = pt->m_scale;
  539. pt2->m_fTemp = true;
  541. POSITION pos = pt->m_pSubTextures.GetHeadPosition();
  542. while(pos)
  543. {
  544. IDirect3DTexture9* pTexture = pt->m_pSubTextures.GetNext(pos);
  545. pTexture->GetLevelDesc(0, &pt2->m_desc);
  546. scale_t scale(pTexture);
  547. if(pt2->m_desc.Width == tw && pt2->m_desc.Height == th
  548. && pt2->m_scale.x == scale.x && pt2->m_scale.y == scale.y)
  549. {
  550. pt2->m_pTexture = pTexture;
  551. break;
  552. }
  553. }
  555. if(!pt2->m_pTexture)
  556. {
  557. CRect dst(0, 0, tw, th);
  559. if(tw > rw)
  560. {
  561. pt2->m_scale.x = pt2->m_scale.x * rw / tw;
  562. dst.right = rw * rw / tw;
  563. tw = rw;
  564. }
  566. if(th > rh)
  567. {
  568. pt2->m_scale.y = pt2->m_scale.y * rh / th;
  569. dst.bottom = rh * rh / th;
  570. th = rh;
  571. }
  573. CRect src(0, 0, tw, th);
  575. HRESULT hr;
  577. if(FAILED(hr = CreateRT(s, tw, th, &pt2->m_pTexture)) || FAILED(hr = pt2->m_pTexture->GetLevelDesc(0, &pt2->m_desc)))
  578. {
  579. delete pt2; 
  580. return false;
  581. }
  583. CComPtr<IDirect3DSurface9> pSrc, pDst;
  584. hr = pt->m_pTexture->GetSurfaceLevel(0, &pSrc);
  585. hr = pt2->m_pTexture->GetSurfaceLevel(0, &pDst);
  587. ASSERT(pSrc);
  588. ASSERT(pDst);
  590. hr = s->m_pD3DDev->StretchRect(pSrc, src, pDst, dst, src == dst ? D3DTEXF_POINT : D3DTEXF_LINEAR);
  592. pt2->m_scale.Set(pt2->m_pTexture);
  593. pt->m_pSubTextures.AddTail(pt2->m_pTexture);
  594. }
  596. pt = pt2;
  597. }
  599. return pt;
  600. }
  602. HRESULT GSTextureCache::CreateRT(GSState* s, int w, int h, IDirect3DTexture9** ppRT)
  603. {
  604. ASSERT(ppRT && *ppRT == NULL);
  606. HRESULT hr;
  608. POSITION pos = m_pRTPool.GetHeadPosition();
  609. while(pos)
  610. {
  611. IDirect3DTexture9* pRT = m_pRTPool.GetNext(pos);
  612. D3DSURFACE_DESC desc;
  613. pRT->GetLevelDesc(0, &desc);
  614. if(desc.Width == w && desc.Height == h)
  615. {
  616. (*ppRT = pRT)->AddRef();
  617. return S_OK;
  618. }
  619. }
  621. hr = s->m_pD3DDev->CreateTexture(w, h, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, ppRT, NULL);
  622. if(FAILED(hr)) return hr;
  623. /**/
  624. m_pRTPool.AddHead(*ppRT);
  625. while(m_pRTPool.GetCount() > 3) m_pRTPool.RemoveTail();
  627. return S_OK;
  628. }
  630. GSTexture* GSTextureCache::ConvertRT(GSState* s, GSTexture* pt)
  631. {
  632. ASSERT(pt->m_fRT);
  634. // FIXME: RT + 8h,4hl,4hh
  636. if(s->m_ctxt->TEX0.PSM == PSM_PSMT8H)
  637. {
  638. if(!pt->m_pPalette)
  639. {
  640. if(FAILED(s->m_pD3DDev->CreateTexture(256, 1, 1, 0, s->m_ctxt->TEX0.CPSM == PSM_PSMCT32 ? D3DFMT_A8R8G8B8 : D3DFMT_A1R5G5B5, D3DPOOL_MANAGED, &pt->m_pPalette, NULL)))
  641. return NULL;
  642. }
  643. }
  644. else if(GSLocalMemory::m_psmtbl[s->m_ctxt->TEX0.PSM].pal)
  645. {
  646. return NULL;
  647. }
  649. pt = ConvertRTPitch(s, pt);
  651. pt = ConvertRTWidthHeight(s, pt);
  653. return pt;
  654. }
  656. bool GSTextureCache::Fetch(GSState* s, GSTextureBase& t)
  657. {
  658. GSTexture* pt = NULL;
  660. int nPaletteEntries = GSLocalMemory::m_psmtbl[s->m_ctxt->TEX0.PSM].pal;
  662. DWORD clut[256];
  664. if(nPaletteEntries)
  665. {
  666. s->m_lm.SetupCLUT32(s->m_ctxt->TEX0, s->m_de.TEXA);
  667. s->m_lm.CopyCLUT32(clut, nPaletteEntries);
  668. }
  670. #ifdef DEBUG_LOG
  671. s->LOG(_T("*TC2 Fetch %dx%d %05I64x %I64d (%d)n"), 
  672. 1 << s->m_ctxt->TEX0.TW, 1 << s->m_ctxt->TEX0.TH, 
  673. s->m_ctxt->TEX0.TBP0, s->m_ctxt->TEX0.PSM, nPaletteEntries);
  674. #endif
  676. enum lookupresult {notfound, needsupdate, found} lr = notfound;
  678. POSITION pos = GetHeadPosition();
  679. while(pos && !pt)
  680. {
  681. POSITION cur = pos;
  682. pt = GetNext(pos);
  684. if(HasSharedBits(pt->m_TEX0.TBP0, pt->m_TEX0.PSM, s->m_ctxt->TEX0.TBP0, s->m_ctxt->TEX0.PSM))
  685. {
  686. if(pt->m_fRT)
  687. {
  688. lr = found;
  690. if(!(pt = ConvertRT(s, pt)))
  691. return false;
  692. }
  693. else if(s->m_ctxt->TEX0.PSM == pt->m_TEX0.PSM && pt->m_TEX0.TBW == s->m_ctxt->TEX0.TBW
  694. && s->m_ctxt->TEX0.TW == pt->m_TEX0.TW && s->m_ctxt->TEX0.TH == pt->m_TEX0.TH
  695. && (!(s->m_ctxt->CLAMP.WMS&2) && !(pt->m_CLAMP.WMS&2) && !(s->m_ctxt->CLAMP.WMT&2) && !(pt->m_CLAMP.WMT&2) || s->m_ctxt->CLAMP.i64 == pt->m_CLAMP.i64)
  696. && s->m_de.TEXA.TA0 == pt->m_TEXA.TA0 && s->m_de.TEXA.TA1 == pt->m_TEXA.TA1 && s->m_de.TEXA.AEM == pt->m_TEXA.AEM
  697. && (!nPaletteEntries || s->m_ctxt->TEX0.CPSM == pt->m_TEX0.CPSM && !memcmp(pt->m_clut, clut, nPaletteEntries*sizeof(clut[0]))))
  698. {
  699. lr = needsupdate;
  700. }
  701. }
  703. if(lr != notfound) {MoveToHead(cur); break;}
  705. pt = NULL;
  706. }
  708. #ifdef DEBUG_LOG
  709. s->LOG(_T("*TC2 lr = %sn"), lr == found ? _T("found") : lr == needsupdate ? _T("needsupdate") : _T("notfound"));
  710. #endif
  712. if(lr == notfound)
  713. {
  714. pt = new GSTexture();
  716. pt->m_TEX0 = s->m_ctxt->TEX0;
  717. pt->m_CLAMP = s->m_ctxt->CLAMP;
  718. pt->m_TEXA = s->m_de.TEXA;
  720. if(!SUCCEEDED(CreateTexture(s, pt, PSM_PSMCT32)))
  721. {
  722. delete pt;
  723. return false;
  724. }
  726. RemoveOldTextures(s);
  728. AddHead(pt);
  730. lr = needsupdate;
  731. }
  733. ASSERT(pt);
  735. if(pt && nPaletteEntries)
  736. {
  737. memcpy(pt->m_clut, clut, nPaletteEntries*sizeof(clut[0]));
  738. }
  740. if(lr == needsupdate)
  741. {
  742. UpdateTexture(s, pt, &GSLocalMemory::ReadTexture);
  744. lr = found;
  745. }
  747. if(lr == found)
  748. {
  749. #ifdef DEBUG_LOG
  750. s->LOG(_T("*TC2 texture was found, age %d -> 0n"), pt->m_nAge);
  751. #endif
  752. pt->m_nAge = 0;
  753. t = *pt;
  754. if(pt->m_fTemp) delete pt;
  755. return true;
  756. }
  758. return false;
  759. }
  761. bool GSTextureCache::FetchP(GSState* s, GSTextureBase& t)
  762. {
  763. GSTexture* pt = NULL;
  765. int nPaletteEntries = GSLocalMemory::m_psmtbl[s->m_ctxt->TEX0.PSM].pal;
  767. #ifdef DEBUG_LOG
  768. s->LOG(_T("*TC2 Fetch %dx%d %05I64x %I64d (%d)n"), 
  769. 1 << s->m_ctxt->TEX0.TW, 1 << s->m_ctxt->TEX0.TH, 
  770. s->m_ctxt->TEX0.TBP0, s->m_ctxt->TEX0.PSM, nPaletteEntries);
  771. #endif
  773. enum lookupresult {notfound, needsupdate, found} lr = notfound;
  775. POSITION pos = GetHeadPosition();
  776. while(pos && !pt)
  777. {
  778. POSITION cur = pos;
  779. pt = GetNext(pos);
  781. if(HasSharedBits(pt->m_TEX0.TBP0, pt->m_TEX0.PSM, s->m_ctxt->TEX0.TBP0, s->m_ctxt->TEX0.PSM))
  782. {
  783. if(pt->m_fRT)
  784. {
  785. lr = found;
  787. if(!(pt = ConvertRT(s, pt)))
  788. return false;
  789. }
  790. else if(s->m_ctxt->TEX0.PSM == pt->m_TEX0.PSM && pt->m_TEX0.TBW == s->m_ctxt->TEX0.TBW
  791. && s->m_ctxt->TEX0.TW == pt->m_TEX0.TW && s->m_ctxt->TEX0.TH == pt->m_TEX0.TH
  792. && (!(s->m_ctxt->CLAMP.WMS&2) && !(pt->m_CLAMP.WMS&2) && !(s->m_ctxt->CLAMP.WMT&2) && !(pt->m_CLAMP.WMT&2) || s->m_ctxt->CLAMP.i64 == pt->m_CLAMP.i64))
  793. {
  794. lr = needsupdate;
  795. }
  796. }
  798. if(lr != notfound) {MoveToHead(cur); break;}
  800. pt = NULL;
  801. }
  803. #ifdef DEBUG_LOG
  804. s->LOG(_T("*TC2 lr = %sn"), lr == found ? _T("found") : lr == needsupdate ? _T("needsupdate") : _T("notfound"));
  805. #endif
  807. if(lr == notfound)
  808. {
  809. pt = new GSTexture();
  811. pt->m_TEX0 = s->m_ctxt->TEX0;
  812. pt->m_CLAMP = s->m_ctxt->CLAMP;
  813. // pt->m_TEXA = s->m_de.TEXA;
  815. if(!SUCCEEDED(CreateTexture(s, pt, s->m_ctxt->TEX0.PSM, PSM_PSMCT32)))
  816. {
  817. delete pt;
  818. return false;
  819. }
  821. RemoveOldTextures(s);
  823. AddHead(pt);
  825. lr = needsupdate;
  826. }
  828. ASSERT(pt);
  830. if(pt && pt->m_pPalette) 
  831. {
  832. D3DLOCKED_RECT r;
  833. if(FAILED(pt->m_pPalette->LockRect(0, &r, NULL, 0)))
  834. return false;
  835. s->m_lm.ReadCLUT32(s->m_ctxt->TEX0, s->m_de.TEXA, (DWORD*)r.pBits);
  836. pt->m_pPalette->UnlockRect(0);
  837. s->m_perfmon.IncCounter(GSPerfMon::c_texture, 256*4);
  838. }
  840. if(lr == needsupdate)
  841. {
  842. UpdateTexture(s, pt, &GSLocalMemory::ReadTextureP);
  844. lr = found;
  845. }
  847. if(lr == found)
  848. {
  849. #ifdef DEBUG_LOG
  850. s->LOG(_T("*TC2 texture was found, age %d -> 0n"), pt->m_nAge);
  851. #endif
  852. pt->m_nAge = 0;
  853. t = *pt;
  854. if(pt->m_fTemp) delete pt;
  855. return true;
  856. }
  858. return false;
  859. }
  861. bool GSTextureCache::FetchNP(GSState* s, GSTextureBase& t)
  862. {
  863. GSTexture* pt = NULL;
  865. int nPaletteEntries = GSLocalMemory::m_psmtbl[s->m_ctxt->TEX0.PSM].pal;
  867. DWORD clut[256];
  869. if(nPaletteEntries)
  870. {
  871. s->m_lm.SetupCLUT(s->m_ctxt->TEX0, s->m_de.TEXA);
  872. s->m_lm.CopyCLUT32(clut, nPaletteEntries);
  873. }
  875. #ifdef DEBUG_LOG
  876. s->LOG(_T("*TC2 Fetch %dx%d %05I64x %I64d (%d)n"), 
  877. 1 << s->m_ctxt->TEX0.TW, 1 << s->m_ctxt->TEX0.TH, 
  878. s->m_ctxt->TEX0.TBP0, s->m_ctxt->TEX0.PSM, nPaletteEntries);
  879. #endif
  881. enum lookupresult {notfound, needsupdate, found} lr = notfound;
  883. POSITION pos = GetHeadPosition();
  884. while(pos && !pt)
  885. {
  886. POSITION cur = pos;
  887. pt = GetNext(pos);
  889. if(HasSharedBits(pt->m_TEX0.TBP0, pt->m_TEX0.PSM, s->m_ctxt->TEX0.TBP0, s->m_ctxt->TEX0.PSM))
  890. {
  891. if(pt->m_fRT)
  892. {
  893. lr = found;
  895. if(!(pt = ConvertRT(s, pt)))
  896. return false;
  897. }
  898. else if(s->m_ctxt->TEX0.PSM == pt->m_TEX0.PSM && pt->m_TEX0.TBW == s->m_ctxt->TEX0.TBW
  899. && s->m_ctxt->TEX0.TW == pt->m_TEX0.TW && s->m_ctxt->TEX0.TH == pt->m_TEX0.TH
  900. && (!(s->m_ctxt->CLAMP.WMS&2) && !(pt->m_CLAMP.WMS&2) && !(s->m_ctxt->CLAMP.WMT&2) && !(pt->m_CLAMP.WMT&2) || s->m_ctxt->CLAMP.i64 == pt->m_CLAMP.i64)
  901. // && s->m_de.TEXA.TA0 == pt->m_TEXA.TA0 && s->m_de.TEXA.TA1 == pt->m_TEXA.TA1 && s->m_de.TEXA.AEM == pt->m_TEXA.AEM
  902. && (!nPaletteEntries || s->m_ctxt->TEX0.CPSM == pt->m_TEX0.CPSM && !memcmp(pt->m_clut, clut, nPaletteEntries*sizeof(clut[0]))))
  903. {
  904. lr = needsupdate;
  905. }
  906. }
  908. if(lr != notfound) {MoveToHead(cur); break;}
  910. pt = NULL;
  911. }
  913. #ifdef DEBUG_LOG
  914. s->LOG(_T("*TC2 lr = %sn"), lr == found ? _T("found") : lr == needsupdate ? _T("needsupdate") : _T("notfound"));
  915. #endif
  917. if(lr == notfound)
  918. {
  919. pt = new GSTexture();
  921. pt->m_TEX0 = s->m_ctxt->TEX0;
  922. pt->m_CLAMP = s->m_ctxt->CLAMP;
  923. // pt->m_TEXA = s->m_de.TEXA;
  925. DWORD psm = s->m_ctxt->TEX0.PSM;
  927. switch(psm)
  928. {
  929. case PSM_PSMT8:
  930. case PSM_PSMT8H:
  931. case PSM_PSMT4:
  932. case PSM_PSMT4HL:
  933. case PSM_PSMT4HH:
  934. psm = s->m_ctxt->TEX0.CPSM;
  935. break;
  936. }
  938. if(!SUCCEEDED(CreateTexture(s, pt, psm)))
  939. {
  940. delete pt;
  941. return false;
  942. }
  944. RemoveOldTextures(s);
  946. AddHead(pt);
  948. lr = needsupdate;
  949. }
  951. ASSERT(pt);
  953. if(pt && nPaletteEntries)
  954. {
  955. memcpy(pt->m_clut, clut, nPaletteEntries*sizeof(clut[0]));
  956. }
  958. if(lr == needsupdate)
  959. {
  960. UpdateTexture(s, pt, &GSLocalMemory::ReadTextureNP);
  962. lr = found;
  963. }
  965. if(lr == found)
  966. {
  967. #ifdef DEBUG_LOG
  968. s->LOG(_T("*TC2 texture was found, age %d -> 0n"), pt->m_nAge);
  969. #endif
  970. pt->m_nAge = 0;
  971. t = *pt;
  972. if(pt->m_fTemp) delete pt;
  973. return true;
  974. }
  976. return false;
  977. }
  979. void GSTextureCache::IncAge(CSurfMap<IDirect3DTexture9>& pRTs)
  980. {
  981. POSITION pos = GetHeadPosition();
  982. while(pos)
  983. {
  984. POSITION cur = pos;
  985. GSTexture* pt = GetNext(pos);
  986. pt->m_nAge++;
  987. pt->m_nVsyncs++;
  988. if(pt->m_nAge > 10 && (!pt->m_fRT || pRTs.GetCount() > 3))
  989. {
  990. pRTs.RemoveKey(pt->m_TEX0.TBP0);
  991. RemoveAt(cur);
  992. delete pt;
  993. }
  994. }
  995. }
  997. void GSTextureCache::ResetAge(DWORD TBP0)
  998. {
  999. POSITION pos = GetHeadPosition();
  1000. while(pos)
  1001. {
  1002. GSTexture* pt = GetNext(pos);
  1003. if(pt->m_TEX0.TBP0 == TBP0) pt->m_nAge = 0;
  1004. }
  1005. }
  1007. void GSTextureCache::RemoveAll()
  1008. {
  1009. while(GetCount()) delete RemoveHead();
  1010. m_pTexturePool.RemoveAll();
  1011. m_pRTPool.RemoveAll();
  1012. }
  1014. void GSTextureCache::InvalidateTexture(GSState* s, const GIFRegBITBLTBUF& BITBLTBUF, const CRect& r)
  1015. {
  1016. GIFRegTEX0 TEX0;
  1017. TEX0.TBP0 = BITBLTBUF.DBP;
  1018. TEX0.TBW = BITBLTBUF.DBW;
  1019. TEX0.PSM = BITBLTBUF.DPSM;
  1020. TEX0.TCC = 0;
  1022. #ifdef DEBUG_LOG
  1023. s->LOG(_T("*TC2 invalidate %05x %x (%d,%d-%d,%d)n"), TEX0.TBP0, TEX0.PSM, r.left, r.top, r.right, r.bottom);
  1024. #endif
  1026. POSITION pos = GetHeadPosition();
  1027. while(pos)
  1028. {
  1029. POSITION cur = pos;
  1030. GSTexture* pt = GetNext(pos);
  1031. if(HasSharedBits(TEX0.TBP0, TEX0.PSM, pt->m_TEX0.TBP0, pt->m_TEX0.PSM)) 
  1032. {
  1033. if(TEX0.TBW != pt->m_TEX0.TBW)
  1034. {
  1035. // if TEX0.TBW != pt->m_TEX0.TBW then this render target is more likely to 
  1036. // be discarded by the game (means it doesn't want to transfer an image over 
  1037. // another pre-rendered image) and can be refetched from local mem safely.
  1039. RemoveAt(cur);
  1040. delete pt;
  1041. }
  1042. else if(pt->m_fRT) 
  1043. {
  1044. // TEX0.TBW = pt->m_TEX0.TBW;
  1045. TEX0.PSM = pt->m_TEX0.PSM;
  1047. if(TEX0.PSM == PSM_PSMCT32 || TEX0.PSM == PSM_PSMCT24 
  1048. || TEX0.PSM == PSM_PSMCT16 || TEX0.PSM == PSM_PSMCT16S) 
  1049. {
  1050. // pt->m_rcDirty.AddHead(GSDirtyRect(PSM, r));
  1052. HRESULT hr;
  1054. int tw = (r.Width() + 3) & ~3;
  1055. int th = r.Height();
  1057. CComPtr<IDirect3DTexture9> pSrc;
  1058. hr = s->m_pD3DDev->CreateTexture(tw, th, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &pSrc, NULL);
  1060. D3DLOCKED_RECT lr;
  1061. if(pSrc && SUCCEEDED(pSrc->LockRect(0, &lr, NULL, 0)))
  1062. {
  1063. GIFRegTEXA TEXA;
  1064. TEXA.AEM = 1;
  1065. TEXA.TA0 = 0;
  1066. TEXA.TA1 = 0x80;
  1068. GIFRegCLAMP CLAMP;
  1069. CLAMP.WMS = 0;
  1070. CLAMP.WMT = 0;
  1072. s->m_lm.ReadTexture(r, (BYTE*)lr.pBits, lr.Pitch, TEX0, TEXA, CLAMP);
  1073. s->m_perfmon.IncCounter(GSPerfMon::c_unswizzle, r.Width()*r.Height()*4);
  1075. pSrc->UnlockRect(0);
  1077. scale_t scale(pt->m_pTexture);
  1079. CRect dst;
  1080. dst.left = (long)(scale.x * r.left + 0.5);
  1081. dst.top = (long)(scale.y * r.top + 0.5);
  1082. dst.right = (long)(scale.x * r.right + 0.5);
  1083. dst.bottom = (long)(scale.y * r.bottom + 0.5);
  1085. //
  1087. CComPtr<IDirect3DSurface9> pRTSurf;
  1088. hr = pt->m_pTexture->GetSurfaceLevel(0, &pRTSurf);
  1089. hr = s->m_pD3DDev->SetRenderTarget(0, pRTSurf);
  1090. hr = s->m_pD3DDev->SetDepthStencilSurface(NULL);
  1092. hr = s->m_pD3DDev->SetTexture(0, pSrc);
  1093. hr = s->m_pD3DDev->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
  1094. hr = s->m_pD3DDev->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
  1095. hr = s->m_pD3DDev->SetRenderState(D3DRS_ZENABLE, FALSE);
  1096. hr = s->m_pD3DDev->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
  1097. hr = s->m_pD3DDev->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
  1098. hr = s->m_pD3DDev->SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD);
  1099. hr = s->m_pD3DDev->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE);
  1100. hr = s->m_pD3DDev->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ZERO);
  1101. hr = s->m_pD3DDev->SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
  1102. hr = s->m_pD3DDev->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RGBA);
  1104. hr = s->m_pD3DDev->SetPixelShader(NULL);
  1106. struct
  1107. {
  1108. float x, y, z, rhw;
  1109. float tu, tv;
  1110. }
  1111. pVertices[] =
  1112. {
  1113. {(float)dst.left, (float)dst.top, 0.5f, 2.0f, 0, 0},
  1114. {(float)dst.right, (float)dst.top, 0.5f, 2.0f, 1.0f * r.Width() / tw, 0},
  1115. {(float)dst.left, (float)dst.bottom, 0.5f, 2.0f, 0, 1},
  1116. {(float)dst.right, (float)dst.bottom, 0.5f, 2.0f, 1.0f * r.Width() / tw, 1},
  1117. };
  1119. hr = s->m_pD3DDev->BeginScene();
  1120. hr = s->m_pD3DDev->SetFVF(D3DFVF_XYZRHW | D3DFVF_TEX1);
  1121. hr = s->m_pD3DDev->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, pVertices, sizeof(pVertices[0]));
  1122. hr = s->m_pD3DDev->EndScene();
  1124. }
  1125. }
  1126. else
  1127. {
  1128. RemoveAt(cur);
  1129. delete pt;
  1130. }
  1131. }
  1132. else
  1133. {
  1134. pt->m_rcDirty.AddHead(GSDirtyRect(TEX0.PSM, r));
  1135. }
  1136. }
  1137. }
  1138. }
  1140. void GSTextureCache::InvalidateLocalMem(GSState* s, DWORD TBP0, DWORD BW, DWORD PSM, const CRect& r)
  1141. {
  1142. CComPtr<IDirect3DTexture9> pRT;
  1144. POSITION pos = GetHeadPosition();
  1145. while(pos)
  1146. {
  1147. POSITION cur = pos;
  1148. GSTexture* pt = GetNext(pos);
  1149. if(pt->m_TEX0.TBP0 == TBP0 && pt->m_fRT) 
  1150. {
  1151. pRT = pt->m_pTexture;
  1152. break;
  1153. }
  1154. }
  1156. if(!pRT) return;
  1158. // TODO: add resizing
  1159. /*
  1160. HRESULT hr;
  1162. D3DSURFACE_DESC desc;
  1163. hr = pRT->GetLevelDesc(0, &desc);
  1164. if(FAILED(hr)) return;
  1166. CComPtr<IDirect3DSurface9> pVidMem;
  1167. hr = pRT->GetSurfaceLevel(0, &pVidMem);
  1168. if(FAILED(hr)) return;
  1170. CComPtr<IDirect3DSurface9> pSysMem;
  1171. hr = s->m_pD3DDev->CreateOffscreenPlainSurface(desc.Width, desc.Height, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &pSysMem, NULL);
  1172. if(FAILED(hr)) return;
  1174. hr = s->m_pD3DDev->GetRenderTargetData(pVidMem, pSysMem);
  1175. if(FAILED(hr)) return;
  1177. D3DLOCKED_RECT lr;
  1178. hr = pSysMem->LockRect(&lr, &r, D3DLOCK_READONLY|D3DLOCK_NO_DIRTY_UPDATE);
  1179. if(SUCCEEDED(hr))
  1180. {
  1181. BYTE* p = (BYTE*)lr.pBits;
  1183. if(0 && r.left == 0 && r.top == 0 && PSM == PSM_PSMCT32)
  1184. {
  1185. }
  1186. else
  1187. {
  1188. GSLocalMemory::writeFrame wf = s->m_lm.GetWriteFrame(PSM);
  1190. for(int y = r.top; y < r.bottom; y++, p += lr.Pitch)
  1191. {
  1192. for(int x = r.left; x < r.right; x++)
  1193. {
  1194. (s->m_lm.*wf)(x, y, ((DWORD*)p)[x], TBP0, BW);
  1195. }
  1196. }
  1197. }
  1199. pSysMem->UnlockRect();
  1200. }
  1201. */
  1202. }
  1204. void GSTextureCache::AddRT(GIFRegTEX0& TEX0, IDirect3DTexture9* pRT, scale_t scale)
  1205. {
  1206. POSITION pos = GetHeadPosition();
  1207. while(pos)
  1208. {
  1209. POSITION cur = pos;
  1210. GSTexture* pt = GetNext(pos);
  1211. if(HasSharedBits(TEX0.TBP0, TEX0.PSM, pt->m_TEX0.TBP0, pt->m_TEX0.PSM))
  1212. {
  1213. RemoveAt(cur);
  1214. delete pt;
  1215. }
  1216. }
  1218. GSTexture* pt = new GSTexture();
  1219. pt->m_TEX0 = TEX0;
  1220. pt->m_pTexture = pRT;
  1221. pt->m_pTexture->GetLevelDesc(0, &pt->m_desc);
  1222. pt->m_scale = scale;
  1223. pt->m_fRT = true;
  1225. AddHead(pt);
  1226. }