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

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

多媒体编程

开发平台：

Visual C++

GSRendererHW.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 "GSRendererHW.h"
  25. #define INTERNALRESX 1024
  26. #define INTERNALRESY 1024
  28. inline BYTE SCALE_ALPHA(BYTE a) 
  29. {
  30. return (((a)&0x80)?0xff:((a)<<1));
  31. }
  33. static const float one_over_log_2pow32 = 1.0f / (log(2.0f)*32);
  35. //
  37. GSRendererHW::GSRendererHW(HWND hWnd, HRESULT& hr)
  38. : GSRenderer<GSVertexHW>(INTERNALRESX, INTERNALRESY, hWnd, hr)
  39. {
  40. Reset();
  41. }
  43. GSRendererHW::~GSRendererHW()
  44. {
  45. }
  47. HRESULT GSRendererHW::ResetDevice(bool fForceWindowed)
  48. {
  49. m_pRTs.RemoveAll();
  50. m_pDSs.RemoveAll();
  51. m_tc.RemoveAll();
  53. return __super::ResetDevice(fForceWindowed);
  54. }
  56. void GSRendererHW::Reset()
  57. {
  58. m_primtype = D3DPT_FORCE_DWORD;
  60. m_tc.RemoveAll();
  62. m_pRTs.RemoveAll();
  63. m_pDSs.RemoveAll();
  65. POSITION pos = m_pRenderWnds.GetStartPosition();
  66. while(pos)
  67. {
  68. DWORD FBP;
  69. CGSWnd* pWnd = NULL;
  70. m_pRenderWnds.GetNextAssoc(pos, FBP, pWnd);
  71. pWnd->DestroyWindow();
  72. delete pWnd;
  73. }
  74. m_pRenderWnds.RemoveAll();
  76. __super::Reset();
  77. }
  79. void GSRendererHW::VertexKick(bool fSkip)
  80. {
  81. GSVertexHW& v = m_vl.AddTail();
  83. v.x = (float)((int)m_v.XYZ.X - (int)m_ctxt->XYOFFSET.OFX) * (1.0f/16);
  84. v.y = (float)((int)m_v.XYZ.Y - (int)m_ctxt->XYOFFSET.OFY) * (1.0f/16);
  85. //if(m_v.XYZ.Z && m_v.XYZ.Z < 0x100) m_v.XYZ.Z = 0x100;
  86. //v.z = 1.0f * (m_v.XYZ.Z>>8)/(UINT_MAX>>8);
  87. v.z = log(1.0f + m_v.XYZ.Z) * one_over_log_2pow32;
  88. //v.z = (float)m_v.XYZ.Z / UINT_MAX;
  89. //v.rhw = v.z ? 1.0f/v.z : 1.0f;
  90. v.rhw = m_v.RGBAQ.Q > 0 ? m_v.RGBAQ.Q : 1.0f; // TODO
  91. //v.rhw = m_v.RGBAQ.Q;
  93. v.color = m_v.RGBAQ.ai32[0];
  95. if(m_pPRIM->TME)
  96. {
  97. if(m_pPRIM->FST)
  98. {
  99. v.tu = (float)(int)m_v.UV.U / (16 << m_ctxt->TEX0.TW);
  100. v.tv = (float)(int)m_v.UV.V / (16 << m_ctxt->TEX0.TH);
  101. v.rhw = 1.0f;
  102. }
  103. else
  104. {
  105. float w = m_v.RGBAQ.Q ? 1.0f / m_v.RGBAQ.Q : 1.0f;
  106. v.tu = m_v.ST.S * w;
  107. v.tv = m_v.ST.T * w;
  108. }
  109. }
  110. else
  111. {
  112. v.a = SCALE_ALPHA(v.a);
  113. }
  115. v.fog = (m_pPRIM->FGE ? m_v.FOG.F : 0xff) << 24;
  117. __super::VertexKick(fSkip);
  118. }
  120. int GSRendererHW::DrawingKick(bool fSkip)
  121. {
  122. GSVertexHW* pVertices = &m_pVertices[m_nVertices];
  123. int nVertices = 0;
  125. CRect sc(m_ctxt->SCISSOR.SCAX0, m_ctxt->SCISSOR.SCAY0, m_ctxt->SCISSOR.SCAX1+1, m_ctxt->SCISSOR.SCAY1+1);
  127. switch(m_PRIM)
  128. {
  129. case 3: // triangle list
  130. m_primtype = D3DPT_TRIANGLELIST;
  131. m_vl.RemoveAt(0, pVertices[nVertices++]);
  132. m_vl.RemoveAt(0, pVertices[nVertices++]);
  133. m_vl.RemoveAt(0, pVertices[nVertices++]);
  134. if(pVertices[nVertices-1].x < sc.left && pVertices[nVertices-2].x < sc.left && pVertices[nVertices-3].x < sc.left
  135. || pVertices[nVertices-1].y < sc.top && pVertices[nVertices-2].y < sc.top && pVertices[nVertices-3].y < sc.top
  136. || pVertices[nVertices-1].x >= sc.right && pVertices[nVertices-2].x >= sc.right && pVertices[nVertices-3].x >= sc.right
  137. || pVertices[nVertices-1].y >= sc.bottom && pVertices[nVertices-2].y >= sc.bottom && pVertices[nVertices-3].y >= sc.bottom)
  138. return 0;
  139. LOGV((pVertices[0], _T("TriList")));
  140. LOGV((pVertices[1], _T("TriList")));
  141. LOGV((pVertices[2], _T("TriList")));
  142. break;
  143. case 4: // triangle strip
  144. m_primtype = D3DPT_TRIANGLELIST;
  145. m_vl.RemoveAt(0, pVertices[nVertices++]);
  146. m_vl.GetAt(0, pVertices[nVertices++]);
  147. m_vl.GetAt(1, pVertices[nVertices++]);
  148. if(pVertices[nVertices-1].x < sc.left && pVertices[nVertices-2].x < sc.left && pVertices[nVertices-3].x < sc.left
  149. || pVertices[nVertices-1].y < sc.top && pVertices[nVertices-2].y < sc.top && pVertices[nVertices-3].y < sc.top
  150. || pVertices[nVertices-1].x >= sc.right && pVertices[nVertices-2].x >= sc.right && pVertices[nVertices-3].x >= sc.right
  151. || pVertices[nVertices-1].y >= sc.bottom && pVertices[nVertices-2].y >= sc.bottom && pVertices[nVertices-3].y >= sc.bottom)
  152. return 0;
  153. LOGV((pVertices[0], _T("TriStrip")));
  154. LOGV((pVertices[1], _T("TriStrip")));
  155. LOGV((pVertices[2], _T("TriStrip")));
  156. break;
  157. case 5: // triangle fan
  158. m_primtype = D3DPT_TRIANGLELIST;
  159. m_vl.GetAt(0, pVertices[nVertices++]);
  160. m_vl.RemoveAt(1, pVertices[nVertices++]);
  161. m_vl.GetAt(1, pVertices[nVertices++]);
  162. if(pVertices[nVertices-1].x < sc.left && pVertices[nVertices-2].x < sc.left && pVertices[nVertices-3].x < sc.left
  163. || pVertices[nVertices-1].y < sc.top && pVertices[nVertices-2].y < sc.top && pVertices[nVertices-3].y < sc.top
  164. || pVertices[nVertices-1].x >= sc.right && pVertices[nVertices-2].x >= sc.right && pVertices[nVertices-3].x >= sc.right
  165. || pVertices[nVertices-1].y >= sc.bottom && pVertices[nVertices-2].y >= sc.bottom && pVertices[nVertices-3].y >= sc.bottom)
  166. return 0;
  167. LOGV((pVertices[0], _T("TriFan")));
  168. LOGV((pVertices[1], _T("TriFan")));
  169. LOGV((pVertices[2], _T("TriFan")));
  170. break;
  171. case 6: // sprite
  172. m_primtype = D3DPT_TRIANGLELIST;
  173. m_vl.RemoveAt(0, pVertices[nVertices++]);
  174. m_vl.RemoveAt(0, pVertices[nVertices++]);
  175. if(pVertices[nVertices-1].x < sc.left && pVertices[nVertices-2].x < sc.left
  176. || pVertices[nVertices-1].y < sc.top && pVertices[nVertices-2].y < sc.top
  177. || pVertices[nVertices-1].x >= sc.right && pVertices[nVertices-2].x >= sc.right
  178. || pVertices[nVertices-1].y >= sc.bottom && pVertices[nVertices-2].y >= sc.bottom)
  179. return 0;
  180. nVertices += 2;
  182. /*
  183. float lod;
  184. if(m_ctxt->TEX1.LCM) lod = -log(pVertices[nVertices-1].rhw)/log(2.0f) * (1 << m_ctxt->TEX1.L) + m_ctxt->TEX1.K;
  185. else lod = m_ctxt->TEX1.K;
  187. int filter;
  188. if(lod < 0) filter = m_ctxt->TEX1.MMAG&1;
  189. else filter = m_ctxt->TEX1.MMIN&1;
  191. // if(!filter)
  192. {
  193. pVertices[nVertices-2].x -= 0.5f;
  194. pVertices[nVertices-2].y -= 0.5f;
  195. pVertices[nVertices-1].x -= 0.5f;
  196. pVertices[nVertices-1].y -= 0.5f;
  197. }
  198. */
  199. // ASSERT(pVertices[0].z == pVertices[1].z);
  200. pVertices[0].z = pVertices[1].z;
  201. pVertices[2] = pVertices[1];
  202. pVertices[3] = pVertices[1];
  203. pVertices[1].y = pVertices[0].y;
  204. pVertices[1].tv = pVertices[0].tv;
  205. pVertices[2].x = pVertices[0].x;
  206. pVertices[2].tu = pVertices[0].tu;
  207. LOGV((pVertices[0], _T("Sprite")));
  208. LOGV((pVertices[1], _T("Sprite")));
  209. LOGV((pVertices[2], _T("Sprite")));
  210. LOGV((pVertices[3], _T("Sprite")));
  211. nVertices += 2;
  212. pVertices[5] = pVertices[3];
  213. pVertices[3] = pVertices[1];
  214. pVertices[4] = pVertices[2];
  215. break;
  216. case 1: // line
  217. m_primtype = D3DPT_LINELIST;
  218. m_vl.RemoveAt(0, pVertices[nVertices++]);
  219. m_vl.RemoveAt(0, pVertices[nVertices++]);
  220. if(pVertices[nVertices-1].x < sc.left && pVertices[nVertices-2].x < sc.left
  221. || pVertices[nVertices-1].y < sc.top && pVertices[nVertices-2].y < sc.top
  222. || pVertices[nVertices-1].x >= sc.right && pVertices[nVertices-2].x >= sc.right
  223. || pVertices[nVertices-1].y >= sc.bottom && pVertices[nVertices-2].y >= sc.bottom)
  224. return 0;
  225. LOGV((pVertices[0], _T("LineList")));
  226. LOGV((pVertices[1], _T("LineList")));
  227. break;
  228. case 2: // line strip
  229. m_primtype = D3DPT_LINELIST;
  230. m_vl.RemoveAt(0, pVertices[nVertices++]);
  231. m_vl.GetAt(0, pVertices[nVertices++]);
  232. if(pVertices[nVertices-1].x < sc.left && pVertices[nVertices-2].x < sc.left
  233. || pVertices[nVertices-1].y < sc.top && pVertices[nVertices-2].y < sc.top
  234. || pVertices[nVertices-1].x >= sc.right && pVertices[nVertices-2].x >= sc.right
  235. || pVertices[nVertices-1].y >= sc.bottom && pVertices[nVertices-2].y >= sc.bottom)
  236. return 0;
  237. LOGV((pVertices[0], _T("LineStrip")));
  238. LOGV((pVertices[1], _T("LineStrip")));
  239. break;
  240. case 0: // point
  241. m_primtype = D3DPT_POINTLIST;
  242. m_vl.RemoveAt(0, pVertices[nVertices++]);
  243. if(pVertices[nVertices-1].x < sc.left
  244. || pVertices[nVertices-1].y < sc.top
  245. || pVertices[nVertices-1].x >= sc.right
  246. || pVertices[nVertices-1].y >= sc.bottom)
  247. return 0;
  248. LOGV((pVertices[0], _T("PointList")));
  249. break;
  250. default:
  251. //ASSERT(0);
  252. m_vl.RemoveAll();
  253. return 0;
  254. }
  255. /*
  256. int gt = 0;
  257. for(int i = 0; i < nVertices; i++)
  258. if(pVertices[i].rhw > 0) gt++;
  259. if(gt != nVertices) 
  260. return 0;
  261. */
  262. if(fSkip || !m_rs.IsEnabled(0) && !m_rs.IsEnabled(1))
  263. return 0;
  265. if(!m_pPRIM->IIP)
  266. {
  267. pVertices[0].color = pVertices[nVertices-1].color;
  268. if(m_PRIM == 6) pVertices[3].color = pVertices[5].color;
  269. /*for(int i = nVertices-1; i > 0; i--)
  270. pVertices[i-1].color = pVertices[i].color;*/
  271. }
  273. return nVertices;
  274. }
  276. void GSRendererHW::FlushPrim()
  277. {
  278. if(m_nVertices > 0 && !(m_pPRIM->TME && HasSharedBits(m_ctxt->TEX0.TBP0, m_ctxt->TEX0.PSM, m_ctxt->FRAME.Block(), m_ctxt->FRAME.PSM)))
  279. do
  280. {
  281. int nPrims = 0;
  283. switch(m_primtype)
  284. {
  285. case D3DPT_TRIANGLELIST: ASSERT(!(m_nVertices%3)); nPrims = m_nVertices/3; break;
  286. case D3DPT_TRIANGLESTRIP: ASSERT(m_nVertices > 2); nPrims = m_nVertices-2; break;
  287. case D3DPT_TRIANGLEFAN: ASSERT(m_nVertices > 2); nPrims = m_nVertices-2; break;
  288. case D3DPT_LINELIST: ASSERT(!(m_nVertices&1)); nPrims = m_nVertices/2; break;
  289. case D3DPT_LINESTRIP: ASSERT(m_nVertices > 1); nPrims = m_nVertices-1; break;
  290. case D3DPT_POINTLIST: nPrims = m_nVertices; break;
  291. default: ASSERT(0); return;
  292. }
  294. LOG(_T("FlushPrim(pt=%d, nVertices=%d, nPrims=%d)n"), m_primtype, m_nVertices, nPrims);
  296. m_perfmon.IncCounter(GSPerfMon::c_prim, nPrims);
  298. //////////////////////
  300. HRESULT hr;
  302. scale_t scale(
  303. (float)m_bd.Width / (m_ctxt->FRAME.FBW*64), 
  304. // (float)m_bd.Width / m_rs.GetDispRect(m_rs.IsEnabled(1)?1:0).right, 
  305. (float)m_bd.Height / m_rs.GetDispRect(m_rs.IsEnabled(1)?1:0).bottom);
  307. //////////////////////
  309. CComPtr<IDirect3DTexture9> pRT;
  310. CComPtr<IDirect3DSurface9> pDS;
  312. bool fClearRT = false;
  313. bool fClearDS = false;
  315. if(!m_pRTs.Lookup(m_ctxt->FRAME.Block(), pRT))
  316. {
  317. hr = m_pD3DDev->CreateTexture(m_bd.Width, m_bd.Height, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &pRT, NULL);
  318. if(S_OK != hr) {ASSERT(0); return;}
  319. m_pRTs[m_ctxt->FRAME.Block()] = pRT;
  320. #ifdef DEBUG_RENDERTARGETS
  321. CGSWnd* pWnd = NULL;
  322. if(!m_pRenderWnds.Lookup(m_ctxt->FRAME.Block(), pWnd))
  323. {
  324. AFX_MANAGE_STATE(AfxGetStaticModuleState());
  325. pWnd = new CGSWnd();
  326. CString str; str.Format(_T("%05x"), m_ctxt->FRAME.Block());
  327. pWnd->Create(str);
  328. m_pRenderWnds[m_ctxt->FRAME.Block()] = pWnd;
  329. pWnd->Show();
  330. }
  331. #endif
  332. fClearRT = true;
  333. }
  335. if(!m_pDSs.Lookup(m_ctxt->ZBUF.ZBP, pDS))
  336. {
  337. hr = m_pD3DDev->CreateDepthStencilSurface(m_bd.Width, m_bd.Height, m_fmtDepthStencil, D3DMULTISAMPLE_NONE, 0, FALSE, &pDS, NULL);
  338. if(S_OK != hr) {ASSERT(0); return;}
  339. m_pDSs[m_ctxt->ZBUF.ZBP] = pDS;
  340. fClearDS = true;
  341. }
  343. if(!pRT || !pDS) {ASSERT(0); return;}
  345. //////////////////////
  347. GSTextureBase t;
  349. if(m_pPRIM->TME)
  350. {
  351. if(m_ctxt->TEX0.TBP0 == 0x800)
  352. {
  353. int i = 0;
  354. }
  356. bool fFetched = 
  357. m_fEnablePalettizedTextures && m_caps.PixelShaderVersion >= D3DPS_VERSION(2, 0) ? m_tc.FetchP(this, t) : 
  358. m_caps.PixelShaderVersion >= D3DPS_VERSION(2, 0) ? m_tc.FetchNP(this, t) :
  359. m_tc.Fetch(this, t);
  361. if(!fFetched) break;
  363. if(nPrims > 100 && t.m_pPalette) // TODO: find the optimal value for nPrims > ?
  364. {
  365. CComPtr<IDirect3DTexture9> pRT;
  366. hr = m_pD3DDev->CreateTexture(t.m_desc.Width, t.m_desc.Height, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &pRT, NULL);
  368. CComPtr<IDirect3DSurface9> pRTSurf;
  369. hr = pRT->GetSurfaceLevel(0, &pRTSurf);
  370. hr = m_pD3DDev->SetRenderTarget(0, pRTSurf);
  371. hr = m_pD3DDev->SetDepthStencilSurface(NULL);
  373. hr = m_pD3DDev->SetTexture(0, t.m_pTexture);
  374. hr = m_pD3DDev->SetTexture(1, t.m_pPalette);
  375. hr = m_pD3DDev->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
  376. hr = m_pD3DDev->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
  377. hr = m_pD3DDev->SetSamplerState(1, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
  378. hr = m_pD3DDev->SetSamplerState(1, D3DSAMP_MINFILTER, D3DTEXF_POINT);
  379. hr = m_pD3DDev->SetRenderState(D3DRS_ZENABLE, FALSE);
  380. hr = m_pD3DDev->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
  381. hr = m_pD3DDev->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
  382. hr = m_pD3DDev->SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD);
  383. hr = m_pD3DDev->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE);
  384. hr = m_pD3DDev->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ZERO);
  385. hr = m_pD3DDev->SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
  386. hr = m_pD3DDev->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RGBA);
  388. hr = m_pD3DDev->SetPixelShader(m_pHLSLTFX[37]);
  390. struct
  391. {
  392. float x, y, z, rhw;
  393. float tu, tv;
  394. }
  395. pVertices[] =
  396. {
  397. {0, 0, 0.5f, 2.0f, 0, 0},
  398. {(float)t.m_desc.Width, 0, 0.5f, 2.0f, 1, 0},
  399. {0, (float)t.m_desc.Height, 0.5f, 2.0f, 0, 1},
  400. {(float)t.m_desc.Width, (float)t.m_desc.Height, 0.5f, 2.0f, 1, 1},
  401. };
  403. hr = m_pD3DDev->BeginScene();
  404. hr = m_pD3DDev->SetFVF(D3DFVF_XYZRHW | D3DFVF_TEX1);
  405. hr = m_pD3DDev->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, pVertices, sizeof(pVertices[0]));
  406. hr = m_pD3DDev->EndScene();
  408. t.m_pTexture = pRT;
  409. t.m_pPalette = NULL;
  411. t.m_pTexture->GetLevelDesc(0, &t.m_desc);
  412. }
  413. }
  415. //////////////////////
  417. hr = m_pD3DDev->BeginScene();
  419. //////////////////////
  421. CComPtr<IDirect3DSurface9> pSurf;
  422. hr = pRT->GetSurfaceLevel(0, &pSurf);
  423. hr = m_pD3DDev->SetRenderTarget(0, pSurf);
  424. hr = m_pD3DDev->SetDepthStencilSurface(pDS);
  425. if(fClearRT) hr = m_pD3DDev->Clear(0, NULL, D3DCLEAR_TARGET, 0, 1.0f, 0);
  426. if(fClearDS) hr = m_pD3DDev->Clear(0, NULL, D3DCLEAR_ZBUFFER, 0, 1.0f, 0);
  428. D3DSURFACE_DESC rd;
  429. ZeroMemory(&rd, sizeof(rd));
  430. pRT->GetLevelDesc(0, &rd);
  432. //////////////////////
  434. hr = m_pD3DDev->SetRenderState(D3DRS_SHADEMODE, m_pPRIM->IIP ? D3DSHADE_GOURAUD : D3DSHADE_FLAT);
  436. //////////////////////
  438. float tsx = 1.0f, tsy = 1.0f;
  440. if(m_pPRIM->TME)
  441. {
  442. tsx = 1.0f * (1 << m_ctxt->TEX0.TW) / t.m_desc.Width * t.m_scale.x;
  443. tsy = 1.0f * (1 << m_ctxt->TEX0.TH) / t.m_desc.Height * t.m_scale.y;
  444. }
  446. ASSERT(abs(tsx - 1.0f) < 0.001 && abs(tsy - 1.0f) < 0.001);
  448. SetupTexture(t, tsx, tsy);
  450. //////////////////////
  452. SetupAlphaBlend();
  454. //////////////////////
  456. SetupColorMask();
  458. //////////////////////
  460. SetupZBuffer();
  462. //////////////////////
  464. SetupAlphaTest();
  466. //////////////////////
  468. SetupScissor(scale);
  470. scale.Set(pRT);
  472. //////////////////////
  474. // ASSERT(!m_de.PABE.PABE); // bios
  475. // ASSERT(!m_ctxt->FBA.FBA); // bios
  476. // ASSERT(!m_ctxt->TEST.DATE); // sfex3 (after the capcom logo), vf4 (first menu fading in)
  478. //////////////////////
  480. {
  481. // hr = m_pD3DDev->SetTextureStageState(1, D3DTSS_TEXCOORDINDEX, 1);
  482. // hr = m_pD3DDev->SetTexture(1, pRT);
  484. GSVertexHW* pVertices = m_pVertices;
  485. for(int i = m_nVertices; i-- > 0; pVertices++)
  486. {
  487. pVertices->x *= scale.x;
  488. pVertices->y *= scale.y;
  490. // pVertices->tu2 = pVertices->x / rd.Width;
  491. // pVertices->tv2 = pVertices->y / rd.Height;
  493. if(m_pPRIM->TME)
  494. {
  495. // FIXME
  496. float base, fract;
  497. fract = modf(pVertices->tu, &base);
  498. fract *= tsx;
  499. //ASSERT(-1 <= fract && fract <= 1.01);
  500. pVertices->tu = base + fract;
  501. fract = modf(pVertices->tv, &base);
  502. fract *= tsy;
  503. //ASSERT(-1 <= fract && fract <= 1.01);
  504. pVertices->tv = base + fract;
  505. }
  507. /*
  508. if(m_pPRIM->TME)
  509. {
  510. pVertices->tu *= tsx;
  511. pVertices->tv *= tsy;
  512. }
  513. */
  514. if(m_pPRIM->FGE)
  515. {
  516. pVertices->fog = (pVertices->fog & 0xff000000) | (m_de.FOGCOL.ai32[0] & 0x00ffffff);
  517. // D3DCOLOR_ARGB(pVertices->fog >> 24, m_de.FOGCOL.FCB, m_de.FOGCOL.FCG, m_de.FOGCOL.FCR)
  518. }
  519. }
  520. }
  522. hr = m_pD3DDev->SetFVF(D3DFVF_XYZRHW|D3DFVF_DIFFUSE|D3DFVF_SPECULAR|D3DFVF_TEX1);
  524. if(1)//!m_de.PABE.PABE)
  525. {
  526. hr = m_pD3DDev->DrawPrimitiveUP(m_primtype, nPrims, m_pVertices, sizeof(GSVertexHW));
  527. }
  528. /* else
  529. {
  530. ASSERT(!m_ctxt->TEST.ATE); // TODO
  532. hr = m_pD3DDev->SetRenderState(D3DRS_ALPHATESTENABLE, TRUE); 
  533. hr = m_pD3DDev->SetRenderState(D3DRS_ALPHAREF, 0xfe);
  535. hr = m_pD3DDev->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL);
  536. hr = m_pD3DDev->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
  537. hr = m_pD3DDev->DrawPrimitive(m_primtype, 0, nPrims);
  539. hr = m_pD3DDev->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_LESS);
  540. hr = m_pD3DDev->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
  541. hr = m_pD3DDev->DrawPrimitive(m_primtype, 0, nPrims);
  542. }
  543. */
  544. if(m_ctxt->TEST.ATE && m_ctxt->TEST.AFAIL && m_ctxt->TEST.ATST != 1)
  545. {
  546. ASSERT(!m_de.PABE.PABE);
  548. static const DWORD iafunc[] = {D3DCMP_ALWAYS, D3DCMP_NEVER, D3DCMP_GREATEREQUAL, D3DCMP_GREATER, D3DCMP_NOTEQUAL, D3DCMP_LESS, D3DCMP_LESSEQUAL, D3DCMP_EQUAL};
  550. hr = m_pD3DDev->SetRenderState(D3DRS_ALPHAFUNC, iafunc[m_ctxt->TEST.ATST]);
  551. hr = m_pD3DDev->SetRenderState(D3DRS_ALPHAREF, (DWORD)SCALE_ALPHA(m_ctxt->TEST.AREF));
  553. int mask = 0;
  554. bool zwrite = false;
  556. switch(m_ctxt->TEST.AFAIL)
  557. {
  558. case 0: break; // keep
  559. case 1: mask = D3DCOLORWRITEENABLE_RGBA; break; // fbuf
  560. case 2: zwrite = true; break; // zbuf
  561. case 3: mask = D3DCOLORWRITEENABLE_RGB; break; // fbuf w/o alpha
  562. default: __assume(0);
  563. }
  565. hr = m_pD3DDev->SetRenderState(D3DRS_ZWRITEENABLE, zwrite);
  566. hr = m_pD3DDev->SetRenderState(D3DRS_COLORWRITEENABLE, mask);
  568. if(mask || zwrite)
  569. hr = m_pD3DDev->DrawPrimitiveUP(m_primtype, nPrims, m_pVertices, sizeof(GSVertexHW));
  570. }
  572. hr = m_pD3DDev->EndScene();
  574. //////////////////////
  576. GIFRegTEX0 TEX0;
  577. TEX0.TBP0 = m_ctxt->FRAME.Block();
  578. TEX0.TBW = m_ctxt->FRAME.FBW;
  579. TEX0.PSM = m_ctxt->FRAME.PSM;
  580. m_tc.AddRT(TEX0, pRT, scale); 
  581. }
  582. while(0);
  584. m_primtype = D3DPT_FORCE_DWORD;
  586. __super::FlushPrim();
  587. }
  589. void GSRendererHW::Flip()
  590. {
  591. HRESULT hr;
  593. FlipInfo rt[2];
  595. for(int i = 0; i < countof(rt); i++)
  596. {
  597. if(!m_rs.IsEnabled(i)) continue;
  599. DWORD FBP = m_rs.DISPFB[i].FBP<<5;
  601. #ifdef DEBUG_RENDERTARGETS
  602. if(::GetAsyncKeyState(VK_SPACE)&0x80000000) FBP = m_ctxt->FRAME.Block();
  603. #endif
  605. CSurfMap<IDirect3DTexture9>::CPair* pPair = m_pRTs.PLookup(FBP);
  607. if(!pPair)
  608. {
  609. for(CSurfMap<IDirect3DTexture9>::CPair* pPair2 = m_pRTs.PGetFirstAssoc(); 
  610. pPair2; 
  611. pPair2 = m_pRTs.PGetNextAssoc(pPair2))
  612. {
  613. if(pPair2->key <= FBP && (!pPair || pPair2->key >= pPair->key))
  614. {
  615. pPair = pPair2;
  616. }
  617. }
  618. }
  620. if(!pPair)
  621. {
  622. CComPtr<IDirect3DTexture9> pRT;
  624. if(S_OK == m_pD3DDev->CreateTexture(m_bd.Width, m_bd.Height, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &pRT, NULL))
  625. {
  626. m_pRTs[FBP] = pRT;
  628. EXECUTE_ASSERT(pPair = m_pRTs.PLookup(FBP));
  630. #ifdef DEBUG_RENDERTARGETS
  631. CGSWnd* pWnd = NULL;
  632. if(!m_pRenderWnds.Lookup(m_ctxt->FRAME.Block(), pWnd))
  633. {
  634. AFX_MANAGE_STATE(AfxGetStaticModuleState());
  635. pWnd = new CGSWnd();
  636. CString str; str.Format(_T("%05x"), FBP);
  637. pWnd->Create(str);
  638. m_pRenderWnds[FBP] = pWnd;
  639. pWnd->Show();
  640. }
  641. #endif
  643. CRect r = m_rs.GetDispRect(m_rs.IsEnabled(1)?1:0);
  645. scale_t scale(
  646. (float)m_bd.Width / (m_rs.DISPFB[i].FBW*64), 
  647. // (float)m_bd.Width / m_rs.GetDispRect(m_rs.IsEnabled(1)?1:0).right, 
  648. (float)m_bd.Height / r.bottom);
  650. scale.Set(pRT);
  652. GIFRegTEX0 TEX0;
  653. TEX0.TBP0 = m_rs.DISPFB[i].FBP;
  654. TEX0.TBW = m_rs.DISPFB[i].FBW;
  655. TEX0.PSM = m_rs.DISPFB[i].PSM;
  657. m_tc.AddRT(TEX0, pRT, scale);
  659. GIFRegBITBLTBUF BITBLTBUF;
  660. BITBLTBUF.DBP = TEX0.TBP0;
  661. BITBLTBUF.DBW = TEX0.TBW;
  662. BITBLTBUF.DPSM = TEX0.PSM;
  664. m_tc.InvalidateTexture(this, BITBLTBUF, r);
  665. }
  666. }
  668. if(pPair)
  669. {
  670. m_tc.ResetAge(pPair->key);
  672. rt[i].pRT = pPair->value;
  674. ZeroMemory(&rt[i].rd, sizeof(rt[i].rd));
  675. hr = rt[i].pRT->GetLevelDesc(0, &rt[i].rd);
  677. rt[i].scale.Get(rt[i].pRT);
  678. }
  679. }
  681. FinishFlip(rt);
  683. #ifdef DEBUG_RENDERTARGETS
  684. CRect dst(0, 0, m_bd.Width, m_bd.Height);
  686. AFX_MANAGE_STATE(AfxGetStaticModuleState());
  688. if(!m_pRenderWnds.IsEmpty())
  689. {
  690. POSITION pos = m_pRenderWnds.GetStartPosition();
  691. while(pos)
  692. {
  693. DWORD fbp;
  694. CGSWnd* pWnd = NULL;
  695. m_pRenderWnds.GetNextAssoc(pos, fbp, pWnd);
  697. CComPtr<IDirect3DTexture9> pRT;
  698. if(m_pRTs.Lookup(fbp, pRT))
  699. {
  700. D3DSURFACE_DESC rd;
  701. ZeroMemory(&rd, sizeof(rd));
  702. hr = pRT->GetLevelDesc(0, &rd);
  704. hr = m_pD3DDev->SetTexture(0, pRT);
  705. hr = m_pD3DDev->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, 0);
  706. hr = m_pD3DDev->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
  707. hr = m_pD3DDev->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
  709. scale_t scale(pRT);
  711. CRect rect = m_rs.GetDispRect(m_rs.IsEnabled(1)?1:0);
  712. //CSize size = m_rs.GetSize(m_rs.IsEnabled(1)?1:0);
  713. CRect src = CRect(0, 0, scale.x*rect.right, scale.y*rect.bottom);
  715. struct
  716. {
  717. float x, y, z, rhw;
  718. float tu, tv;
  719. }
  720. pVertices[] =
  721. {
  722. {(float)dst.left, (float)dst.top, 0.5f, 2.0f, (float)src.left / rd.Width, (float)src.top / rd.Height},
  723. {(float)dst.right, (float)dst.top, 0.5f, 2.0f, (float)src.right / rd.Width, (float)src.top / rd.Height},
  724. {(float)dst.left, (float)dst.bottom, 0.5f, 2.0f, (float)src.left / rd.Width, (float)src.bottom / rd.Height},
  725. {(float)dst.right, (float)dst.bottom, 0.5f, 2.0f, (float)src.right / rd.Width, (float)src.bottom / rd.Height},
  726. };
  728. for(int i = 0; i < countof(pVertices); i++)
  729. {
  730. pVertices[i].x -= 0.5;
  731. pVertices[i].y -= 0.5;
  732. }
  734. hr = m_pD3DDev->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
  735. hr = m_pD3DDev->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
  736. hr = m_pD3DDev->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
  738. hr = m_pD3DDev->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
  740. hr = m_pD3DDev->SetPixelShader(NULL);
  742. hr = m_pD3DDev->BeginScene();
  743. hr = m_pD3DDev->SetFVF(D3DFVF_XYZRHW | D3DFVF_TEX1);
  744. hr = m_pD3DDev->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, pVertices, sizeof(pVertices[0]));
  745. hr = m_pD3DDev->EndScene();
  747. hr = m_pD3DDev->Present(NULL, NULL, pWnd->m_hWnd, NULL);
  749. hr = m_pD3DDev->Clear(0, NULL, D3DCLEAR_TARGET, 0, 1.0f, 0);
  751. CString str;
  752. str.Format(_T("PCSX2 - %05x - %05x"), fbp, m_ctxt->TEX0.TBP0);
  753. if(fbp == (m_ctxt->FRAME.Block()))
  754. {
  755. // pWnd->SetFocus();
  756. str += _T(" - Drawing");
  757. }
  758. pWnd->SetWindowText(str);
  760. MSG msg;
  761. ZeroMemory(&msg, sizeof(msg));
  762. while(msg.message != WM_QUIT)
  763. {
  764. if(PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
  765. {
  766. TranslateMessage(&msg);
  767. DispatchMessage(&msg);
  768. }
  769. #ifdef DEBUG_RENDERTARGETS
  770. else if(!(::GetAsyncKeyState(VK_RCONTROL)&0x80000000))
  771. {
  772. break;
  773. }
  774. #endif
  775. }
  777. #ifdef DEBUG_RENDERTARGETS
  778. if(::GetAsyncKeyState(VK_LCONTROL)&0x80000000)
  779. Sleep(500);
  780. #endif
  781. }
  782. else
  783. {
  784. if(IsWindow(pWnd->m_hWnd)) pWnd->DestroyWindow();
  785. m_pRenderWnds.RemoveKey(fbp);
  786. }
  788. CString str;
  789. str.Format(_T("PCSX2 - %05x - %05x"), m_ctxt->FRAME.Block(), m_ctxt->TEX0.TBP0);
  790. SetWindowText(m_hWnd, str);
  791. }
  792. }
  793. else
  794. {
  795. SetWindowText(m_hWnd, _T("PCSX2"));
  796. }
  797. #endif
  798. }
  800. void GSRendererHW::EndFrame()
  801. {
  802. m_tc.IncAge(m_pRTs);
  803. }
  805. void GSRendererHW::InvalidateTexture(const GIFRegBITBLTBUF& BITBLTBUF, CRect r)
  806. {
  807. m_tc.InvalidateTexture(this, BITBLTBUF, &r);
  808. }
  810. void GSRendererHW::InvalidateLocalMem(DWORD TBP0, DWORD BW, DWORD PSM, CRect r)
  811. {
  812. m_tc.InvalidateLocalMem(this, TBP0, BW, PSM, &r);
  813. }
  815. void GSRendererHW::MinMaxUV(int w, int h, CRect& r)
  816. {
  817. r.SetRect(0, 0, w, h);
  819. uvmm_t uv;
  820. CSize bsm;
  822. if(m_ctxt->CLAMP.WMS < 3 || m_ctxt->CLAMP.WMT < 3)
  823. {
  824. UVMinMax(m_nVertices, (vertex_t*)m_pVertices, &uv);
  825. CSize bs = GSLocalMemory::m_psmtbl[m_ctxt->TEX0.PSM].bs;
  826. bsm.SetSize(bs.cx-1, bs.cy-1);
  827. }
  829. // FIXME: region clamp returns the right rect but we should still update the whole texture later in TC...
  831. if(m_ctxt->CLAMP.WMS < 3)
  832. {
  833. if(m_ctxt->CLAMP.WMS == 0)
  834. {
  835. float fmin = floor(uv.umin);
  836. float fmax = floor(uv.umax);
  838. if(fmin != fmax) {uv.umin = 0; uv.umax = 1.0f;}
  839. else {uv.umin -= fmin; uv.umax -= fmax;}
  841. // FIXME
  842. if(uv.umin == 0 && uv.umax != 1.0f) uv.umax = 1.0f;
  843. }
  844. else if(m_ctxt->CLAMP.WMS == 1)
  845. {
  846. if(uv.umin < 0) uv.umin = 0;
  847. if(uv.umax > 1.0f) uv.umax = 1.0f;
  848. }
  849. else if(m_ctxt->CLAMP.WMS == 2)
  850. {
  851. float minu = 1.0f * m_ctxt->CLAMP.MINU / w;
  852. float maxu = 1.0f * m_ctxt->CLAMP.MAXU / w;
  853. if(uv.umin < minu) uv.umin = minu;
  854. if(uv.umax > maxu) uv.umax = maxu;
  855. }
  857. r.left = max((int)(uv.umin * w) & ~bsm.cx, 0);
  858. r.right = min(((int)(uv.umax * w) + bsm.cx + 1) & ~bsm.cx, w);
  859. }
  861. if(m_ctxt->CLAMP.WMT < 3)
  862. {
  863. if(m_ctxt->CLAMP.WMT == 0)
  864. {
  865. float fmin = floor(uv.vmin);
  866. float fmax = floor(uv.vmax);
  868. if(fmin != fmax) {uv.vmin = 0; uv.vmax = 1.0f;}
  869. else {uv.vmin -= fmin; uv.vmax -= fmax;}
  871. // FIXME
  872. if(uv.vmin == 0 && uv.vmax != 1.0f) uv.vmax = 1.0f;
  873. }
  874. else if(m_ctxt->CLAMP.WMT == 1)
  875. {
  876. if(uv.vmin < 0) uv.vmin = 0;
  877. if(uv.vmax > 1.0f) uv.vmax = 1.0f;
  878. }
  879. else if(m_ctxt->CLAMP.WMT == 2)
  880. {
  881. float minv = 1.0f * m_ctxt->CLAMP.MINV / h;
  882. float maxv = 1.0f * m_ctxt->CLAMP.MAXV / h;
  883. if(uv.vmin < minv) uv.vmin = minv;
  884. if(uv.vmax > maxv) uv.vmax = maxv;
  885. }
  887. r.top = max((int)(uv.vmin * h) & ~bsm.cy, 0);
  888. r.bottom = min(((int)(uv.vmax * h) + bsm.cy + 1) & ~bsm.cy, h);
  889. }
  891. ASSERT(r.left <= r.right);
  892. ASSERT(r.top <= r.bottom);
  893. }
  895. void GSRendererHW::SetupTexture(const GSTextureBase& t, float tsx, float tsy)
  896. {
  897. HRESULT hr;
  899. int tw = 0, th = 0;
  900. float rw = 0, rh = 0;
  902. IDirect3DPixelShader9* pPixelShader = NULL;
  904. if(m_pPRIM->TME && t.m_pTexture)
  905. {
  906. tw = t.m_desc.Width;
  907. th = t.m_desc.Height;
  908. rw = 1.0f / tw;
  909. rh = 1.0f / th;
  911. hr = m_pD3DDev->SetTexture(0, t.m_pTexture);
  912. hr = m_pD3DDev->SetTexture(1, t.m_pPalette);
  914. D3DTEXTUREADDRESS u, v;
  916. switch(m_ctxt->CLAMP.WMS)
  917. {
  918. case 0: case 3: u = D3DTADDRESS_WRAP; break; // repeat
  919. case 1: case 2: u = D3DTADDRESS_CLAMP; break; // clamp
  920. default: __assume(0);
  921. }
  923. switch(m_ctxt->CLAMP.WMT)
  924. {
  925. case 0: case 3: v = D3DTADDRESS_WRAP; break; // repeat
  926. case 1: case 2: v = D3DTADDRESS_CLAMP; break; // clamp
  927. default: __assume(0);
  928. }
  930. hr = m_pD3DDev->SetSamplerState(0, D3DSAMP_ADDRESSU, u);
  931. hr = m_pD3DDev->SetSamplerState(0, D3DSAMP_ADDRESSV, v);
  933. hr = m_pD3DDev->SetSamplerState(0, D3DSAMP_MAGFILTER, t.m_pPalette ? D3DTEXF_POINT : m_texfilter);
  934. hr = m_pD3DDev->SetSamplerState(0, D3DSAMP_MINFILTER, t.m_pPalette ? D3DTEXF_POINT : m_texfilter);
  935. hr = m_pD3DDev->SetSamplerState(1, D3DSAMP_MAGFILTER, t.m_pPalette ? D3DTEXF_POINT : m_texfilter);
  936. hr = m_pD3DDev->SetSamplerState(1, D3DSAMP_MINFILTER, t.m_pPalette ? D3DTEXF_POINT : m_texfilter);
  938. if(!pPixelShader && m_caps.PixelShaderVersion >= D3DPS_VERSION(2, 0) && m_pHLSLTFX[m_ctxt->TEX0.TFX])
  939. {
  940. int i = m_ctxt->TEX0.TFX;
  942. switch(t.m_desc.Format)
  943. {
  944. default: 
  945. ASSERT(0);
  946. break;
  947. case D3DFMT_A8R8G8B8:
  948. //ASSERT(m_ctxt->TEX0.PSM != PSM_PSMCT24); // format must be D3DFMT_X8R8G8B8 for PSM_PSMCT24
  949. //if(m_ctxt->TEX0.PSM == PSM_PSMCT24) {i += 4; if(m_de.TEXA.AEM) i += 4;}
  950. if(m_ctxt->TEX0.PSM == PSM_PSMT8H) i += 32;
  951. break;
  952. case D3DFMT_X8R8G8B8:
  953. i += 4; if(m_de.TEXA.AEM) i += 4;
  954. break;
  955. case D3DFMT_A1R5G5B5:
  956. i += 12; if(m_de.TEXA.AEM) i += 4; 
  957. break;
  958. case D3DFMT_L8:
  959. i += 24;
  960. ASSERT(t.m_pPalette);
  961. break;
  962. }
  964. pPixelShader = m_pHLSLTFX[i];
  965. }
  967. if(!pPixelShader && m_caps.PixelShaderVersion >= D3DPS_VERSION(1, 1))
  968. {
  969. switch(m_ctxt->TEX0.TFX)
  970. {
  971. case 0:
  972. if(!m_ctxt->TEX0.TCC) pPixelShader = m_pPixelShaders[0];
  973. else if(!t.m_fRT) pPixelShader = m_pPixelShaders[1];
  974. else pPixelShader = m_pPixelShaders[2];
  975. break;
  976. case 1:
  977. if(!t.m_fRT) pPixelShader = m_pPixelShaders[3];
  978. else pPixelShader = m_pPixelShaders[4];
  979. break;
  980. case 2:
  981. if(!m_ctxt->TEX0.TCC) pPixelShader = m_pPixelShaders[5];
  982. else if(!t.m_fRT) pPixelShader = m_pPixelShaders[6];
  983. else pPixelShader = m_pPixelShaders[7];
  984. break;
  985. case 3:
  986. if(!m_ctxt->TEX0.TCC) pPixelShader = m_pPixelShaders[8];
  987. else if(!t.m_fRT) pPixelShader = m_pPixelShaders[9];
  988. else pPixelShader = m_pPixelShaders[10];
  989. break;
  990. default: 
  991. __assume(0);
  992. }
  993. }
  995. if(!pPixelShader)
  996. {
  997. int stage = 0;
  999. hr = m_pD3DDev->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, 0);
  1000. hr = m_pD3DDev->SetTextureStageState(1, D3DTSS_TEXCOORDINDEX, 0);
  1002. switch(m_ctxt->TEX0.TFX)
  1003. {
  1004. case 0:
  1005. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
  1006. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLORARG1, D3DTA_TEXTURE);
  1007. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
  1008. if(m_ctxt->TEX0.TCC)
  1009. {
  1010. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAOP, t.m_fRT ? D3DTOP_MODULATE2X : D3DTOP_MODULATE4X);
  1011. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
  1012. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
  1013. }
  1014. else
  1015. {
  1016. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAOP, D3DTOP_ADD);
  1017. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
  1018. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
  1019. }
  1020. stage++;
  1021. break;
  1022. case 1:
  1023. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
  1024. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLORARG1, D3DTA_TEXTURE);
  1025. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAOP, t.m_fRT ? D3DTOP_SELECTARG1 : D3DTOP_ADD);
  1026. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
  1027. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAARG2, D3DTA_TEXTURE);
  1028. stage++;
  1029. break;
  1030. case 2:
  1031. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
  1032. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLORARG1, D3DTA_TEXTURE);
  1033. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
  1034. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
  1035. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
  1036. if(m_ctxt->TEX0.TCC)
  1037. {
  1038. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAOP, D3DTOP_ADD);
  1039. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAARG2, D3DTA_TEXTURE);
  1040. ASSERT(!t.m_fRT); // FIXME
  1041. }
  1042. stage++;
  1043. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLOROP, D3DTOP_ADD);
  1044. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLORARG1, D3DTA_CURRENT);
  1045. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLORARG2, D3DTA_ALPHAREPLICATE|D3DTA_DIFFUSE);
  1046. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAOP, D3DTOP_ADD);
  1047. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAARG1, D3DTA_CURRENT);
  1048. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
  1049. stage++;
  1050. break;
  1051. case 3:
  1052. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLOROP, D3DTOP_MODULATE2X);
  1053. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLORARG1, D3DTA_TEXTURE);
  1054. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
  1055. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
  1056. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
  1057. if(m_ctxt->TEX0.TCC)
  1058. {
  1059. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
  1060. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
  1061. ASSERT(!t.m_fRT); // FIXME
  1062. }
  1063. stage++;
  1064. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLOROP, D3DTOP_ADD);
  1065. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLORARG1, D3DTA_CURRENT);
  1066. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLORARG2, D3DTA_ALPHAREPLICATE|D3DTA_DIFFUSE);
  1067. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAOP, D3DTOP_ADD);
  1068. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAARG1, D3DTA_CURRENT);
  1069. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
  1070. stage++;
  1071. break;
  1072. default: 
  1073. __assume(0);
  1074. }
  1076. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLOROP, D3DTOP_DISABLE);
  1077. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
  1078. }
  1079. }
  1080. else
  1081. {
  1082. hr = m_pD3DDev->SetTexture(0, NULL);
  1083. hr = m_pD3DDev->SetTexture(1, NULL);
  1085. if(!pPixelShader && m_caps.PixelShaderVersion >= D3DPS_VERSION(2, 0) && m_pHLSLTFX[36])
  1086. {
  1087. pPixelShader = m_pHLSLTFX[36];
  1088. }
  1090. if(!pPixelShader && m_caps.PixelShaderVersion >= D3DPS_VERSION(1, 1) && m_pPixelShaders[11])
  1091. {
  1092. pPixelShader = m_pPixelShaders[11];
  1093. }
  1095. if(!pPixelShader)
  1096. {
  1097. hr = m_pD3DDev->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_DISABLE);
  1098. hr = m_pD3DDev->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
  1099. }
  1100. }
  1102. float fConstData[][4] = 
  1103. {
  1104. {(float)m_ctxt->TEX0.TCC - 0.5f, t.m_fRT ? 1.0f : 2.0f, min(2.0f * m_de.TEXA.TA0 / 255, 1), min(2.0f * m_de.TEXA.TA1 / 255, 1)},
  1105. {(float)tw, (float)th, 0, 0},
  1106. {rw, rh, 0, 0},
  1107. {rw, 0, 0, 0},
  1108. {0, rh, 0, 0},
  1109. };
  1111. hr = m_pD3DDev->SetPixelShaderConstantF(0, (float*)fConstData, countof(fConstData));
  1113. hr = m_pD3DDev->SetPixelShader(pPixelShader);
  1114. }
  1116. void GSRendererHW::SetupAlphaBlend()
  1117. {
  1118. HRESULT hr;
  1120. DWORD ABE = FALSE;
  1121. hr = m_pD3DDev->GetRenderState(D3DRS_ALPHABLENDENABLE, &ABE);
  1123. bool fABE = m_pPRIM->ABE || (m_primtype == D3DPT_LINELIST || m_primtype == D3DPT_LINESTRIP) && m_pPRIM->AA1; // FIXME
  1124. if(fABE != !!ABE)
  1125. hr = m_pD3DDev->SetRenderState(D3DRS_ALPHABLENDENABLE, fABE);
  1126. if(fABE)
  1127. {
  1128. // (A:Cs/Cd/0 - B:Cs/Cd/0) * C:As/Ad/FIX + D:Cs/Cd/0
  1130. BYTE FIX = SCALE_ALPHA(m_ctxt->ALPHA.FIX);
  1132. hr = m_pD3DDev->SetRenderState(D3DRS_BLENDFACTOR, (0x010101*FIX)|(FIX<<24));
  1134. D3DBLENDOP op = D3DBLENDOP_ADD;
  1135. D3DBLEND src = D3DBLEND_SRCALPHA, dst = D3DBLEND_INVSRCALPHA;
  1137. static const struct {bool bogus; D3DBLENDOP op; D3DBLEND src, dst;} blendmap[3*3*3*3] =
  1138. {
  1139. {0, D3DBLENDOP_ADD, D3DBLEND_ONE, D3DBLEND_ZERO}, // 0000: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + Cs ==> Cs
  1140. {0, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_ONE}, // 0001: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + Cd ==> Cd
  1141. {0, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_ZERO}, // 0002: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + 0 ==> 0
  1142. {0, D3DBLENDOP_ADD, D3DBLEND_ONE, D3DBLEND_ZERO}, // 0010: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + Cs ==> Cs
  1143. {0, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_ONE}, // 0011: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + Cd ==> Cd
  1144. {0, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_ZERO}, // 0012: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + 0 ==> 0
  1145. {0, D3DBLENDOP_ADD, D3DBLEND_ONE, D3DBLEND_ZERO}, // 0020: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + Cs ==> Cs
  1146. {0, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_ONE}, // 0021: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + Cd ==> Cd
  1147. {0, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_ZERO}, // 0022: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + 0 ==> 0
  1148. {1, D3DBLENDOP_SUBTRACT, D3DBLEND_SRCALPHA, D3DBLEND_SRCALPHA}, // * 0100: (Cs - Cd)*As + Cs ==> Cs*(As + 1) - Cd*As
  1149. {0, D3DBLENDOP_ADD, D3DBLEND_SRCALPHA, D3DBLEND_INVSRCALPHA}, // 0101: (Cs - Cd)*As + Cd ==> Cs*As + Cd*(1 - As)
  1150. {0, D3DBLENDOP_SUBTRACT, D3DBLEND_SRCALPHA, D3DBLEND_SRCALPHA}, // 0102: (Cs - Cd)*As + 0 ==> Cs*As - Cd*As
  1151. {1, D3DBLENDOP_SUBTRACT, D3DBLEND_DESTALPHA, D3DBLEND_DESTALPHA}, // * 0110: (Cs - Cd)*Ad + Cs ==> Cs*(Ad + 1) - Cd*Ad
  1152. {0, D3DBLENDOP_ADD, D3DBLEND_DESTALPHA, D3DBLEND_INVDESTALPHA}, // 0111: (Cs - Cd)*Ad + Cd ==> Cs*Ad + Cd*(1 - Ad)
  1153. {0, D3DBLENDOP_ADD, D3DBLEND_DESTALPHA, D3DBLEND_DESTALPHA}, // 0112: (Cs - Cd)*Ad + 0 ==> Cs*Ad - Cd*Ad
  1154. {1, D3DBLENDOP_SUBTRACT, D3DBLEND_BLENDFACTOR, D3DBLEND_BLENDFACTOR}, // * 0120: (Cs - Cd)*F + Cs ==> Cs*(F + 1) - Cd*F
  1155. {0, D3DBLENDOP_ADD, D3DBLEND_BLENDFACTOR, D3DBLEND_INVBLENDFACTOR}, // 0121: (Cs - Cd)*F + Cd ==> Cs*F + Cd*(1 - F)
  1156. {0, D3DBLENDOP_SUBTRACT, D3DBLEND_BLENDFACTOR, D3DBLEND_BLENDFACTOR}, // 0122: (Cs - Cd)*F + 0 ==> Cs*F - Cd*F
  1157. {1, D3DBLENDOP_ADD, D3DBLEND_SRCALPHA, D3DBLEND_ZERO}, // * 0200: (Cs - 0)*As + Cs ==> Cs*(As + 1)
  1158. {0, D3DBLENDOP_ADD, D3DBLEND_SRCALPHA, D3DBLEND_ONE}, // 0201: (Cs - 0)*As + Cd ==> Cs*As + Cd
  1159. {0, D3DBLENDOP_ADD, D3DBLEND_SRCALPHA, D3DBLEND_ZERO}, // 0202: (Cs - 0)*As + 0 ==> Cs*As
  1160. {1, D3DBLENDOP_ADD, D3DBLEND_SRCALPHA, D3DBLEND_ZERO}, // * 0210: (Cs - 0)*Ad + Cs ==> Cs*(As + 1)
  1161. {0, D3DBLENDOP_ADD, D3DBLEND_DESTALPHA, D3DBLEND_ONE}, // 0211: (Cs - 0)*Ad + Cd ==> Cs*Ad + Cd
  1162. {0, D3DBLENDOP_ADD, D3DBLEND_DESTALPHA, D3DBLEND_ZERO}, // 0212: (Cs - 0)*Ad + 0 ==> Cs*Ad
  1163. {1, D3DBLENDOP_ADD, D3DBLEND_BLENDFACTOR, D3DBLEND_ZERO}, // * 0220: (Cs - 0)*F + Cs ==> Cs*(F + 1)
  1164. {0, D3DBLENDOP_ADD, D3DBLEND_BLENDFACTOR, D3DBLEND_ONE}, // 0221: (Cs - 0)*F + Cd ==> Cs*F + Cd
  1165. {0, D3DBLENDOP_ADD, D3DBLEND_BLENDFACTOR, D3DBLEND_ZERO}, // 0222: (Cs - 0)*F + 0 ==> Cs*F
  1166. {0, D3DBLENDOP_ADD, D3DBLEND_INVSRCALPHA, D3DBLEND_SRCALPHA}, // 1000: (Cd - Cs)*As + Cs ==> Cd*As + Cs*(1 - As)
  1167. {1, D3DBLENDOP_REVSUBTRACT, D3DBLEND_SRCALPHA, D3DBLEND_SRCALPHA}, // * 1001: (Cd - Cs)*As + Cd ==> Cd*(As + 1) - Cs*As
  1168. {0, D3DBLENDOP_REVSUBTRACT, D3DBLEND_SRCALPHA, D3DBLEND_SRCALPHA}, // 1002: (Cd - Cs)*As + 0 ==> Cd*As - Cs*As
  1169. {0, D3DBLENDOP_ADD, D3DBLEND_INVDESTALPHA, D3DBLEND_DESTALPHA}, // 1010: (Cd - Cs)*Ad + Cs ==> Cd*Ad + Cs*(1 - Ad)
  1170. {1, D3DBLENDOP_REVSUBTRACT, D3DBLEND_DESTALPHA, D3DBLEND_DESTALPHA}, // * 1011: (Cd - Cs)*Ad + Cd ==> Cd*(Ad + 1) - Cs*Ad
  1171. {0, D3DBLENDOP_REVSUBTRACT, D3DBLEND_DESTALPHA, D3DBLEND_DESTALPHA}, // 1012: (Cd - Cs)*Ad + 0 ==> Cd*Ad - Cs*Ad
  1172. {0, D3DBLENDOP_ADD, D3DBLEND_INVBLENDFACTOR, D3DBLEND_BLENDFACTOR}, // 1020: (Cd - Cs)*F + Cs ==> Cd*F + Cs*(1 - F)
  1173. {1, D3DBLENDOP_REVSUBTRACT, D3DBLEND_BLENDFACTOR, D3DBLEND_BLENDFACTOR},// * 1021: (Cd - Cs)*F + Cd ==> Cd*(F + 1) - Cs*F
  1174. {0, D3DBLENDOP_REVSUBTRACT, D3DBLEND_BLENDFACTOR, D3DBLEND_BLENDFACTOR},// 1022: (Cd - Cs)*F + 0 ==> Cd*F - Cs*F
  1175. {0, D3DBLENDOP_ADD, D3DBLEND_ONE, D3DBLEND_ZERO}, // 1100: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + Cs ==> Cs
  1176. {0, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_ONE}, // 1101: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + Cd ==> Cd
  1177. {0, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_ZERO}, // 1102: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + 0 ==> 0
  1178. {0, D3DBLENDOP_ADD, D3DBLEND_ONE, D3DBLEND_ZERO}, // 1110: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + Cs ==> Cs
  1179. {0, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_ONE}, // 1111: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + Cd ==> Cd
  1180. {0, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_ZERO}, // 1112: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + 0 ==> 0
  1181. {0, D3DBLENDOP_ADD, D3DBLEND_ONE, D3DBLEND_ZERO}, // 1120: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + Cs ==> Cs
  1182. {0, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_ONE}, // 1121: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + Cd ==> Cd
  1183. {0, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_ZERO}, // 1122: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + 0 ==> 0
  1184. {0, D3DBLENDOP_ADD, D3DBLEND_ONE, D3DBLEND_SRCALPHA}, // 1200: (Cd - 0)*As + Cs ==> Cs + Cd*As
  1185. {1, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_SRCALPHA}, // * 1201: (Cd - 0)*As + Cd ==> Cd*(1 + As)
  1186. {0, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_SRCALPHA}, // 1202: (Cd - 0)*As + 0 ==> Cd*As
  1187. {0, D3DBLENDOP_ADD, D3DBLEND_ONE, D3DBLEND_DESTALPHA}, // 1210: (Cd - 0)*Ad + Cs ==> Cs + Cd*Ad
  1188. {1, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_DESTALPHA}, // * 1211: (Cd - 0)*Ad + Cd ==> Cd*(1 + Ad)
  1189. {0, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_DESTALPHA}, // 1212: (Cd - 0)*Ad + 0 ==> Cd*Ad
  1190. {0, D3DBLENDOP_ADD, D3DBLEND_ONE, D3DBLEND_BLENDFACTOR}, // 1220: (Cd - 0)*F + Cs ==> Cs + Cd*F
  1191. {1, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_BLENDFACTOR}, // * 1221: (Cd - 0)*F + Cd ==> Cd*(1 + F)
  1192. {0, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_BLENDFACTOR}, // 1222: (Cd - 0)*F + 0 ==> Cd*F
  1193. {0, D3DBLENDOP_ADD, D3DBLEND_INVSRCALPHA, D3DBLEND_ZERO}, // 2000: (0 - Cs)*As + Cs ==> Cs*(1 - As)
  1194. {0, D3DBLENDOP_REVSUBTRACT, D3DBLEND_SRCALPHA, D3DBLEND_ONE}, // 2001: (0 - Cs)*As + Cd ==> Cd - Cs*As
  1195. {0, D3DBLENDOP_REVSUBTRACT, D3DBLEND_SRCALPHA, D3DBLEND_ZERO}, // 2002: (0 - Cs)*As + 0 ==> 0 - Cs*As
  1196. {0, D3DBLENDOP_ADD, D3DBLEND_INVDESTALPHA, D3DBLEND_ZERO}, // 2010: (0 - Cs)*Ad + Cs ==> Cs*(1 - Ad)
  1197. {0, D3DBLENDOP_REVSUBTRACT, D3DBLEND_DESTALPHA, D3DBLEND_ONE}, // 2011: (0 - Cs)*Ad + Cd ==> Cd - Cs*Ad
  1198. {0, D3DBLENDOP_REVSUBTRACT, D3DBLEND_DESTALPHA, D3DBLEND_ZERO}, // 2012: (0 - Cs)*Ad + 0 ==> 0 - Cs*Ad
  1199. {0, D3DBLENDOP_ADD, D3DBLEND_INVBLENDFACTOR, D3DBLEND_ZERO}, // 2020: (0 - Cs)*F + Cs ==> Cs*(1 - F)
  1200. {0, D3DBLENDOP_REVSUBTRACT, D3DBLEND_BLENDFACTOR, D3DBLEND_ONE}, // 2021: (0 - Cs)*F + Cd ==> Cd - Cs*F
  1201. {0, D3DBLENDOP_REVSUBTRACT, D3DBLEND_BLENDFACTOR, D3DBLEND_ZERO}, // 2022: (0 - Cs)*F + 0 ==> 0 - Cs*F
  1202. {0, D3DBLENDOP_SUBTRACT, D3DBLEND_ONE, D3DBLEND_SRCALPHA}, // 2100: (0 - Cd)*As + Cs ==> Cs - Cd*As
  1203. {0, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_INVSRCALPHA}, // 2101: (0 - Cd)*As + Cd ==> Cd*(1 - As)
  1204. {0, D3DBLENDOP_SUBTRACT, D3DBLEND_ZERO, D3DBLEND_SRCALPHA}, // 2102: (0 - Cd)*As + 0 ==> 0 - Cd*As
  1205. {0, D3DBLENDOP_SUBTRACT, D3DBLEND_ONE, D3DBLEND_DESTALPHA}, // 2110: (0 - Cd)*Ad + Cs ==> Cs - Cd*Ad
  1206. {0, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_INVDESTALPHA}, // 2111: (0 - Cd)*Ad + Cd ==> Cd*(1 - Ad)
  1207. {0, D3DBLENDOP_SUBTRACT, D3DBLEND_ONE, D3DBLEND_DESTALPHA}, // 2112: (0 - Cd)*Ad + 0 ==> 0 - Cd*Ad
  1208. {0, D3DBLENDOP_SUBTRACT, D3DBLEND_ONE, D3DBLEND_BLENDFACTOR}, // 2120: (0 - Cd)*F + Cs ==> Cs - Cd*F
  1209. {0, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_INVBLENDFACTOR}, // 2121: (0 - Cd)*F + Cd ==> Cd*(1 - F)
  1210. {0, D3DBLENDOP_SUBTRACT, D3DBLEND_ONE, D3DBLEND_BLENDFACTOR}, // 2122: (0 - Cd)*F + 0 ==> 0 - Cd*F
  1211. {0, D3DBLENDOP_ADD, D3DBLEND_ONE, D3DBLEND_ZERO}, // 2200: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + Cs ==> Cs
  1212. {0, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_ONE}, // 2201: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + Cd ==> Cd
  1213. {0, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_ZERO}, // 2202: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + 0 ==> 0
  1214. {0, D3DBLENDOP_ADD, D3DBLEND_ONE, D3DBLEND_ZERO}, // 2210: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + Cs ==> Cs
  1215. {0, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_ONE}, // 2211: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + Cd ==> Cd
  1216. {0, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_ZERO}, // 2212: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + 0 ==> 0
  1217. {0, D3DBLENDOP_ADD, D3DBLEND_ONE, D3DBLEND_ZERO}, // 2220: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + Cs ==> Cs
  1218. {0, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_ONE}, // 2221: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + Cd ==> Cd
  1219. {0, D3DBLENDOP_ADD, D3DBLEND_ZERO, D3DBLEND_ZERO}, // 2222: (Cs/Cd/0 - Cs/Cd/0)*As/Ad/F + 0 ==> 0
  1220. };
  1222. // bogus: 0100, 0110, 0120, 0200, 0210, 0220, 1001, 1011, 1021, 1201, 1211, 1221
  1224. int i = (((m_ctxt->ALPHA.A&3)*3+(m_ctxt->ALPHA.B&3))*3+(m_ctxt->ALPHA.C&3))*3+(m_ctxt->ALPHA.D&3);
  1226. ASSERT(m_ctxt->ALPHA.A != 3);
  1227. ASSERT(m_ctxt->ALPHA.B != 3);
  1228. ASSERT(m_ctxt->ALPHA.C != 3);
  1229. ASSERT(m_ctxt->ALPHA.D != 3);
  1230. ASSERT(!blendmap[i].bogus);
  1232. hr = m_pD3DDev->SetRenderState(D3DRS_BLENDOP, blendmap[i].op);
  1233. hr = m_pD3DDev->SetRenderState(D3DRS_SRCBLEND, blendmap[i].src);
  1234. hr = m_pD3DDev->SetRenderState(D3DRS_DESTBLEND, blendmap[i].dst);
  1235. }
  1236. }
  1238. void GSRendererHW::SetupColorMask()
  1239. {
  1240. HRESULT hr;
  1242. // close approx., to be tested...
  1243. int mask = D3DCOLORWRITEENABLE_RGBA;
  1244. if((m_ctxt->FRAME.FBMSK&0xff000000) == 0xff000000) mask &= ~D3DCOLORWRITEENABLE_ALPHA;
  1245. if((m_ctxt->FRAME.FBMSK&0x00ff0000) == 0x00ff0000) mask &= ~D3DCOLORWRITEENABLE_BLUE;
  1246. if((m_ctxt->FRAME.FBMSK&0x0000ff00) == 0x0000ff00) mask &= ~D3DCOLORWRITEENABLE_GREEN;
  1247. if((m_ctxt->FRAME.FBMSK&0x000000ff) == 0x000000ff) mask &= ~D3DCOLORWRITEENABLE_RED;
  1248. //if(m_ctxt->FRAME.PSM == PSM_PSMCT24) mask &= ~D3DCOLORWRITEENABLE_ALPHA;
  1249. hr = m_pD3DDev->SetRenderState(D3DRS_COLORWRITEENABLE, mask);
  1251. // ASSERT(m_ctxt->FRAME.FBMSK == 0); // wild arms (also 8H+pal on RT...)
  1252. }
  1254. void GSRendererHW::SetupZBuffer()
  1255. {
  1256. HRESULT hr;
  1258. hr = m_pD3DDev->SetRenderState(D3DRS_ZENABLE, m_ctxt->TEST.ZTE);
  1259. hr = m_pD3DDev->SetRenderState(D3DRS_ZWRITEENABLE, !m_ctxt->ZBUF.ZMSK);
  1260. if(m_ctxt->TEST.ZTE)
  1261. {
  1262. static const DWORD zfunc[] = {D3DCMP_NEVER, D3DCMP_ALWAYS, D3DCMP_GREATEREQUAL, D3DCMP_GREATER};
  1264. hr = m_pD3DDev->SetRenderState(D3DRS_ZFUNC, zfunc[m_ctxt->TEST.ZTST]);
  1265. // hr = m_pD3DDev->SetRenderState(D3DRS_ZFUNC, D3DCMP_ALWAYS);
  1267. // FIXME
  1268. if(m_ctxt->ZBUF.ZMSK && m_ctxt->TEST.ZTST == 1)
  1269. {
  1270. for(int i = 0; i < m_nVertices; i++)
  1271. m_pVertices[i].z = 0;
  1272. }
  1273. }
  1274. }
  1276. void GSRendererHW::SetupAlphaTest()
  1277. {
  1278. HRESULT hr = m_pD3DDev->SetRenderState(D3DRS_ALPHATESTENABLE, m_ctxt->TEST.ATE);
  1280. if(m_ctxt->TEST.ATE)
  1281. {
  1282. static const DWORD afunc[] = {D3DCMP_NEVER, D3DCMP_ALWAYS, D3DCMP_LESS, D3DCMP_LESSEQUAL, D3DCMP_EQUAL, D3DCMP_GREATEREQUAL, D3DCMP_GREATER, D3DCMP_NOTEQUAL};
  1284. hr = m_pD3DDev->SetRenderState(D3DRS_ALPHAFUNC, afunc[m_ctxt->TEST.ATST]);
  1285. hr = m_pD3DDev->SetRenderState(D3DRS_ALPHAREF, (DWORD)SCALE_ALPHA(m_ctxt->TEST.AREF));
  1286. }
  1287. }
  1289. void GSRendererHW::SetupScissor(scale_t& s)
  1290. {
  1291. HRESULT hr = m_pD3DDev->SetRenderState(D3DRS_SCISSORTESTENABLE, TRUE);
  1293. CRect r(
  1294. (int)(s.x * m_ctxt->SCISSOR.SCAX0),
  1295. (int)(s.y * m_ctxt->SCISSOR.SCAY0), 
  1296. (int)(s.x * (m_ctxt->SCISSOR.SCAX1+1)),
  1297. (int)(s.y * (m_ctxt->SCISSOR.SCAY1+1)));
  1299. if(/*r.Width() == m_bd.Width &&*/ r.bottom > m_bd.Height && r.bottom <= m_bd.Height*2
  1300. /*r.bottom == m_bd.Height*2*/
  1301. )
  1302. {
  1303. // TODO: isn't there a better way? what about s.x?
  1304. // s.y = s.y * m_bd.Height / r.bottom;
  1305. }
  1307. r &= CRect(0, 0, m_bd.Width, m_bd.Height);
  1309. hr = m_pD3DDev->SetScissorRect(r);
  1310. }