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

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

多媒体编程

开发平台：

Visual C++

GSRendererSoft.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 "GSRendererSoft.h"
  24. #include "x86.h"
  26. template <class Vertex>
  27. GSRendererSoft<Vertex>::GSRendererSoft(HWND hWnd, HRESULT& hr)
  28. : GSRenderer<Vertex>(640, 512, hWnd, hr)
  29. {
  30. Reset();
  32. int i = SHRT_MIN, j = 0;
  33. for(; i < 0; i++, j++) m_clip[j] = 0, m_mask[j] = j&255;
  34. for(; i < 256; i++, j++) m_clip[j] = i, m_mask[j] = j&255;
  35. for(; i < SHRT_MAX; i++, j++) m_clip[j] = 255, m_mask[j] = j&255;
  37. m_uv = (uv_wrap_t*)_aligned_malloc(sizeof(uv_wrap_t), 16);
  39. // w00t :P
  41. #define InitATST(iZTST, iATST) 
  42. m_dv[iZTST][iATST] = &GSRendererSoft<Vertex>::DrawVertex<iZTST, iATST>; 
  44. #define InitZTST(iZTST) 
  45. InitATST(iZTST, 0) 
  46. InitATST(iZTST, 1) 
  47. InitATST(iZTST, 2) 
  48. InitATST(iZTST, 3) 
  49. InitATST(iZTST, 4) 
  50. InitATST(iZTST, 5) 
  51. InitATST(iZTST, 6) 
  52. InitATST(iZTST, 7) 
  54. #define InitDV() 
  55. InitZTST(0) 
  56. InitZTST(1) 
  57. InitZTST(2) 
  58. InitZTST(3) 
  60. InitDV();
  62. #define InitTFX(iLOD, bLCM, bTCC, iTFX) 
  63. m_dvtfx[iLOD][bLCM][bTCC][iTFX] = &GSRendererSoft<Vertex>::DrawVertexTFX<iLOD, bLCM, bTCC, iTFX>; 
  65. #define InitTCC(iLOD, bLCM, bTCC) 
  66. InitTFX(iLOD, bLCM, bTCC, 0) 
  67. InitTFX(iLOD, bLCM, bTCC, 1) 
  68. InitTFX(iLOD, bLCM, bTCC, 2) 
  69. InitTFX(iLOD, bLCM, bTCC, 3) 
  71. #define InitLCM(iLOD, bLCM) 
  72. InitTCC(iLOD, bLCM, false) 
  73. InitTCC(iLOD, bLCM, true) 
  75. #define InitLOD(iLOD) 
  76. InitLCM(iLOD, false) 
  77. InitLCM(iLOD, true) 
  79. #define InitDVTFX() 
  80. InitLOD(0) 
  81. InitLOD(1) 
  82. InitLOD(2) 
  83. InitLOD(3) 
  85. InitDVTFX();
  86. }
  88. template <class Vertex>
  89. GSRendererSoft<Vertex>::~GSRendererSoft()
  90. {
  91. _aligned_free(m_uv);
  92. }
  94. template <class Vertex>
  95. HRESULT GSRendererSoft<Vertex>::ResetDevice(bool fForceWindowed)
  96. {
  97. m_pRT[0] = NULL;
  98. m_pRT[1] = NULL;
  100. return __super::ResetDevice(fForceWindowed);
  101. }
  103. template <class Vertex>
  104. void GSRendererSoft<Vertex>::Reset()
  105. {
  106. m_primtype = PRIM_NONE;
  107. m_pTexture = NULL;
  109. __super::Reset();
  110. }
  112. template <class Vertex>
  113. int GSRendererSoft<Vertex>::DrawingKick(bool fSkip)
  114. {
  115. Vertex* pVertices = &m_pVertices[m_nVertices];
  116. int nVertices = 0;
  118. switch(m_PRIM)
  119. {
  120. case 3: // triangle list
  121. m_primtype = PRIM_TRIANGLE;
  122. m_vl.RemoveAt(0, pVertices[nVertices++]);
  123. m_vl.RemoveAt(0, pVertices[nVertices++]);
  124. m_vl.RemoveAt(0, pVertices[nVertices++]);
  125. LOGV((pVertices[0], _T("TriList")));
  126. LOGV((pVertices[1], _T("TriList")));
  127. LOGV((pVertices[2], _T("TriList")));
  128. break;
  129. case 4: // triangle strip
  130. m_primtype = PRIM_TRIANGLE;
  131. m_vl.RemoveAt(0, pVertices[nVertices++]);
  132. m_vl.GetAt(0, pVertices[nVertices++]);
  133. m_vl.GetAt(1, pVertices[nVertices++]);
  134. LOGV((pVertices[0], _T("TriStrip")));
  135. LOGV((pVertices[1], _T("TriStrip")));
  136. LOGV((pVertices[2], _T("TriStrip")));
  137. break;
  138. case 5: // triangle fan
  139. m_primtype = PRIM_TRIANGLE;
  140. m_vl.GetAt(0, pVertices[nVertices++]);
  141. m_vl.RemoveAt(1, pVertices[nVertices++]);
  142. m_vl.GetAt(1, pVertices[nVertices++]);
  143. LOGV((pVertices[0], _T("TriFan")));
  144. LOGV((pVertices[1], _T("TriFan")));
  145. LOGV((pVertices[2], _T("TriFan")));
  146. break;
  147. case 6: // sprite
  148. m_primtype = PRIM_SPRITE;
  149. m_vl.RemoveAt(0, pVertices[nVertices++]);
  150. m_vl.RemoveAt(0, pVertices[nVertices++]);
  151. nVertices += 2;
  152. pVertices[0].p.z = pVertices[1].p.z;
  153. pVertices[0].p.q = pVertices[1].p.q;
  154. pVertices[2] = pVertices[1];
  155. pVertices[3] = pVertices[1];
  156. pVertices[1].p.y = pVertices[0].p.y;
  157. pVertices[1].t.y = pVertices[0].t.y;
  158. pVertices[2].p.x = pVertices[0].p.x;
  159. pVertices[2].t.x = pVertices[0].t.x;
  160. LOGV((pVertices[0], _T("Sprite")));
  161. LOGV((pVertices[1], _T("Sprite")));
  162. LOGV((pVertices[2], _T("Sprite")));
  163. LOGV((pVertices[3], _T("Sprite")));
  164. /*
  165. m_primtype = PRIM_TRIANGLE;
  166. nVertices += 2;
  167. pVertices[5] = pVertices[3];
  168. pVertices[3] = pVertices[1];
  169. pVertices[4] = pVertices[2];
  170. */
  171. break;
  172. case 1: // line
  173. m_primtype = PRIM_LINE;
  174. m_vl.RemoveAt(0, pVertices[nVertices++]);
  175. m_vl.RemoveAt(0, pVertices[nVertices++]);
  176. LOGV((pVertices[0], _T("LineList")));
  177. LOGV((pVertices[1], _T("LineList")));
  178. break;
  179. case 2: // line strip
  180. m_primtype = PRIM_LINE;
  181. m_vl.RemoveAt(0, pVertices[nVertices++]);
  182. m_vl.GetAt(0, pVertices[nVertices++]);
  183. LOGV((pVertices[0], _T("LineStrip")));
  184. LOGV((pVertices[1], _T("LineStrip")));
  185. break;
  186. case 0: // point
  187. m_primtype = PRIM_POINT;
  188. m_vl.RemoveAt(0, pVertices[nVertices++]);
  189. LOGV((pVertices[0], _T("PointList")));
  190. break;
  191. default:
  192. ASSERT(0);
  193. return 0;
  194. }
  196. if(fSkip || !m_rs.IsEnabled(0) && !m_rs.IsEnabled(1))
  197. return 0;
  199. if(!m_pPRIM->IIP)
  200. {
  201. Vertex::Vector c = pVertices[nVertices-1].c;
  202. for(int i = 0; i < nVertices-1; i++) 
  203. pVertices[i].c = c;
  204. }
  206. return nVertices;
  207. }
  209. template <class Vertex>
  210. void GSRendererSoft<Vertex>::FlushPrim()
  211. {
  212. if(m_nVertices > 0)
  213. {
  214. CString fn;
  215. static int s_savenum = 0;
  216. s_savenum++;
  218. if(0)
  219. //if(m_ctxt->FRAME.Block() == 0x008c0 && (DWORD)m_ctxt->TEX0.TBP0 == 0x03a98)
  220. //if(m_ctxt->TEX0.PSM == 0x1b)
  221. if(m_perfmon.GetFrame() >= 200)
  222. {
  223. fn.Format(_T("g:/tmp/%04I64d_%06d_1f_%05x_%x.bmp"), m_perfmon.GetFrame(), s_savenum, m_ctxt->FRAME.Block(), m_ctxt->FRAME.PSM);
  224. m_lm.SaveBMP(m_pD3DDev, fn, m_ctxt->FRAME.Block(), m_ctxt->FRAME.FBW, m_ctxt->FRAME.PSM, m_ctxt->FRAME.FBW*64, 224);
  226. if(m_pPRIM->TME)
  227. {
  228. fn.Format(_T("g:/tmp/%04I64d_%06d_2t_%05x_%x.bmp"), m_perfmon.GetFrame(), s_savenum, (DWORD)m_ctxt->TEX0.TBP0, (DWORD)m_ctxt->TEX0.PSM);
  229. m_lm.SaveBMP(m_pD3DDev, fn, m_ctxt->TEX0.TBP0, m_ctxt->TEX0.TBW, m_ctxt->TEX0.PSM, 1 << m_ctxt->TEX0.TW, 1 << m_ctxt->TEX0.TH);
  230. }
  231. }
  233. int iZTST = !m_ctxt->TEST.ZTE ? 1 : m_ctxt->TEST.ZTST;
  234. int iATST = !m_ctxt->TEST.ATE ? 1 : m_ctxt->TEST.ATST;
  236. m_pDrawVertex = m_dv[iZTST][iATST];
  238. if(m_pPRIM->TME)
  239. {
  240. int iLOD = (m_ctxt->TEX1.MMAG & 1) + (m_ctxt->TEX1.MMIN & 1);
  241. int bLCM = m_ctxt->TEX1.LCM ? 1 : 0;
  242. int bTCC = m_ctxt->TEX0.TCC ? 1 : 0;
  243. int iTFX = m_ctxt->TEX0.TFX;
  245. if(m_pPRIM->FST)
  246. {
  247. iLOD = 3;
  248. bLCM = m_ctxt->TEX1.K <= 0 && (m_ctxt->TEX1.MMAG & 1) || m_ctxt->TEX1.K > 0 && (m_ctxt->TEX1.MMIN & 1);
  249. }
  251. m_pDrawVertexTFX = m_dvtfx[iLOD][bLCM][bTCC][iTFX];
  252. }
  254. SetupTexture();
  256. m_scissor.SetRect(
  257. max(m_ctxt->SCISSOR.SCAX0, 0),
  258. max(m_ctxt->SCISSOR.SCAY0, 0),
  259. min(m_ctxt->SCISSOR.SCAX1+1, m_ctxt->FRAME.FBW * 64),
  260. min(m_ctxt->SCISSOR.SCAY1+1, 4096));
  262. m_clamp = (m_de.COLCLAMP.CLAMP ? m_clip : m_mask) + 32768;
  264. int nPrims = 0;
  265. Vertex* pVertices = m_pVertices;
  267. switch(m_primtype)
  268. {
  269. case PRIM_SPRITE:
  270. ASSERT(!(m_nVertices&3));
  271. nPrims = m_nVertices / 4;
  272. LOG(_T("FlushPrim(pt=%d, nVertices=%d, nPrims=%d)n"), m_primtype, m_nVertices, nPrims);
  273. for(int i = 0; i < nPrims; i++, pVertices += 4) DrawSprite(pVertices);
  274. break;
  275. case PRIM_TRIANGLE:
  276. ASSERT(!(m_nVertices%3));
  277. nPrims = m_nVertices / 3;
  278. LOG(_T("FlushPrim(pt=%d, nVertices=%d, nPrims=%d)n"), m_primtype, m_nVertices, nPrims);
  279. for(int i = 0; i < nPrims; i++, pVertices += 3) DrawTriangle(pVertices);
  280. break;
  281. case PRIM_LINE: 
  282. ASSERT(!(m_nVertices&1));
  283. nPrims = m_nVertices / 2;
  284. LOG(_T("FlushPrim(pt=%d, nVertices=%d, nPrims=%d)n"), m_primtype, m_nVertices, nPrims);
  285. for(int i = 0; i < nPrims; i++, pVertices += 2) DrawLine(pVertices);
  286. break;
  287. case PRIM_POINT:
  288. nPrims = m_nVertices;
  289. LOG(_T("FlushPrim(pt=%d, nVertices=%d, nPrims=%d)n"), m_primtype, m_nVertices, nPrims);
  290. for(int i = 0; i < nPrims; i++, pVertices++) DrawPoint(pVertices);
  291. break;
  292. default:
  293. ASSERT(m_nVertices == 0);
  294. return;
  295. }
  297. m_perfmon.IncCounter(GSPerfMon::c_prim, nPrims);
  299. if(0)
  300. //if(m_ctxt->FRAME.Block() == 0x008c0 && (DWORD)m_ctxt->TEX0.TBP0 == 0x03a98)
  301. //if(m_ctxt->TEX0.PSM == 0x1b)
  302. if(m_perfmon.GetFrame() >= 200)
  303. {
  304. fn.Format(_T("g:/tmp/%04I64d_%06d_3f_%05x_%x.bmp"), m_perfmon.GetFrame(), s_savenum, m_ctxt->FRAME.Block(), m_ctxt->FRAME.PSM);
  305. m_lm.SaveBMP(m_pD3DDev, fn, m_ctxt->FRAME.Block(), m_ctxt->FRAME.FBW, m_ctxt->FRAME.PSM, m_ctxt->FRAME.FBW*64, 224);
  306. }
  307. }
  309. m_primtype = PRIM_NONE;
  311. __super::FlushPrim();
  312. }
  314. template <class Vertex>
  315. void GSRendererSoft<Vertex>::Flip()
  316. {
  317. HRESULT hr;
  319. FlipInfo rt[2];
  321. for(int i = 0; i < countof(rt); i++)
  322. {
  323. if(m_rs.IsEnabled(i))
  324. {
  325. CRect rect = CRect(CPoint(0, 0), m_rs.GetDispRect(i).BottomRight());
  327. //GSLocalMemory::RoundUp(, GSLocalMemory::GetBlockSize(m_rs.DISPFB[i].PSM));
  329. ZeroMemory(&rt[i].rd, sizeof(rt[i].rd));
  330. if(m_pRT[i]) m_pRT[i]->GetLevelDesc(0, &rt[i].rd);
  332. if(rt[i].rd.Width != rect.right || rt[i].rd.Height != rect.bottom)
  333. m_pRT[i] = NULL;
  335. if(!m_pRT[i])
  336. {
  337. CComPtr<IDirect3DTexture9> pRT;
  338. D3DLOCKED_RECT lr;
  339. int nTries = 0, nMaxTries = 10;
  340. do
  341. {
  342. pRT = NULL;
  343. hr = m_pD3DDev->CreateTexture(rect.right, rect.bottom, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &pRT, NULL);
  344. if(FAILED(hr)) break;
  345. if(SUCCEEDED(pRT->LockRect(0, &lr, NULL, 0)))
  346. pRT->UnlockRect(0);
  347. m_pRT[i] = pRT;
  348. }
  349. while((((DWORD_PTR)lr.pBits & 0xf) || (lr.Pitch & 0xf)) && ++nTries < nMaxTries);
  351. if(nTries == nMaxTries) continue;
  353. ZeroMemory(&rt[i].rd, sizeof(rt[i].rd));
  354. hr = m_pRT[i]->GetLevelDesc(0, &rt[i].rd);
  355. }
  357. rt[i].pRT = m_pRT[i];
  359. rt[i].scale = scale_t(1, 1);
  361. D3DLOCKED_RECT lr;
  362. if(FAILED(hr = rt[i].pRT->LockRect(0, &lr, NULL, 0)))
  363. continue;
  365. GIFRegTEX0 TEX0;
  366. TEX0.TBP0 = m_rs.DISPFB[i].FBP<<5;
  367. TEX0.TBW = m_rs.DISPFB[i].FBW;
  368. TEX0.PSM = m_rs.DISPFB[i].PSM;
  370. GIFRegCLAMP CLAMP;
  371. CLAMP.WMS = CLAMP.WMT = 1;
  373. #ifdef DEBUG_RENDERTARGETS
  374. if(::GetAsyncKeyState(VK_SPACE)&0x80000000)
  375. {
  376. TEX0.TBP0 = m_ctxt->FRAME.Block();
  377. TEX0.TBW = m_ctxt->FRAME.FBW;
  378. TEX0.PSM = m_ctxt->FRAME.PSM;
  379. }
  381. MSG msg;
  382. ZeroMemory(&msg, sizeof(msg));
  383. while(msg.message != WM_QUIT)
  384. {
  385. if(PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
  386. {
  387. TranslateMessage(&msg);
  388. DispatchMessage(&msg);
  389. }
  390. else if(!(::GetAsyncKeyState(VK_RCONTROL)&0x80000000))
  391. {
  392. break;
  393. }
  394. }
  396. if(::GetAsyncKeyState(VK_LCONTROL)&0x80000000)
  397. Sleep(500);
  399. #endif
  401. m_lm.ReadTexture(rect, (BYTE*)lr.pBits, lr.Pitch, TEX0, m_de.TEXA, CLAMP);
  403. rt[i].pRT->UnlockRect(0);
  404. }
  405. }
  407. FinishFlip(rt);
  408. }
  410. template <class Vertex>
  411. void GSRendererSoft<Vertex>::EndFrame()
  412. {
  413. }
  415. template <class Vertex>
  416. void GSRendererSoft<Vertex>::RowInit(int x, int y)
  417. {
  418. m_faddr_x0 = (m_ctxt->ftbl->pa)(0, y, m_ctxt->FRAME.FBP<<5, m_ctxt->FRAME.FBW);
  419. m_zaddr_x0 = (m_ctxt->ztbl->pa)(0, y, m_ctxt->ZBUF.ZBP<<5, m_ctxt->FRAME.FBW);
  421. m_faddr_ro = &m_ctxt->ftbl->rowOffset[y&7][x];
  422. m_zaddr_ro = &m_ctxt->ztbl->rowOffset[y&7][x];
  424. m_fx = x-1; // -1 because RowStep() will do +1, yea lame...
  425. m_fy = y;
  427. RowStep();
  428. }
  430. template <class Vertex>
  431. void GSRendererSoft<Vertex>::RowStep()
  432. {
  433. m_fx++;
  435. m_faddr = m_faddr_x0 + *m_faddr_ro++;
  436. m_zaddr = m_zaddr_x0 + *m_zaddr_ro++;
  437. }
  439. template <class Vertex>
  440. void GSRendererSoft<Vertex>::DrawPoint(Vertex* v)
  441. {
  442. CPoint p = *v;
  443. if(!m_scissor.PtInRect(p))
  444. {
  445. RowInit(p.x, p.y);
  446. (this->*m_pDrawVertex)(*v);
  447. }
  448. }
  450. template <class Vertex>
  451. void GSRendererSoft<Vertex>::DrawLine(Vertex* v)
  452. {
  453. Vertex dv = v[1] - v[0];
  455. Vertex::Vector dp = dv.p;
  456. dp.x.abs();
  457. dp.y.abs();
  459. int dx = (int)dp.x;
  460. int dy = (int)dp.y;
  462. if(dx == 0 && dy == 0) return;
  464. int i = dx > dy ? 0 : 1;
  466. Vertex edge = v[0];
  467. Vertex dedge = dv / dp.v[i];
  469. // TODO: clip with the scissor
  471. int steps = (int)dp.v[i];
  473. while(steps-- > 0)
  474. {
  475. CPoint p = edge;
  477. if(m_scissor.PtInRect(p))
  478. {
  479. RowInit(p.x, p.y);
  480. (this->*m_pDrawVertex)(edge);
  481. }
  483. edge += dedge;
  484. }
  485. }
  487. template <class Vertex>
  488. void GSRendererSoft<Vertex>::DrawTriangle(Vertex* v)
  489. {
  490. if(v[1].p.y < v[0].p.y) {Exchange(&v[0], &v[1]);}
  491. if(v[2].p.y < v[0].p.y) {Exchange(&v[0], &v[2]);}
  492. if(v[2].p.y < v[1].p.y) {Exchange(&v[1], &v[2]);}
  494. if(!(v[0].p.y < v[2].p.y)) return;
  496. Vertex v01 = v[1] - v[0];
  497. Vertex v02 = v[2] - v[0];
  499. Vertex::Scalar temp = v01.p.y / v02.p.y;
  500. Vertex::Scalar longest = temp * v02.p.x - v01.p.x;
  502. int ledge, redge;
  503. if(Vertex::Scalar(0) < longest) {ledge = 0; redge = 1; if(longest < Vertex::Scalar(1)) longest = Vertex::Scalar(1);}
  504. else if(longest < Vertex::Scalar(0)) {ledge = 1; redge = 0; if(Vertex::Scalar(-1) < longest) longest = Vertex::Scalar(-1);}
  505. else return;
  507. Vertex edge[2] = {v[0], v[0]};
  509. Vertex dedge[2];
  510. dedge[0].p.y = dedge[1].p.y = Vertex::Scalar(1);
  511. if(Vertex::Scalar(0) < v01.p.y) dedge[ledge] = v01 / v01.p.y;
  512. if(Vertex::Scalar(0) < v02.p.y) dedge[redge] = v02 / v02.p.y;
  514. Vertex scan;
  516. Vertex dscan = (v02 * temp - v01) / longest;
  517. dscan.p.y = 0;
  519. for(int i = 0; i < 2; i++, v++)
  520. { 
  521. int top = edge[0].p.y.ceil_i(), bottom = v[1].p.y.ceil_i();
  522. if(top < m_scissor.top) top = min(m_scissor.top, bottom);
  523. if(bottom > m_scissor.bottom) bottom = m_scissor.bottom;
  524. if(edge[0].p.y < Vertex::Scalar(top)) // for(int j = 0; j < 2; j++) edge[j] += dedge[j] * ((float)top - edge[0].p.y);
  525. {
  526. Vertex::Scalar dy = Vertex::Scalar(top) - edge[0].p.y;
  527. edge[0] += dedge[0] * dy;
  528. edge[1].p.x += dedge[1].p.x * dy;
  529. edge[0].p.y = edge[1].p.y = Vertex::Scalar(top);
  530. }
  532. ASSERT(top >= bottom || (int)((edge[1].p.y - edge[0].p.y) * 10) == 0);
  534. for(; top < bottom; top++)
  535. {
  536. scan = edge[0];
  538. int left = edge[0].p.x.ceil_i(), right = edge[1].p.x.ceil_i();
  539. if(left < m_scissor.left) left = m_scissor.left;
  540. if(right > m_scissor.right) right = m_scissor.right;
  541. if(edge[0].p.x < Vertex::Scalar(left))
  542. {
  543. scan += dscan * (Vertex::Scalar(left) - edge[0].p.x);
  544. scan.p.x = Vertex::Scalar(left);
  545. }
  547. RowInit(left, top);
  549. for(int steps = right - left; steps > 0; steps--)
  550. {
  551. (this->*m_pDrawVertex)(scan);
  552. scan += dscan;
  553. RowStep();
  554. }
  556. // for(int j = 0; j < 2; j++) edge[j] += dedge[j];
  557. edge[0] += dedge[0];
  558. edge[1].p += dedge[1].p;
  559. }
  561. if(v[1].p.y < v[2].p.y)
  562. {
  563. edge[ledge] = v[1];
  564. dedge[ledge] = (v[2] - v[1]) / (v[2].p.y - v[1].p.y);
  565. edge[ledge] += dedge[ledge] * (edge[ledge].p.y.ceil_s() - edge[ledge].p.y);
  566. }
  567. }
  568. }
  570. template <class Vertex>
  571. void GSRendererSoft<Vertex>::DrawSprite(Vertex* v)
  572. {
  573. if(v[2].p.y < v[0].p.y) {Exchange(&v[0], &v[2]); Exchange(&v[1], &v[3]);}
  574. if(v[1].p.x < v[0].p.x) {Exchange(&v[0], &v[1]); Exchange(&v[2], &v[3]);}
  576. if(v[0].p.x == v[1].p.x || v[0].p.y == v[2].p.y) return;
  578. Vertex v01 = v[1] - v[0];
  579. Vertex v02 = v[2] - v[0];
  581. Vertex edge = v[0];
  582. Vertex dedge = v02 / v02.p.y;
  583. Vertex scan;
  584. Vertex dscan = v01 / v01.p.x;
  586. int top = v[0].p.y.ceil_i(), bottom = v[2].p.y.ceil_i();
  587. if(top < m_scissor.top) top = min(m_scissor.top, bottom);
  588. if(bottom > m_scissor.bottom) bottom = m_scissor.bottom;
  589. if(v[0].p.y < Vertex::Scalar(top)) edge += dedge * (Vertex::Scalar(top) - v[0].p.y);
  591. int left = v[0].p.x.ceil_i(), right = v[1].p.x.ceil_i();
  592. if(left < m_scissor.left) left = m_scissor.left;
  593. if(right > m_scissor.right) right = m_scissor.right;
  594. if(v[0].p.x < Vertex::Scalar(left)) edge += dscan * (Vertex::Scalar(left) - v[0].p.x);
  596. if(DrawFilledRect(left, top, right, bottom, edge))
  597. return;
  599. for(; top < bottom; top++)
  600. {
  601. scan = edge;
  603. RowInit(left, top);
  605. for(int steps = right - left; steps > 0; steps--)
  606. {
  607. (this->*m_pDrawVertex)(scan);
  608. scan += dscan;
  609. RowStep();
  610. }
  612. edge += dedge;
  613. }
  614. }
  616. template <class Vertex>
  617. bool GSRendererSoft<Vertex>::DrawFilledRect(int left, int top, int right, int bottom, const Vertex& v)
  618. {
  619. if(left >= right || top >= bottom)
  620. return false;
  622. ASSERT(top >= 0);
  623. ASSERT(bottom >= 0);
  625. if(m_pPRIM->IIP
  626. || m_ctxt->TEST.ZTE && m_ctxt->TEST.ZTST != 1
  627. || m_ctxt->TEST.ATE && m_ctxt->TEST.ATST != 1
  628. || m_ctxt->TEST.DATE
  629. || m_pPRIM->TME
  630. || m_pPRIM->ABE
  631. || m_pPRIM->FGE
  632. || m_de.DTHE.DTHE
  633. || m_ctxt->FRAME.FBMSK)
  634. return false;
  636. DWORD FBP = m_ctxt->FRAME.FBP<<5, FBW = m_ctxt->FRAME.FBW;
  637. DWORD ZBP = m_ctxt->ZBUF.ZBP<<5;
  639. if(!m_ctxt->ZBUF.ZMSK)
  640. {
  641. m_lm.FillRect(CRect(left, top, right, bottom), v.GetZ(), m_ctxt->ZBUF.PSM, ZBP, FBW);
  642. }
  644. __declspec(align(16)) union {struct {short Rf, Gf, Bf, Af;}; UINT64 Cui64;};
  645. Cui64 = v.c;
  647. Rf = m_clamp[Rf];
  648. Gf = m_clamp[Gf];
  649. Bf = m_clamp[Bf];
  650. Af |= m_ctxt->FBA.FBA << 7;
  652. DWORD Cdw;
  654. if(m_ctxt->FRAME.PSM == PSM_PSMCT16 || m_ctxt->FRAME.PSM == PSM_PSMCT16S)
  655. {
  656. Cdw = ((DWORD)(Rf&0xf8) >> 3)
  657. | ((DWORD)(Gf&0xf8) << 2) 
  658. | ((DWORD)(Bf&0xf8) << 7) 
  659. | ((DWORD)(Af&0x80) << 8);
  660. }
  661. else
  662. {
  663. #if _M_IX86_FP >= 2 || defined(_M_AMD64)
  664. __m128i r0 = _mm_load_si128((__m128i*)&Cui64);
  665. Cdw = (DWORD)_mm_cvtsi128_si32(_mm_packus_epi16(r0, r0));
  666. #else
  667. Cdw = ((DWORD)(Rf&0xff) << 0)
  668. | ((DWORD)(Gf&0xff) << 8) 
  669. | ((DWORD)(Bf&0xff) << 16) 
  670. | ((DWORD)(Af&0xff) << 24);
  671. #endif
  672. }
  674. m_lm.FillRect(CRect(left, top, right, bottom), Cdw, m_ctxt->FRAME.PSM, FBP, FBW);
  676. return true;
  677. }
  679. template <class Vertex>
  680. template <int iZTST, int iATST>
  681. void GSRendererSoft<Vertex>::DrawVertex(const Vertex& v)
  682. {
  683. DWORD vz;
  685. switch(iZTST)
  686. {
  687. case 0: return;
  688. case 1: break;
  689. case 2: vz = v.GetZ(); if(vz < (m_lm.*m_ctxt->ztbl->rpa)(m_zaddr)) return; break;
  690. case 3: vz = v.GetZ(); if(vz <= (m_lm.*m_ctxt->ztbl->rpa)(m_zaddr)) return; break;
  691. default: __assume(0);
  692. }
  694. union
  695. {
  696. struct {Vertex::Vector Cf, Cd, Ca;};
  697. struct {Vertex::Vector Cfda[3];};
  698. };
  700. Cf = v.c;
  702. if(m_pPRIM->TME)
  703. {
  704. (this->*m_pDrawVertexTFX)(Cf, v);
  705. }
  707. if(m_pPRIM->FGE)
  708. {
  709. Vertex::Scalar a = Cf.a;
  710. Vertex::Vector Cfog((DWORD)m_de.FOGCOL.ai32[0]);
  711. Cf = Cfog + (Cf - Cfog) * v.t.z;
  712. Cf.a = a;
  713. }
  715. BOOL ZMSK = m_ctxt->ZBUF.ZMSK;
  716. DWORD FBMSK = m_ctxt->FRAME.FBMSK;
  718. bool fAlphaPass = true;
  720. BYTE Af = (BYTE)(int)Cf.a;
  722. switch(iATST)
  723. {
  724. case 0: fAlphaPass = false; break;
  725. case 1: fAlphaPass = true; break;
  726. case 2: fAlphaPass = Af < m_ctxt->TEST.AREF; break;
  727. case 3: fAlphaPass = Af <= m_ctxt->TEST.AREF; break;
  728. case 4: fAlphaPass = Af == m_ctxt->TEST.AREF; break;
  729. case 5: fAlphaPass = Af >= m_ctxt->TEST.AREF; break;
  730. case 6: fAlphaPass = Af > m_ctxt->TEST.AREF; break;
  731. case 7: fAlphaPass = Af != m_ctxt->TEST.AREF; break;
  732. default: __assume(0);
  733. }
  735. if(!fAlphaPass)
  736. {
  737. switch(m_ctxt->TEST.AFAIL)
  738. {
  739. case 0: return;
  740. case 1: ZMSK = 1; break; // RGBA
  741. case 2: FBMSK = 0xffffffff; break; // Z
  742. case 3: FBMSK = 0xff000000; ZMSK = 1; break; // RGB
  743. default: __assume(0);
  744. }
  745. }
  747. if(!ZMSK)
  748. {
  749. if(iZTST != 2 && iZTST != 3) vz = v.GetZ(); 
  750. (m_lm.*m_ctxt->ztbl->wpa)(m_zaddr, vz);
  751. }
  753. if(FBMSK != ~0)
  754. {
  755. if(m_ctxt->TEST.DATE && m_ctxt->FRAME.PSM <= PSM_PSMCT16S && m_ctxt->FRAME.PSM != PSM_PSMCT24)
  756. {
  757. BYTE A = (BYTE)((m_lm.*m_ctxt->ftbl->rpa)(m_faddr) >> (m_ctxt->FRAME.PSM == PSM_PSMCT32 ? 31 : 15));
  758. if(A ^ m_ctxt->TEST.DATM) return;
  759. }
  761. // FIXME: for AA1 the value of Af should be calculated from the pixel coverage...
  763. bool fABE = (m_pPRIM->ABE || m_pPRIM->AA1 && (m_pPRIM->PRIM == 1 || m_pPRIM->PRIM == 2)) && (!m_de.PABE.PABE || (int)Cf.a >= 0x80);
  765. if(FBMSK || fABE)
  766. {
  767. GIFRegTEXA TEXA;
  768. /*
  769. TEXA.AEM = 0;
  770. TEXA.TA0 = 0;
  771. TEXA.TA1 = 0x80;
  772. */
  773. TEXA.ai32[0] = 0;
  774. TEXA.ai32[1] = 0x80;
  775. Cd = (m_lm.*m_ctxt->ftbl->rta)(m_faddr, m_ctxt->TEX0, TEXA);
  776. }
  778. if(fABE)
  779. {
  780. Ca = Vertex::Vector(Vertex::Scalar(0));
  781. Ca.a = Vertex::Scalar((int)m_ctxt->ALPHA.FIX);
  783. Vertex::Scalar a = Cf.a;
  784. Cf = ((Cfda[m_ctxt->ALPHA.A] - Cfda[m_ctxt->ALPHA.B]) * Cfda[m_ctxt->ALPHA.C].a >> 7) + Cfda[m_ctxt->ALPHA.D];
  785. Cf.a = a;
  786. }
  788. DWORD Cdw; 
  790. if(m_de.COLCLAMP.CLAMP && !m_de.DTHE.DTHE)
  791. {
  792. Cdw = Cf;
  793. }
  794. else
  795. {
  796. __declspec(align(16)) union {struct {short Rf, Gf, Bf, Af;}; UINT64 Cui64;};
  797. Cui64 = Cf;
  799. if(m_de.DTHE.DTHE)
  800. {
  801. short DMxy = (signed char)((*((WORD*)&m_de.DIMX.i64 + (m_fy&3)) >> ((m_fx&3)<<2)) << 5) >> 5;
  802. Rf += DMxy;
  803. Gf += DMxy;
  804. Bf += DMxy;
  805. }
  807. Rf = m_clamp[Rf];
  808. Gf = m_clamp[Gf];
  809. Bf = m_clamp[Bf];
  810. Af |= m_ctxt->FBA.FBA << 7;
  812. #if _M_IX86_FP >= 2 || defined(_M_AMD64)
  813. __m128i r0 = _mm_load_si128((__m128i*)&Cui64);
  814. Cdw = (DWORD)_mm_cvtsi128_si32(_mm_packus_epi16(r0, r0));
  815. #else
  816. Cdw = ((DWORD)(Rf&0xff) << 0)
  817. | ((DWORD)(Gf&0xff) << 8) 
  818. | ((DWORD)(Bf&0xff) << 16) 
  819. | ((DWORD)(Af&0xff) << 24);
  820. #endif
  821. }
  823. if(FBMSK != 0)
  824. {
  825. Cdw = (Cdw & ~FBMSK) | ((DWORD)Cd & FBMSK);
  826. }
  828. (m_lm.*m_ctxt->ftbl->wfa)(m_faddr, Cdw);
  829. }
  830. }
  832. static const float one_over_log2 = 1.0f / log(2.0f);
  834. template <class Vertex>
  835. template <int iLOD, bool bLCM, bool bTCC, int iTFX>
  836. void GSRendererSoft<Vertex>::DrawVertexTFX(typename Vertex::Vector& Cf, const Vertex& v)
  837. {
  838. ASSERT(m_pPRIM->TME);
  840. Vertex::Vector t = v.t;
  842. bool fBiLinear = iLOD == 2; 
  844. if(iLOD == 3)
  845. {
  846. fBiLinear = bLCM;
  847. }
  848. else
  849. {
  850. t.q.rcp();
  851. t *= t.q;
  853. if(iLOD == 1)
  854. {
  855. float lod = (float)(int)m_ctxt->TEX1.K;
  856. if(!bLCM) lod += log(fabs((float)t.q)) * one_over_log2 * (1 << m_ctxt->TEX1.L);
  857. fBiLinear = lod <= 0 && (m_ctxt->TEX1.MMAG & 1) || lod > 0 && (m_ctxt->TEX1.MMIN & 1);
  858. }
  859. }
  861. if(fBiLinear) t -= Vertex::Scalar(0.5f);
  863. __declspec(align(16)) short ituv[8] = {(int)t.x, (int)t.x+1, (int)t.y, (int)t.y+1};
  865. #if _M_IX86_FP >= 2 || defined(_M_AMD64)
  867. __m128i uv = _mm_load_si128((__m128i*)ituv);
  868. __m128i mask = _mm_load_si128((__m128i*)m_uv->mask);
  869. __m128i region = _mm_or_si128(_mm_and_si128(uv, *(__m128i*)m_uv->and), *(__m128i*)m_uv->or);
  870. __m128i clamp = _mm_min_epi16(_mm_max_epi16(uv, *(__m128i*)m_uv->min), *(__m128i*)m_uv->max);
  871. _mm_store_si128((__m128i*)ituv, _mm_or_si128(_mm_and_si128(region, mask), _mm_andnot_si128(mask, clamp)));
  873. #else
  875. for(int i = 0; i < 4; i++)
  876. {
  877. short region = (ituv[i] & m_uv->and[i]) | m_uv->or[i];
  878. short clamp = ituv[i] < m_uv->min[i] ? m_uv->min[i] : ituv[i] > m_uv->max[i] ? m_uv->max[i] : ituv[i];
  879. ituv[i] = (region & m_uv->mask[i]) | (clamp & ~m_uv->mask[i]);
  880. }
  882. #endif
  884. Vertex::Vector Ct[4];
  886. if(fBiLinear)
  887. {
  888. if(0 && m_pTexture)
  889. {
  890. Ct[0] = m_pTexture[(ituv[2] << m_ctxt->TEX0.TW) + ituv[0]];
  891. Ct[1] = m_pTexture[(ituv[2] << m_ctxt->TEX0.TW) + ituv[1]];
  892. Ct[2] = m_pTexture[(ituv[3] << m_ctxt->TEX0.TW) + ituv[0]];
  893. Ct[3] = m_pTexture[(ituv[3] << m_ctxt->TEX0.TW) + ituv[1]];
  894. }
  895. else
  896. {
  897. Ct[0] = (m_lm.*m_ctxt->ttbl->rt)(ituv[0], ituv[2], m_ctxt->TEX0, m_de.TEXA);
  898. Ct[1] = (m_lm.*m_ctxt->ttbl->rt)(ituv[1], ituv[2], m_ctxt->TEX0, m_de.TEXA);
  899. Ct[2] = (m_lm.*m_ctxt->ttbl->rt)(ituv[0], ituv[3], m_ctxt->TEX0, m_de.TEXA);
  900. Ct[3] = (m_lm.*m_ctxt->ttbl->rt)(ituv[1], ituv[3], m_ctxt->TEX0, m_de.TEXA);
  901. }
  903. Vertex::Vector ft = t - t.floor();
  905. Ct[0] = Ct[0] + (Ct[1] - Ct[0]) * ft.x;
  906. Ct[2] = Ct[2] + (Ct[3] - Ct[2]) * ft.x;
  907. Ct[0] = Ct[0] + (Ct[2] - Ct[0]) * ft.y;
  908. }
  909. else 
  910. {
  911. if(0 && m_pTexture)
  912. {
  913. Ct[0] = m_pTexture[(ituv[2] << m_ctxt->TEX0.TW) + ituv[0]];
  914. }
  915. else
  916. {
  917. Ct[0] = (m_lm.*m_ctxt->ttbl->rt)(ituv[0], ituv[2], m_ctxt->TEX0, m_de.TEXA);
  918. }
  919. }
  921. Vertex::Scalar a = Cf.a;
  923. switch(iTFX)
  924. {
  925. case 0:
  926. Cf = (Cf * Ct[0] >> 7);
  927. if(!bTCC) Cf.a = a;
  928. break;
  929. case 1:
  930. Cf = Ct[0];
  931. break;
  932. case 2:
  933. Cf = (Cf * Ct[0] >> 7) + Cf.a;
  934. Cf.a = !bTCC ? a : (Ct[0].a + a);
  935. break;
  936. case 3:
  937. Cf = (Cf * Ct[0] >> 7) + Cf.a;
  938. Cf.a = !bTCC ? a : Ct[0].a;
  939. break;
  940. default: 
  941. __assume(0);
  942. }
  944. Cf.sat();
  945. }
  947. template <class Vertex>
  948. void GSRendererSoft<Vertex>::SetupTexture()
  949. {
  950. if(!m_pPRIM->TME) return;
  952. m_lm.SetupCLUT32(m_ctxt->TEX0, m_de.TEXA);
  954. //
  956. int tw = 1 << m_ctxt->TEX0.TW;
  957. int th = 1 << m_ctxt->TEX0.TH;
  959. switch(m_ctxt->CLAMP.WMS)
  960. {
  961. case 0: m_uv->and[0] = tw-1; m_uv->or[0] = 0; m_uv->mask[0] = 0xffff; break;
  962. case 1: m_uv->min[0] = 0; m_uv->max[0] = tw-1; m_uv->mask[0] = 0; break;
  963. case 2: m_uv->min[0] = m_ctxt->CLAMP.MINU; m_uv->max[0] = m_ctxt->CLAMP.MAXU; m_uv->mask[0] = 0; break;
  964. case 3: m_uv->and[0] = m_ctxt->CLAMP.MINU; m_uv->or[0] = m_ctxt->CLAMP.MAXU; m_uv->mask[0] = 0xffff; break;
  965. default: __assume(0);
  966. }
  968. m_uv->and[1] = m_uv->and[0];
  969. m_uv->or[1] = m_uv->or[0];
  970. m_uv->min[1] = m_uv->min[0];
  971. m_uv->max[1] = m_uv->max[0];
  972. m_uv->mask[1] = m_uv->mask[0];
  974. switch(m_ctxt->CLAMP.WMT)
  975. {
  976. case 0: m_uv->and[2] = th-1; m_uv->or[2] = 0; m_uv->mask[2] = 0xffff; break;
  977. case 1: m_uv->min[2] = 0; m_uv->max[2] = th-1; m_uv->mask[2] = 0; break;
  978. case 2: m_uv->min[2] = m_ctxt->CLAMP.MINV; m_uv->max[2] = m_ctxt->CLAMP.MAXV; m_uv->mask[2] = 0; break;
  979. case 3: m_uv->and[2] = m_ctxt->CLAMP.MINV; m_uv->or[2] = m_ctxt->CLAMP.MAXV; m_uv->mask[2] = 0xffff; break;
  980. default: __assume(0);
  981. }
  983. m_uv->and[3] = m_uv->and[2];
  984. m_uv->or[3] = m_uv->or[2];
  985. m_uv->min[3] = m_uv->min[2];
  986. m_uv->max[3] = m_uv->max[2];
  987. m_uv->mask[3] = m_uv->mask[2];
  988. }
  990. //
  991. // GSRendererSoftFP
  992. //
  994. GSRendererSoftFP::GSRendererSoftFP(HWND hWnd, HRESULT& hr)
  995. : GSRendererSoft<GSSoftVertexFP>(hWnd, hr)
  996. {
  997. }
  999. void GSRendererSoftFP::VertexKick(bool fSkip)
  1000. {
  1001. GSSoftVertexFP& v = m_vl.AddTail();
  1003. v.c = (DWORD)m_v.RGBAQ.ai32[0];
  1005. v.p.x = (int)m_v.XYZ.X - (int)m_ctxt->XYOFFSET.OFX;
  1006. v.p.y = (int)m_v.XYZ.Y - (int)m_ctxt->XYOFFSET.OFY;
  1007. v.p *= GSSoftVertexFP::Scalar(1.0f/16);
  1008. v.p.z = (float)(m_v.XYZ.Z >> 16);
  1009. v.p.q = (float)(m_v.XYZ.Z & 0xffff);
  1011. if(m_pPRIM->TME)
  1012. {
  1013. if(m_pPRIM->FST)
  1014. {
  1015. v.t.x = (float)(int)m_v.UV.U;
  1016. v.t.y = (float)(int)m_v.UV.V;
  1017. v.t *= GSSoftVertexFP::Scalar(1.0f/16);
  1018. v.t.q = 1.0f;
  1019. }
  1020. else
  1021. {
  1022. v.t.x = m_v.ST.S * (1 << m_ctxt->TEX0.TW);
  1023. v.t.y = m_v.ST.T * (1 << m_ctxt->TEX0.TH);
  1024. v.t.q = m_v.RGBAQ.Q;
  1025. }
  1026. }
  1028. if(m_pPRIM->FGE)
  1029. {
  1030. v.t.z = (float)m_v.FOG.F * (1.0f/255);
  1031. }
  1033. __super::VertexKick(fSkip);
  1034. }
  1035. /*
  1036. //
  1037. // GSRendererSoftFX
  1038. //
  1040. GSRendererSoftFX::GSRendererSoftFX(HWND hWnd, HRESULT& hr)
  1041. : GSRendererSoft<GSSoftVertexFX>(hWnd, hr)
  1042. {
  1043. }
  1045. void GSRendererSoftFX::VertexKick(bool fSkip)
  1046. {
  1047. GSSoftVertexFX& v = m_vl.AddTail();
  1049. v.c = (DWORD)m_v.RGBAQ.ai32[0];
  1051. v.p.x = ((int)m_v.XYZ.X - (int)m_ctxt->XYOFFSET.OFX) << 12;
  1052. v.p.y = ((int)m_v.XYZ.Y - (int)m_ctxt->XYOFFSET.OFY) << 12;
  1053. v.p.z = (int)((m_v.XYZ.Z & 0xffff0000) >> 1);
  1054. v.p.q = (int)((m_v.XYZ.Z & 0x0000ffff) << 15);
  1056. if(m_pPRIM->TME)
  1057. {
  1058. if(m_pPRIM->FST)
  1059. {
  1060. v.t.x = ((int)m_v.UV.U << (12 >> m_ctxt->TEX0.TW));
  1061. v.t.y = ((int)m_v.UV.V << (12 >> m_ctxt->TEX0.TH));
  1062. v.t.q = 1<<16;
  1063. }
  1064. else
  1065. {
  1066. // TODO
  1067. v.t.x = m_v.ST.S;
  1068. v.t.y = m_v.ST.T;
  1069. v.t.q = m_v.RGBAQ.Q;
  1070. }
  1071. }
  1073. if(m_pPRIM->FGE)
  1074. {
  1075. v.t.z = (int)m_v.FOG.F << 8;
  1076. }
  1078. __super::VertexKick(fSkip);
  1079. }
  1080. */