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

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

多媒体编程

开发平台：

Visual C++

GSState.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 "GSState.h"
  24. #include "GSdx9.h"
  25. #include "GSUtil.h"
  26. #include "resource.h"
  28. //
  29. // GSState
  30. //
  32. GSState::GSState(int w, int h, HWND hWnd, HRESULT& hr) 
  33. : m_hWnd(hWnd)
  34. , m_width(w)
  35. , m_height(h)
  36. , m_sfp(NULL)
  37. , m_fp(NULL)
  38. , m_iOSD(1)
  39. , m_nVSync(0)
  40. {
  41. hr = E_FAIL;
  43. AFX_MANAGE_STATE(AfxGetStaticModuleState());
  45.     CWinApp* pApp = AfxGetApp();
  47. m_v.RGBAQ.Q = m_q = 1.0f;
  49. memset(m_path, 0, sizeof(m_path));
  51. m_de.PRMODECONT.AC = 1;
  52. m_pPRIM = &m_de.PRIM;
  53. m_PRIM = 8;
  55. m_pCSRr = &m_rs.CSRr;
  56. m_fpGSirq = NULL;
  58. m_ctxt = &m_de.CTXT[0];
  60. m_pTrBuff = (BYTE*)_aligned_malloc(1024*1024*4, 16);
  61. m_nTrBytes = 0;
  63. for(int i = 0; i < countof(m_fpGIFPackedRegHandlers); i++)
  64. m_fpGIFPackedRegHandlers[i] = &GSState::GIFPackedRegHandlerNull;
  66. m_fpGIFPackedRegHandlers[GIF_REG_PRIM] = &GSState::GIFPackedRegHandlerPRIM;
  67. m_fpGIFPackedRegHandlers[GIF_REG_RGBA] = &GSState::GIFPackedRegHandlerRGBA;
  68. m_fpGIFPackedRegHandlers[GIF_REG_STQ] = &GSState::GIFPackedRegHandlerSTQ;
  69. m_fpGIFPackedRegHandlers[GIF_REG_UV] = &GSState::GIFPackedRegHandlerUV;
  70. m_fpGIFPackedRegHandlers[GIF_REG_XYZF2] = &GSState::GIFPackedRegHandlerXYZF2;
  71. m_fpGIFPackedRegHandlers[GIF_REG_XYZ2] = &GSState::GIFPackedRegHandlerXYZ2;
  72. m_fpGIFPackedRegHandlers[GIF_REG_TEX0_1] = &GSState::GIFPackedRegHandlerTEX0_1;
  73. m_fpGIFPackedRegHandlers[GIF_REG_TEX0_2] = &GSState::GIFPackedRegHandlerTEX0_2;
  74. m_fpGIFPackedRegHandlers[GIF_REG_CLAMP_1] = &GSState::GIFPackedRegHandlerCLAMP_1;
  75. m_fpGIFPackedRegHandlers[GIF_REG_CLAMP_2] = &GSState::GIFPackedRegHandlerCLAMP_2;
  76. m_fpGIFPackedRegHandlers[GIF_REG_FOG] = &GSState::GIFPackedRegHandlerFOG;
  77. m_fpGIFPackedRegHandlers[GIF_REG_XYZF3] = &GSState::GIFPackedRegHandlerXYZF3;
  78. m_fpGIFPackedRegHandlers[GIF_REG_XYZ3] = &GSState::GIFPackedRegHandlerXYZ3;
  79. m_fpGIFPackedRegHandlers[GIF_REG_A_D] = &GSState::GIFPackedRegHandlerA_D;
  80. m_fpGIFPackedRegHandlers[GIF_REG_NOP] = &GSState::GIFPackedRegHandlerNOP;
  82. for(int i = 0; i < countof(m_fpGIFRegHandlers); i++)
  83. m_fpGIFRegHandlers[i] = &GSState::GIFRegHandlerNull;
  85. m_fpGIFRegHandlers[GIF_A_D_REG_PRIM] = &GSState::GIFRegHandlerPRIM;
  86. m_fpGIFRegHandlers[GIF_A_D_REG_RGBAQ] = &GSState::GIFRegHandlerRGBAQ;
  87. m_fpGIFRegHandlers[GIF_A_D_REG_ST] = &GSState::GIFRegHandlerST;
  88. m_fpGIFRegHandlers[GIF_A_D_REG_UV] = &GSState::GIFRegHandlerUV;
  89. m_fpGIFRegHandlers[GIF_A_D_REG_XYZF2] = &GSState::GIFRegHandlerXYZF2;
  90. m_fpGIFRegHandlers[GIF_A_D_REG_XYZ2] = &GSState::GIFRegHandlerXYZ2;
  91. m_fpGIFRegHandlers[GIF_A_D_REG_TEX0_1] = &GSState::GIFRegHandlerTEX0_1;
  92. m_fpGIFRegHandlers[GIF_A_D_REG_TEX0_2] = &GSState::GIFRegHandlerTEX0_2;
  93. m_fpGIFRegHandlers[GIF_A_D_REG_CLAMP_1] = &GSState::GIFRegHandlerCLAMP_1;
  94. m_fpGIFRegHandlers[GIF_A_D_REG_CLAMP_2] = &GSState::GIFRegHandlerCLAMP_2;
  95. m_fpGIFRegHandlers[GIF_A_D_REG_FOG] = &GSState::GIFRegHandlerFOG;
  96. m_fpGIFRegHandlers[GIF_A_D_REG_XYZF3] = &GSState::GIFRegHandlerXYZF3;
  97. m_fpGIFRegHandlers[GIF_A_D_REG_XYZ3] = &GSState::GIFRegHandlerXYZ3;
  98. m_fpGIFRegHandlers[GIF_A_D_REG_NOP] = &GSState::GIFRegHandlerNOP;
  99. m_fpGIFRegHandlers[GIF_A_D_REG_TEX1_1] = &GSState::GIFRegHandlerTEX1_1;
  100. m_fpGIFRegHandlers[GIF_A_D_REG_TEX1_2] = &GSState::GIFRegHandlerTEX1_2;
  101. m_fpGIFRegHandlers[GIF_A_D_REG_TEX2_1] = &GSState::GIFRegHandlerTEX2_1;
  102. m_fpGIFRegHandlers[GIF_A_D_REG_TEX2_2] = &GSState::GIFRegHandlerTEX2_2;
  103. m_fpGIFRegHandlers[GIF_A_D_REG_XYOFFSET_1] = &GSState::GIFRegHandlerXYOFFSET_1;
  104. m_fpGIFRegHandlers[GIF_A_D_REG_XYOFFSET_2] = &GSState::GIFRegHandlerXYOFFSET_2;
  105. m_fpGIFRegHandlers[GIF_A_D_REG_PRMODECONT] = &GSState::GIFRegHandlerPRMODECONT;
  106. m_fpGIFRegHandlers[GIF_A_D_REG_PRMODE] = &GSState::GIFRegHandlerPRMODE;
  107. m_fpGIFRegHandlers[GIF_A_D_REG_TEXCLUT] = &GSState::GIFRegHandlerTEXCLUT;
  108. m_fpGIFRegHandlers[GIF_A_D_REG_SCANMSK] = &GSState::GIFRegHandlerSCANMSK;
  109. m_fpGIFRegHandlers[GIF_A_D_REG_MIPTBP1_1] = &GSState::GIFRegHandlerMIPTBP1_1;
  110. m_fpGIFRegHandlers[GIF_A_D_REG_MIPTBP1_2] = &GSState::GIFRegHandlerMIPTBP1_2;
  111. m_fpGIFRegHandlers[GIF_A_D_REG_MIPTBP2_1] = &GSState::GIFRegHandlerMIPTBP2_1;
  112. m_fpGIFRegHandlers[GIF_A_D_REG_MIPTBP2_2] = &GSState::GIFRegHandlerMIPTBP2_2;
  113. m_fpGIFRegHandlers[GIF_A_D_REG_TEXA] = &GSState::GIFRegHandlerTEXA;
  114. m_fpGIFRegHandlers[GIF_A_D_REG_FOGCOL] = &GSState::GIFRegHandlerFOGCOL;
  115. m_fpGIFRegHandlers[GIF_A_D_REG_TEXFLUSH] = &GSState::GIFRegHandlerTEXFLUSH;
  116. m_fpGIFRegHandlers[GIF_A_D_REG_SCISSOR_1] = &GSState::GIFRegHandlerSCISSOR_1;
  117. m_fpGIFRegHandlers[GIF_A_D_REG_SCISSOR_2] = &GSState::GIFRegHandlerSCISSOR_2;
  118. m_fpGIFRegHandlers[GIF_A_D_REG_ALPHA_1] = &GSState::GIFRegHandlerALPHA_1;
  119. m_fpGIFRegHandlers[GIF_A_D_REG_ALPHA_2] = &GSState::GIFRegHandlerALPHA_2;
  120. m_fpGIFRegHandlers[GIF_A_D_REG_DIMX] = &GSState::GIFRegHandlerDIMX;
  121. m_fpGIFRegHandlers[GIF_A_D_REG_DTHE] = &GSState::GIFRegHandlerDTHE;
  122. m_fpGIFRegHandlers[GIF_A_D_REG_COLCLAMP] = &GSState::GIFRegHandlerCOLCLAMP;
  123. m_fpGIFRegHandlers[GIF_A_D_REG_TEST_1] = &GSState::GIFRegHandlerTEST_1;
  124. m_fpGIFRegHandlers[GIF_A_D_REG_TEST_2] = &GSState::GIFRegHandlerTEST_2;
  125. m_fpGIFRegHandlers[GIF_A_D_REG_PABE] = &GSState::GIFRegHandlerPABE;
  126. m_fpGIFRegHandlers[GIF_A_D_REG_FBA_1] = &GSState::GIFRegHandlerFBA_1;
  127. m_fpGIFRegHandlers[GIF_A_D_REG_FBA_2] = &GSState::GIFRegHandlerFBA_2;
  128. m_fpGIFRegHandlers[GIF_A_D_REG_FRAME_1] = &GSState::GIFRegHandlerFRAME_1;
  129. m_fpGIFRegHandlers[GIF_A_D_REG_FRAME_2] = &GSState::GIFRegHandlerFRAME_2;
  130. m_fpGIFRegHandlers[GIF_A_D_REG_ZBUF_1] = &GSState::GIFRegHandlerZBUF_1;
  131. m_fpGIFRegHandlers[GIF_A_D_REG_ZBUF_2] = &GSState::GIFRegHandlerZBUF_2;
  132. m_fpGIFRegHandlers[GIF_A_D_REG_BITBLTBUF] = &GSState::GIFRegHandlerBITBLTBUF;
  133. m_fpGIFRegHandlers[GIF_A_D_REG_TRXPOS] = &GSState::GIFRegHandlerTRXPOS;
  134. m_fpGIFRegHandlers[GIF_A_D_REG_TRXREG] = &GSState::GIFRegHandlerTRXREG;
  135. m_fpGIFRegHandlers[GIF_A_D_REG_TRXDIR] = &GSState::GIFRegHandlerTRXDIR;
  136. m_fpGIFRegHandlers[GIF_A_D_REG_HWREG] = &GSState::GIFRegHandlerHWREG;
  137. m_fpGIFRegHandlers[GIF_A_D_REG_SIGNAL] = &GSState::GIFRegHandlerSIGNAL;
  138. m_fpGIFRegHandlers[GIF_A_D_REG_FINISH] = &GSState::GIFRegHandlerFINISH;
  139. m_fpGIFRegHandlers[GIF_A_D_REG_LABEL] = &GSState::GIFRegHandlerLABEL;
  141. // DD
  143. CComPtr<IDirectDraw7> pDD; 
  144. if(FAILED(DirectDrawCreateEx(0, (void**)&pDD, IID_IDirectDraw7, 0)))
  145. return;
  147. m_ddcaps.dwSize = sizeof(DDCAPS); 
  148. if(FAILED(pDD->GetCaps(&m_ddcaps, NULL)))
  149. return;
  151. pDD = NULL;
  153. // D3D
  155. if(!(m_pD3D = Direct3DCreate9(D3D_SDK_VERSION))
  156. && !(m_pD3D = Direct3DCreate9(D3D9b_SDK_VERSION)))
  157. return;
  159. ZeroMemory(&m_caps, sizeof(m_caps));
  160. m_pD3D->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_X, &m_caps);
  162. m_fmtDepthStencil = 
  163. IsDepthFormatOk(m_pD3D, D3DFMT_D32, D3DFMT_X8R8G8B8, D3DFMT_X8R8G8B8) ? D3DFMT_D32 :
  164. IsDepthFormatOk(m_pD3D, D3DFMT_D24X8, D3DFMT_X8R8G8B8, D3DFMT_X8R8G8B8) ? D3DFMT_D24X8 :
  165. D3DFMT_D16;
  167. // D3D Device
  169. if(FAILED(ResetDevice(true)))
  170. return;
  172. // Shaders
  174. DWORD PixelShaderVersion = pApp->GetProfileInt(_T("Settings"), _T("PixelShaderVersion2"), D3DPS_VERSION(2, 0));
  176. if(PixelShaderVersion > m_caps.PixelShaderVersion)
  177. {
  178. CString str;
  179. str.Format(_T("Supported pixel shader version is too low!nnSupported: %d.%dnSelected: %d.%d"),
  180. D3DSHADER_VERSION_MAJOR(m_caps.PixelShaderVersion), D3DSHADER_VERSION_MINOR(m_caps.PixelShaderVersion),
  181. D3DSHADER_VERSION_MAJOR(PixelShaderVersion), D3DSHADER_VERSION_MINOR(PixelShaderVersion));
  182. AfxMessageBox(str);
  183. m_pD3DDev = NULL;
  184. return;
  185. }
  187. m_caps.PixelShaderVersion = min(PixelShaderVersion, m_caps.PixelShaderVersion);
  189. static const TCHAR* hlsl_tfx[] = 
  190. {
  191. _T("main_tfx0_32"), _T("main_tfx1_32"), _T("main_tfx2_32"), _T("main_tfx3_32"),
  192. _T("main_tfx0_24"), _T("main_tfx1_24"), _T("main_tfx2_24"), _T("main_tfx3_24"),
  193. _T("main_tfx0_24AEM"), _T("main_tfx1_24AEM"), _T("main_tfx2_24AEM"), _T("main_tfx3_24AEM"),
  194. _T("main_tfx0_16"), _T("main_tfx1_16"), _T("main_tfx2_16"), _T("main_tfx3_16"), 
  195. _T("main_tfx0_16AEM"), _T("main_tfx1_16AEM"), _T("main_tfx2_16AEM"), _T("main_tfx3_16AEM"), 
  196. _T("main_tfx0_8P_pt"), _T("main_tfx1_8P_pt"), _T("main_tfx2_8P_pt"), _T("main_tfx3_8P_pt"), 
  197. _T("main_tfx0_8P_ln"), _T("main_tfx1_8P_ln"), _T("main_tfx2_8P_ln"), _T("main_tfx3_8P_ln"), 
  198. _T("main_tfx0_8HP_pt"), _T("main_tfx1_8HP_pt"), _T("main_tfx2_8HP_pt"), _T("main_tfx3_8HP_pt"), 
  199. _T("main_tfx0_8HP_ln"), _T("main_tfx1_8HP_ln"), _T("main_tfx2_8HP_ln"), _T("main_tfx3_8HP_ln"),
  200. _T("main_notfx"), 
  201. _T("main_8PTo32"),
  202. };
  204. // ps_3_0
  206. if(m_caps.PixelShaderVersion >= D3DPS_VERSION(3, 0))
  207. {
  208. for(int i = 0; i < countof(hlsl_tfx); i++)
  209. {
  210. if(m_pHLSLTFX[i]) continue;
  212. CompileShaderFromResource(m_pD3DDev, IDR_HLSL_TFX, hlsl_tfx[i], _T("ps_3_0"),
  213. D3DXSHADER_AVOID_FLOW_CONTROL|D3DXSHADER_PARTIALPRECISION, &m_pHLSLTFX[i]);
  214. }
  216. for(int i = 0; i < 3; i++)
  217. {
  218. if(m_pHLSLMerge[i]) continue;
  220. CString main;
  221. main.Format(_T("main%d"), i);
  222. CompileShaderFromResource(m_pD3DDev, IDR_HLSL_MERGE, main, _T("ps_3_0"), 
  223. D3DXSHADER_AVOID_FLOW_CONTROL|D3DXSHADER_PARTIALPRECISION, &m_pHLSLMerge[i]);
  224. }
  225. }
  227. // ps_2_0
  229. if(m_caps.PixelShaderVersion >= D3DPS_VERSION(2, 0))
  230. {
  231. for(int i = 0; i < countof(hlsl_tfx); i++)
  232. {
  233. if(m_pHLSLTFX[i]) continue;
  235. CompileShaderFromResource(m_pD3DDev, IDR_HLSL_TFX, hlsl_tfx[i], _T("ps_2_0"), 
  236. D3DXSHADER_PARTIALPRECISION, &m_pHLSLTFX[i]);
  237. }
  239. for(int i = 0; i < 3; i++)
  240. {
  241. if(m_pHLSLMerge[i]) continue;
  243. CString main;
  244. main.Format(_T("main%d"), i);
  245. CompileShaderFromResource(m_pD3DDev, IDR_HLSL_MERGE, main, _T("ps_2_0"), 
  246. D3DXSHADER_PARTIALPRECISION, &m_pHLSLMerge[i]);
  247. }
  248. }
  250. // ps_1_1 + ps_1_4
  252. if(m_caps.PixelShaderVersion >= D3DPS_VERSION(1, 1))
  253. {
  254. static const UINT nShaderIDs[] = 
  255. {
  256. IDR_PS11_TFX000, IDR_PS11_TFX010, IDR_PS11_TFX011, 
  257. IDR_PS11_TFX1x0, IDR_PS11_TFX1x1,
  258. IDR_PS11_TFX200, IDR_PS11_TFX210, IDR_PS11_TFX211,
  259. IDR_PS11_TFX300, IDR_PS11_TFX310, IDR_PS11_TFX311,
  260. IDR_PS11_TFX4xx,
  261. IDR_PS11_EN11, IDR_PS11_EN01, IDR_PS11_EN10, IDR_PS11_EN00,
  262. IDR_PS14_EN11, IDR_PS14_EN01, IDR_PS14_EN10, IDR_PS14_EN00
  263. };
  265. for(int i = 0; i < countof(nShaderIDs); i++)
  266. {
  267. if(m_pPixelShaders[i]) continue;
  268. AssembleShaderFromResource(m_pD3DDev, nShaderIDs[i], 0, &m_pPixelShaders[i]);
  269. }
  271. if(!m_pHLSLRedBlue)
  272. {
  273. CompileShaderFromResource(m_pD3DDev, IDR_HLSL_RB, _T("main"), _T("ps_1_1"), 
  274. D3DXSHADER_PARTIALPRECISION, &m_pHLSLRedBlue);
  275. }
  276. }
  278. //
  280. m_strDefaultTitle.ReleaseBufferSetLength(GetWindowText(m_hWnd, m_strDefaultTitle.GetBuffer(256), 256));
  282. m_fEnablePalettizedTextures = !!pApp->GetProfileInt(_T("Settings"), _T("fEnablePalettizedTextures"), FALSE);
  284. //
  286. m_pRefClock = new CBaseReferenceClock(_T("RefClock"), NULL, &hr);
  288. //
  290. hr = S_OK;
  292. Reset();
  294. #if defined(DEBUG_LOG) || defined(DEBUG_LOG2)
  295. ::DeleteFile(_T("g:\gs.txt"));
  296. m_fp = _tfopen(_T("g:\gs.txt"), _T("at"));
  297. #endif
  299. // m_pCSRr->REV = 0x20;
  301. /*
  302. GSLocalMemory lm;
  304. int w = 512, h = 512;
  306. for(int y = 0; y < h; y++)
  307. {
  308. for(int x = 0; x < w; x++)
  309. {
  310. lm.writePixel24(x, y, (x * 255 / w) | ((y * 255 / h) << 8), 0x500, 8);
  311. }
  312. }
  314. for(int i = 16; i > 0; i--)
  315. {
  316. CString fn;
  317. fn.Format(_T("g:/%02d.bmp"), i);
  318. lm.SaveBMP(m_pD3DDev, fn, 0x500, i, PSM_PSMCT24, i*64, 512);
  319. }
  320. */
  321. }
  323. GSState::~GSState()
  324. {
  325. Reset();
  326. _aligned_free(m_pTrBuff);
  327. if(m_sfp) fclose(m_sfp);
  328. if(m_fp) fclose(m_fp);
  329. }
  331. HRESULT GSState::ResetDevice(bool fForceWindowed)
  332. {
  333. AFX_MANAGE_STATE(AfxGetStaticModuleState());
  334. HMODULE hModule = AfxGetResourceHandle();
  335.     CWinApp* pApp = AfxGetApp();
  337. HRESULT hr;
  339. if(!m_pD3D)
  340. return E_FAIL;
  342. m_pOrgRenderTarget = NULL;
  343. m_pTmpRenderTarget = NULL;
  344. m_pD3DXFont = NULL;
  346. ZeroMemory(&m_d3dpp, sizeof(m_d3dpp));
  347. m_d3dpp.Windowed = TRUE;
  348. m_d3dpp.hDeviceWindow = m_hWnd;
  349. m_d3dpp.SwapEffect = /*D3DSWAPEFFECT_COPY*/D3DSWAPEFFECT_DISCARD/*D3DSWAPEFFECT_FLIP*/;
  350. m_d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;
  351. m_d3dpp.BackBufferWidth = m_width;
  352. m_d3dpp.BackBufferHeight = m_height;
  353. //m_d3dpp.BackBufferCount = 3;
  354. m_d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
  356. if(!!pApp->GetProfileInt(_T("Settings"), _T("fEnableTvOut"), FALSE))
  357. m_d3dpp.Flags |= D3DPRESENTFLAG_VIDEO;
  359. int ModeWidth = pApp->GetProfileInt(_T("Settings"), _T("ModeWidth"), 0);
  360. int ModeHeight = pApp->GetProfileInt(_T("Settings"), _T("ModeHeight"), 0);
  361. int ModeRefreshRate = pApp->GetProfileInt(_T("Settings"), _T("ModeRefreshRate"), 0);
  363. if(!fForceWindowed && ModeWidth > 0 && ModeHeight > 0 && ModeRefreshRate >= 0)
  364. {
  365. m_d3dpp.Windowed = FALSE;
  366. m_d3dpp.BackBufferWidth = ModeWidth;
  367. m_d3dpp.BackBufferHeight = ModeHeight;
  368. m_d3dpp.FullScreen_RefreshRateInHz = ModeRefreshRate;
  369. m_d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
  371. ::SetWindowLong(m_hWnd, GWL_STYLE, ::GetWindowLong(m_hWnd, GWL_STYLE) & ~(WS_CAPTION|WS_THICKFRAME));
  372. ::SetWindowPos(m_hWnd, NULL, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
  373. ::SetMenu(m_hWnd, NULL);
  375. m_iOSD = 0;
  376. }
  378. if(!m_pD3DDev)
  379. {
  380. if(FAILED(hr = m_pD3D->CreateDevice(
  381. // m_pD3D->GetAdapterCount()-1, D3DDEVTYPE_REF,
  382. D3DADAPTER_DEFAULT, D3DDEVTYPE_X, 
  383. m_hWnd,
  384. m_caps.VertexProcessingCaps ? D3DCREATE_HARDWARE_VERTEXPROCESSING : D3DCREATE_SOFTWARE_VERTEXPROCESSING, 
  385. &m_d3dpp, &m_pD3DDev)))
  386. return hr;
  387. }
  388. else
  389. {
  390. if(FAILED(hr = m_pD3DDev->Reset(&m_d3dpp)))
  391. {
  392. if(D3DERR_DEVICELOST == hr)
  393. {
  394. Sleep(1000);
  395. if(FAILED(hr = m_pD3DDev->Reset(&m_d3dpp)))
  396. return hr;
  397. }
  398. else
  399. {
  400. return hr;
  401. }
  402. }
  403. }
  405. CComPtr<IDirect3DSurface9> pBackBuff;
  406. hr = m_pD3DDev->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &pBackBuff);
  408. ZeroMemory(&m_bd, sizeof(m_bd));
  409. pBackBuff->GetDesc(&m_bd);
  411. hr = m_pD3DDev->Clear(0, NULL, D3DCLEAR_TARGET, 0, 1.0f, 0);
  413.     hr = m_pD3DDev->GetRenderTarget(0, &m_pOrgRenderTarget);
  415. if(m_caps.PixelShaderVersion >= D3DPS_VERSION(1, 1) && m_caps.PixelShaderVersion <= D3DPS_VERSION(1, 3)
  416. && m_pHLSLRedBlue)
  417. {
  418. hr = m_pD3DDev->CreateTexture(
  419. m_bd.Width, m_bd.Height, 0, D3DUSAGE_RENDERTARGET, D3DFMT_X8R8G8B8, 
  420. D3DPOOL_DEFAULT, &m_pTmpRenderTarget, NULL);
  421. }
  423. D3DXFONT_DESC fd;
  424. memset(&fd, 0, sizeof(fd));
  425. _tcscpy(fd.FaceName, _T("Arial"));
  426. fd.Height = -(int)(sqrt((float)m_bd.Height) * 0.7);
  427. hr = D3DXCreateFontIndirect(m_pD3DDev, &fd, &m_pD3DXFont);
  429.     hr = m_pD3DDev->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
  430.     hr = m_pD3DDev->SetRenderState(D3DRS_LIGHTING, FALSE);
  432. m_texfilter = (D3DTEXTUREFILTERTYPE)pApp->GetProfileInt(_T("Settings"), _T("TexFilter"), D3DTEXF_LINEAR);
  434. for(int i = 0; i < 8; i++)
  435. {
  436. hr = m_pD3DDev->SetSamplerState(i, D3DSAMP_MAGFILTER, m_texfilter);
  437. hr = m_pD3DDev->SetSamplerState(i, D3DSAMP_MINFILTER, m_texfilter);
  438. // hr = m_pD3DDev->SetSamplerState(i, D3DSAMP_MIPFILTER, m_texfilter);
  439. hr = m_pD3DDev->SetSamplerState(i, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
  440. hr = m_pD3DDev->SetSamplerState(i, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
  441. }
  443. hr = m_pD3DDev->SetRenderState(D3DRS_SEPARATEALPHABLENDENABLE, TRUE);
  444. hr = m_pD3DDev->SetRenderState(D3DRS_BLENDOPALPHA, D3DBLENDOP_ADD);
  445. hr = m_pD3DDev->SetRenderState(D3DRS_SRCBLENDALPHA, D3DBLEND_ONE);
  446. hr = m_pD3DDev->SetRenderState(D3DRS_DESTBLENDALPHA, D3DBLEND_ZERO);
  448. return S_OK;
  449. }
  451. UINT32 GSState::Freeze(freezeData* fd, bool fSizeOnly)
  452. {
  453. int size = sizeof(m_version)
  454. + sizeof(m_de) + sizeof(m_rs) + sizeof(m_v) 
  455. + sizeof(m_x) + sizeof(m_y) + 1024*1024*4
  456. + sizeof(m_path) + sizeof(m_q)
  457. /*+ sizeof(m_vl)*/;
  459. if(fSizeOnly)
  460. {
  461. fd->size = size;
  462. return 0;
  463. }
  464. else if(!fd->data || fd->size < size)
  465. {
  466. return -1;
  467. }
  469. FlushWriteTransfer();
  471. FlushPrimInternal();
  473. BYTE* data = fd->data;
  474. memcpy(data, &m_version, sizeof(m_version)); data += sizeof(m_version);
  475. memcpy(data, &m_de, sizeof(m_de)); data += sizeof(m_de);
  476. memcpy(data, &m_rs, sizeof(m_rs)); data += sizeof(m_rs);
  477. memcpy(data, &m_v, sizeof(m_v)); data += sizeof(m_v);
  478. memcpy(data, &m_x, sizeof(m_x)); data += sizeof(m_x);
  479. memcpy(data, &m_y, sizeof(m_y)); data += sizeof(m_y);
  480. memcpy(data, m_lm.GetVM(), 1024*1024*4); data += 1024*1024*4;
  481. memcpy(data, m_path, sizeof(m_path)); data += sizeof(m_path);
  482. memcpy(data, &m_q, sizeof(m_q)); data += sizeof(m_q);
  483. // memcpy(data, &m_vl, sizeof(m_vl)); data += sizeof(m_vl);
  485. return 0;
  486. }
  488. UINT32 GSState::Defrost(const freezeData* fd)
  489. {
  490. if(!fd || !fd->data || fd->size == 0) 
  491. return -1;
  493. int size = sizeof(m_version)
  494. + sizeof(m_de) + sizeof(m_rs) + sizeof(m_v) 
  495. + sizeof(m_x) + sizeof(m_y) + 1024*1024*4
  496. + sizeof(m_path)
  497. + sizeof(m_q)
  498. /*+ sizeof(m_vl)*/;
  500. if(fd->size != size) 
  501. return -1;
  503. BYTE* data = fd->data;
  505. int version = 0;
  506. memcpy(&version, data, sizeof(version)); data += sizeof(version);
  507. if(m_version != version) return -1;
  509. FlushPrimInternal();
  511. memcpy(&m_de, data, sizeof(m_de)); data += sizeof(m_de);
  512. memcpy(&m_rs, data, sizeof(m_rs)); data += sizeof(m_rs);
  513. memcpy(&m_v, data, sizeof(m_v)); data += sizeof(m_v);
  514. memcpy(&m_x, data, sizeof(m_x)); data += sizeof(m_x);
  515. memcpy(&m_y, data, sizeof(m_y)); data += sizeof(m_y);
  516. memcpy(m_lm.GetVM(), data, 1024*1024*4); data += 1024*1024*4;
  517. memcpy(&m_path, data, sizeof(m_path)); data += sizeof(m_path);
  518. memcpy(&m_q, data, sizeof(m_q)); data += sizeof(m_q);
  519. // memcpy(&m_vl, data, sizeof(m_vl)); data += sizeof(m_vl);
  521. m_pPRIM = !m_de.PRMODECONT.AC ? (GIFRegPRIM*)&m_de.PRMODE : &m_de.PRIM;
  523. m_ctxt = &m_de.CTXT[m_pPRIM->CTXT];
  525. m_de.CTXT[0].ftbl = &GSLocalMemory::m_psmtbl[m_de.CTXT[0].FRAME.PSM];
  526. m_de.CTXT[0].ztbl = &GSLocalMemory::m_psmtbl[m_de.CTXT[0].ZBUF.PSM];
  527. m_de.CTXT[0].ttbl = &GSLocalMemory::m_psmtbl[m_de.CTXT[0].TEX0.PSM];
  529. m_de.CTXT[1].ftbl = &GSLocalMemory::m_psmtbl[m_de.CTXT[1].FRAME.PSM];
  530. m_de.CTXT[1].ztbl = &GSLocalMemory::m_psmtbl[m_de.CTXT[1].ZBUF.PSM];
  531. m_de.CTXT[1].ttbl = &GSLocalMemory::m_psmtbl[m_de.CTXT[1].TEX0.PSM];
  533. return 0;
  534. }
  536. void GSState::Write(GS_REG mem, GSReg* r, UINT64 mask)
  537. {
  538. ASSERT(r);
  540. GSPerfMonAutoTimer at(m_perfmon);
  542. #ifdef ENABLE_CAPTURE_STATE
  543. if(m_sfp)
  544. {
  545. fputc(ST_WRITE, m_sfp);
  546. fwrite(&mem, 4, 1, m_sfp);
  547. fwrite(r, 8, 1, m_sfp);
  548. fwrite(&mask, 8, 1, m_sfp);
  549. }
  550. #endif
  552. #define AssignReg(reg) m_rs.##reg##.i64 = (r->i64 & mask) | (m_rs.##reg##.i64 & ~mask);
  554. switch(mem)
  555. {
  556. case GS_PMODE:
  557. AssignReg(PMODE);
  558. LOG(_T("Write(GS_PMODE, EN1=%x EN2=%x CRTMD=%x MMOD=%x AMOD=%x SLBG=%x ALP=%x)n"), 
  559. r->PMODE.EN1,
  560. r->PMODE.EN2,
  561. r->PMODE.CRTMD,
  562. r->PMODE.MMOD,
  563. r->PMODE.AMOD,
  564. r->PMODE.SLBG,
  565. r->PMODE.ALP);
  566. break;
  568. case GS_SMODE1:
  569. AssignReg(SMODE1);
  570. LOG(_T("Write(GS_SMODE1, CMOD=%x)n"), 
  571. r->SMODE1.CMOD);
  572. break;
  574. case GS_SMODE2:
  575. AssignReg(SMODE2);
  576. LOG(_T("Write(GS_SMODE2, INT=%x FFMD=%x DPMS=%x)n"), 
  577. r->SMODE2.INT,
  578. r->SMODE2.FFMD,
  579. r->SMODE2.DPMS);
  580. break;
  582. case GS_SRFSH:
  583. LOG(_T("Write(GS_SRFSH, %016I64x)n"), r->i64);
  584. break;
  586. case GS_SYNCH1:
  587. LOG(_T("Write(GS_SYNCH1, %016I64x)n"), r->i64);
  588. break;
  590. case GS_SYNCH2:
  591. LOG(_T("Write(GS_SYNCH2, %016I64x)n"), r->i64);
  592. break;
  594. case GS_SYNCV:
  595. LOG(_T("Write(GS_SYNCV, %016I64x)n"), r->i64);
  596. break;
  598. case GS_DISPFB1:
  599. AssignReg(DISPFB[0]);
  600. LOG(_T("Write(GS_DISPFB1, FBP=%x FBW=%d PSM=%x DBX=%x DBY=%x)n"), 
  601. r->DISPFB.FBP<<5,
  602. r->DISPFB.FBW*64,
  603. r->DISPFB.PSM,
  604. r->DISPFB.DBX,
  605. r->DISPFB.DBY);
  606. break;
  608. case GS_DISPLAY1:
  609. AssignReg(DISPLAY[0]);
  610. LOG(_T("Write(GS_DISPLAY1, DX=%x DY=%x MAGH=%x MAGV=%x DW=%x DH=%x)n"),
  611. r->DISPLAY.DX,
  612. r->DISPLAY.DY,
  613. r->DISPLAY.MAGH,
  614. r->DISPLAY.MAGV,
  615. r->DISPLAY.DW,
  616. r->DISPLAY.DH);
  617. break;
  619. case GS_DISPFB2:
  620. AssignReg(DISPFB[1]);
  621. LOG(_T("Write(GS_DISPFB2, FBP=%x FBW=%d PSM=%x DBX=%x DBY=%x)n"), 
  622. r->DISPFB.FBP<<5,
  623. r->DISPFB.FBW*64,
  624. r->DISPFB.PSM,
  625. r->DISPFB.DBX,
  626. r->DISPFB.DBY);
  627. break;
  629. case GS_DISPLAY2:
  630. AssignReg(DISPLAY[1]);
  631. LOG(_T("Write(GS_DISPLAY2, DX=%x DY=%x MAGH=%x MAGV=%x DW=%x DH=%x)n"),
  632. r->DISPLAY.DX,
  633. r->DISPLAY.DY,
  634. r->DISPLAY.MAGH,
  635. r->DISPLAY.MAGV,
  636. r->DISPLAY.DW,
  637. r->DISPLAY.DH);
  638. break;
  640. case GS_EXTBUF:
  641. AssignReg(EXTBUF);
  642. LOG(_T("Write(GS_EXTBUF, EXBP=%x EXBW=%x FBIN=%x WFFMD=%x EMODA=%x EMODC=%x WDX=%x WDY=%x)n"),
  643. r->EXTBUF.EXBP,
  644. r->EXTBUF.EXBW,
  645. r->EXTBUF.FBIN,
  646. r->EXTBUF.WFFMD,
  647. r->EXTBUF.EMODA,
  648. r->EXTBUF.EMODC,
  649. r->EXTBUF.WDX,
  650. r->EXTBUF.WDY);
  651. break;
  653. case GS_EXTDATA:
  654. AssignReg(EXTDATA);
  655. LOG(_T("Write(GS_EXTDATA, SX=%x SY=%x SMPH=%x SMPV=%x WW=%x WH=%x)n"), 
  656. r->EXTDATA.SX,
  657. r->EXTDATA.SY,
  658. r->EXTDATA.SMPH,
  659. r->EXTDATA.SMPV,
  660. r->EXTDATA.WW,
  661. r->EXTDATA.WH);
  662. break;
  664. case GS_EXTWRITE:
  665. AssignReg(EXTWRITE);
  666. LOG(_T("Write(GS_EXTWRITE, WRITE=%x)n"),
  667. r->EXTWRITE.WRITE);
  668. break;
  670. case GS_BGCOLOR:
  671. AssignReg(BGCOLOR);
  672. LOG(_T("Write(GS_BGCOLOR, R=%x G=%x B=%x)n"),
  673. r->BGCOLOR.R,
  674. r->BGCOLOR.G,
  675. r->BGCOLOR.B);
  676. break;
  678. case GS_CSR:
  679. AssignReg(CSRw);
  680. LOG(_T("Write(GS_CSR, SIGNAL=%x FINISH=%x HSINT=%x VSINT=%x EDWINT=%x ZERO1=%x ZERO2=%x FLUSH=%x RESET=%x NFIELD=%x FIELD=%x FIFO=%x REV=%x ID=%x)n"),
  681. r->CSR.SIGNAL,
  682. r->CSR.FINISH,
  683. r->CSR.HSINT,
  684. r->CSR.VSINT,
  685. r->CSR.EDWINT,
  686. r->CSR.ZERO1,
  687. r->CSR.ZERO2,
  688. r->CSR.FLUSH,
  689. r->CSR.RESET,
  690. r->CSR.NFIELD,
  691. r->CSR.FIELD,
  692. r->CSR.FIFO,
  693. r->CSR.REV,
  694. r->CSR.ID);
  695. if(m_rs.CSRw.SIGNAL) m_pCSRr->SIGNAL = 0;
  696. if(m_rs.CSRw.FINISH) m_pCSRr->FINISH = 0;
  697. if(m_rs.CSRw.RESET) Reset();
  698. break;
  700. case GS_IMR:
  701. AssignReg(IMR);
  702. LOG(_T("Write(GS_IMR, _PAD1=%x SIGMSK=%x FINISHMSK=%x HSMSK=%x VSMSK=%x EDWMSK=%x)n"),
  703. r->IMR._PAD1,
  704. r->IMR.SIGMSK,
  705. r->IMR.FINISHMSK,
  706. r->IMR.HSMSK,
  707. r->IMR.VSMSK,
  708. r->IMR.EDWMSK);
  709. break;
  711. case GS_BUSDIR:
  712. AssignReg(BUSDIR);
  713. LOG(_T("Write(GS_BUSDIR, DIR=%x)n"),
  714. r->BUSDIR.DIR);
  715. break;
  717. case GS_SIGLBLID:
  718. AssignReg(SIGLBLID);
  719. LOG(_T("Write(GS_SIGLBLID, SIGID=%x LBLID=%x)n"),
  720. r->SIGLBLID.SIGID,
  721. r->SIGLBLID.LBLID);
  722. break;
  724. default:
  725. LOG(_T("*** WARNING *** Write(?????????, %016I64x)n"), r->i64);
  726. ASSERT(0);
  727. break;
  728. }
  730. m_nVSync = 0;
  731. }
  733. UINT64 GSState::Read(GS_REG mem)
  734. {
  735. if(mem == GS_CSR)
  736. return m_pCSRr->i64;
  738. GSPerfMonAutoTimer at(m_perfmon);
  740. GSReg* r = NULL;
  742. switch(mem)
  743. {
  744. case GS_CSR:
  745. r = reinterpret_cast<GSReg*>(m_pCSRr);
  746. LOG(_T("Read(GS_CSR, SIGNAL=%x FINISH=%x HSINT=%x VSINT=%x EDWINT=%x ZERO1=%x ZERO2=%x FLUSH=%x RESET=%x NFIELD=%x FIELD=%x FIFO=%x REV=%x ID=%x)n"),
  747. r->CSR.SIGNAL,
  748. r->CSR.FINISH,
  749. r->CSR.HSINT,
  750. r->CSR.VSINT,
  751. r->CSR.EDWINT,
  752. r->CSR.ZERO1,
  753. r->CSR.ZERO2,
  754. r->CSR.FLUSH,
  755. r->CSR.RESET,
  756. r->CSR.NFIELD,
  757. r->CSR.FIELD,
  758. r->CSR.FIFO,
  759. r->CSR.REV,
  760. r->CSR.ID);
  761. break;
  763. case GS_SIGLBLID:
  764. r = reinterpret_cast<GSReg*>(&m_rs.SIGLBLID);
  765. LOG(_T("Read(GS_SIGLBLID, SIGID=%x LBLID=%x)n"),
  766. r->SIGLBLID.SIGID,
  767. r->SIGLBLID.LBLID);
  768. break;
  770. case GS_UNKNOWN:
  771. LOG(_T("*** WARNING *** Read(%08x)n"), mem);
  772. return m_pCSRr->FIELD << 13;
  773. break;
  775. default:
  776. LOG(_T("*** WARNING *** Read(%08x)n"), mem);
  777. ASSERT(0);
  778. break;
  779. }
  781. return r ? r->i64 : 0;
  782. }
  784. void GSState::ReadFIFO(BYTE* pMem)
  785. {
  786. GSPerfMonAutoTimer at(m_perfmon);
  788. FlushWriteTransfer();
  790. LOG(_T("*** WARNING *** ReadFIFO(%08x)n"), pMem);
  791. ReadTransfer(pMem, 16);
  792. }
  794. __declspec(align(16)) static BYTE tr1_buff[0x4000];
  796. void GSState::Transfer1(BYTE* pMem, UINT32 addr)
  797. {
  798. // GSPerfMonAutoTimer at(m_perfmon);
  800. LOG(_T("Transfer1(%08x, %d)n"), pMem, addr);
  802. // TODO: this is too cheap...
  803. addr &= 0x3fff;
  804. memcpy(tr1_buff, pMem + addr, 0x4000 - addr);
  805. memcpy(tr1_buff + 0x4000 - addr, pMem, addr);
  806. /*
  807. if((m_tag).NLOOP
  808. && ((GIFTag*)tr1_buff)->NLOOP == 8 && ((GIFTag*)tr1_buff)->PRIM == 0x5b
  809. && ((GIFTag*)tr1_buff)->NREG == 9 && ((GIFTag*)tr1_buff)->REGS == 0x0000000412412412ui64)
  810. {
  811. ASSERT(0);
  812. }
  813. */
  814. ASSERT(m_path[1].m_tag.NLOOP == 0 && m_path[2].m_tag.NLOOP == 0);
  816. Transfer(tr1_buff, -1, m_path[0]);
  817. }
  819. void GSState::Transfer2(BYTE* pMem, UINT32 size)
  820. {
  821. ASSERT(m_path[0].m_tag.NLOOP == 0 && m_path[2].m_tag.NLOOP == 0);
  823. Transfer(pMem, size, m_path[1]);
  824. }
  826. void GSState::Transfer3(BYTE* pMem, UINT32 size)
  827. {
  828. ASSERT(m_path[0].m_tag.NLOOP == 0 && m_path[1].m_tag.NLOOP == 0);
  830. Transfer(pMem, size, m_path[2]);
  831. }
  833. void GSState::Transfer(BYTE* pMem, UINT32 size, GIFPath& path)
  834. {
  835. GSPerfMonAutoTimer at(m_perfmon);
  837. BYTE* pMemOrg = pMem;
  838. UINT32 sizeOrg = size;
  840. while(size > 0)
  841. {
  842. LOG(_T("Transfer(%08x, %d) STARTn"), pMem, size);
  844. bool fEOP = false;
  846. if(path.m_tag.NLOOP == 0)
  847. {
  848. path.m_tag = *(GIFTag*)pMem;
  849. path.m_nreg = 0;
  850. m_q = 1.0f;
  851. /*
  852. LOG(_T("GIFTag NLOOP=%x EOP=%x PRE=%x PRIM=%x FLG=%x NREG=%x REGS=%xn"), 
  853. m_tag.NLOOP,
  854. m_tag.EOP,
  855. m_tag.PRE,
  856. m_tag.PRIM,
  857. m_tag.FLG,
  858. m_tag.NREG,
  859. m_tag.REGS);
  860. */
  861. pMem += sizeof(GIFTag);
  862. size--;
  864. if(path.m_tag.PRE)
  865. {
  866. LOG(_T("PRE "));
  867. GIFReg r;
  868. r.i64 = path.m_tag.PRIM;
  869. (this->*m_fpGIFRegHandlers[GIF_A_D_REG_PRIM])(&r);
  870. }
  872. if(path.m_tag.EOP)
  873. {
  874. LOG(_T("EOPn"));
  875. fEOP = true;
  876. }
  877. else if(path.m_tag.NLOOP == 0)
  878. {
  879. LOG(_T("*** WARNING *** m_tag.NLOOP == 0 && EOP == 0n"));
  880. fEOP = true;
  881. // ASSERT(0);
  882. }
  883. }
  885. UINT32 size_msb = size & (1<<31);
  887. switch(path.m_tag.FLG)
  888. {
  889. case GIF_FLG_PACKED:
  890. for(GIFPackedReg* r = (GIFPackedReg*)pMem; path.m_tag.NLOOP > 0 && size > 0; r++, size--, pMem += sizeof(GIFPackedReg))
  891. {
  892. DWORD reg = GET_GIF_REG(path.m_tag, path.m_nreg);
  893. (this->*m_fpGIFPackedRegHandlers[reg])(r);
  894. if((path.m_nreg = (path.m_nreg+1)&0xf) == path.m_tag.NREG) {path.m_nreg = 0; path.m_tag.NLOOP--;}
  895. }
  896. break;
  897. case GIF_FLG_REGLIST:
  898. size *= 2;
  899. for(GIFReg* r = (GIFReg*)pMem; path.m_tag.NLOOP > 0 && size > 0; r++, size--, pMem += sizeof(GIFReg))
  900. {
  901. DWORD reg = GET_GIF_REG(path.m_tag, path.m_nreg);
  902. (this->*m_fpGIFRegHandlers[reg])(r);
  903. if((path.m_nreg = (path.m_nreg+1)&0xf) == path.m_tag.NREG) {path.m_nreg = 0; path.m_tag.NLOOP--;}
  904. }
  905. if(size&1) pMem += sizeof(GIFReg);
  906. size /= 2;
  907. size |= size_msb; // a bit lame :P
  908. break;
  909. case GIF_FLG_IMAGE2:
  910. LOG(_T("*** WARNING **** Unexpected GIFTag flagn"));
  911. path.m_tag.NLOOP = 0;
  912. break;
  913. ASSERT(0);
  914. case GIF_FLG_IMAGE:
  915. {
  916. int len = min(size, path.m_tag.NLOOP);
  917. //ASSERT(!(len&3));
  918. switch(m_rs.TRXDIR.XDIR)
  919. {
  920. case 0:
  921. WriteTransfer(pMem, len*16);
  922. break;
  923. case 1: 
  924. ReadTransfer(pMem, len*16);
  925. break;
  926. case 2: 
  927. //MoveTransfer();
  928. break;
  929. case 3: 
  930. ASSERT(0);
  931. break;
  932. default: 
  933. __assume(0);
  934. }
  935. pMem += len*16;
  936. path.m_tag.NLOOP -= len;
  937. size -= len;
  938. }
  939. break;
  940. default: 
  941. __assume(0);
  942. }
  944. LOG(_T("Transfer(%08x, %d) ENDn"), pMem, size);
  946. if(fEOP && (INT32)size <= 0)
  947. {
  948. break;
  949. }
  950. }
  952. #ifdef ENABLE_CAPTURE_STATE
  953. if(m_sfp)
  954. {
  955. fputc(ST_TRANSFER, m_sfp);
  956. fwrite(&sizeOrg, 4, 1, m_sfp);
  957. UINT32 len = (UINT32)(pMem - pMemOrg);
  958. fwrite(&len, 4, 1, m_sfp);
  959. fwrite(pMemOrg, len, 1, m_sfp);
  960. }
  961. #endif
  962. }
  964. UINT32 GSState::MakeSnapshot(char* path)
  965. {
  966. GSPerfMonAutoTimer at(m_perfmon);
  968. CString fn;
  969. fn.Format(_T("%sgsdx9_%s.bmp"), CString(path), CTime::GetCurrentTime().Format(_T("%Y%m%d%H%M%S")));
  970. return D3DXSaveSurfaceToFile(fn, D3DXIFF_BMP, m_pOrgRenderTarget, NULL, NULL);
  971. }
  973. void GSState::Capture()
  974. {
  975. GSPerfMonAutoTimer at(m_perfmon);
  977. if(!m_capture.IsCapturing()) m_capture.BeginCapture(m_pD3DDev, m_rs.GetFPS());
  978. else m_capture.EndCapture();
  979. }
  981. void GSState::ToggleOSD()
  982. {
  983. if(m_d3dpp.Windowed)
  984. {
  985. if(m_iOSD == 1) SetWindowText(m_hWnd, m_strDefaultTitle);
  986. m_iOSD = ++m_iOSD % 3;
  987. }
  988. else
  989. {
  990. m_iOSD = m_iOSD ? 0 : 2;
  991. }
  992. }
  994. void GSState::CaptureState(CString fn)
  995. {
  996. #ifdef ENABLE_CAPTURE_STATE
  997. if(!m_sfp) m_sfp = !fn.IsEmpty() ? _tfopen(fn, _T("wb")) : NULL;
  998. #endif
  999. }
  1001. void GSState::VSync()
  1002. {
  1003. GSPerfMonAutoTimer at(m_perfmon);
  1005. LOG(_T("VSync(%d)n"), m_perfmon.GetFrame());
  1007. #ifdef ENABLE_CAPTURE_STATE
  1008. if(m_sfp) fputc(ST_VSYNC, m_sfp);
  1009. #endif
  1011. FlushPrimInternal();
  1013. Flip();
  1015. EndFrame();
  1016. }
  1018. void GSState::Reset()
  1019. {
  1020. GSPerfMonAutoTimer at(m_perfmon);
  1022. memset(&m_de, 0, sizeof(m_de));
  1023. memset(&m_rs, 0, sizeof(m_rs));
  1024. memset(m_path, 0, sizeof(m_path));
  1025. memset(&m_v, 0, sizeof(m_v));
  1027. // m_de.PRMODECONT.AC = 1;
  1029. // m_pPRIM = &m_de.PRIM;
  1030. m_PRIM = 8;
  1032. m_ctxt = &m_de.CTXT[0];
  1034. m_de.CTXT[0].ftbl = &GSLocalMemory::m_psmtbl[m_de.CTXT[0].FRAME.PSM];
  1035. m_de.CTXT[0].ztbl = &GSLocalMemory::m_psmtbl[m_de.CTXT[0].ZBUF.PSM];
  1036. m_de.CTXT[0].ttbl = &GSLocalMemory::m_psmtbl[m_de.CTXT[0].TEX0.PSM];
  1038. m_de.CTXT[1].ftbl = &GSLocalMemory::m_psmtbl[m_de.CTXT[1].FRAME.PSM];
  1039. m_de.CTXT[1].ztbl = &GSLocalMemory::m_psmtbl[m_de.CTXT[1].ZBUF.PSM];
  1040. m_de.CTXT[1].ttbl = &GSLocalMemory::m_psmtbl[m_de.CTXT[1].TEX0.PSM];
  1042. if(m_pD3DDev) m_pD3DDev->Clear(0, NULL, D3DCLEAR_TARGET/*|D3DCLEAR_ZBUFFER|D3DCLEAR_STENCIL*/, 0, 1.0f, 0);
  1043. }
  1045. void GSState::FinishFlip(FlipInfo rt[2])
  1046. {
  1047. HRESULT hr;
  1049. bool fEN[2];
  1050. CRect src[2];
  1052. for(int i = 0; i < countof(fEN); i++)
  1053. {
  1054. fEN[i] = m_rs.IsEnabled(i) && rt[i].pRT;
  1056. if(fEN[i])
  1057. {
  1058. CRect r = m_rs.GetDispRect(i);
  1060. src[i] = CRect(
  1061. (int)(rt[i].scale.x * r.left),
  1062. (int)(rt[i].scale.y * r.top),
  1063. (int)(rt[i].scale.x * r.right),
  1064. (int)(rt[i].scale.y * r.bottom));
  1066. if(m_rs.SMODE2.INT && m_rs.SMODE2.FFMD)
  1067. src[i].bottom /= 2;
  1068. }
  1069. else
  1070. {
  1071. rt[i].rd.Width = rt[i].rd.Height = 1; // to avoid div by zero below
  1072. }
  1073. }
  1075. CRect dst(0, 0, m_bd.Width, m_bd.Height);
  1077. struct
  1078. {
  1079. float x, y, z, rhw;
  1080. float tu1, tv1;
  1081. float tu2, tv2;
  1082. }
  1083. pVertices[] =
  1084. {
  1085. {(float)dst.left, (float)dst.top, 0.5f, 2.0f, 
  1086. (float)src[0].left / rt[0].rd.Width, (float)src[0].top / rt[0].rd.Height, 
  1087. (float)src[1].left / rt[1].rd.Width, (float)src[1].top / rt[1].rd.Height},
  1088. {(float)dst.right, (float)dst.top, 0.5f, 2.0f, 
  1089. (float)src[0].right / rt[0].rd.Width, (float)src[0].top / rt[0].rd.Height, 
  1090. (float)src[1].right / rt[1].rd.Width, (float)src[1].top / rt[1].rd.Height},
  1091. {(float)dst.left, (float)dst.bottom, 0.5f, 2.0f, 
  1092. (float)src[0].left / rt[0].rd.Width, (float)src[0].bottom / rt[0].rd.Height, 
  1093. (float)src[1].left / rt[1].rd.Width, (float)src[1].bottom / rt[1].rd.Height},
  1094. {(float)dst.right, (float)dst.bottom, 0.5f, 2.0f, 
  1095. (float)src[0].right / rt[0].rd.Width, (float)src[0].bottom / rt[0].rd.Height, 
  1096. (float)src[1].right / rt[1].rd.Width, (float)src[1].bottom / rt[1].rd.Height},
  1097. };
  1099. /*
  1100. if(m_rs.SMODE2.INT)
  1101. {
  1102. if(!m_rs.SMODE2.FFMD)
  1103. {
  1104. // m_pCSRr->FIELD = 1 - m_pCSRr->FIELD;
  1105. }
  1106. else if(!m_pCSRr->FIELD)
  1107. {
  1108. // if(m_pCSRr->FIELD == 0) m_pCSRr->FIELD = 1; // FIXME: might stop a few games, but this is the only way to stop shaking the bios or sfae
  1110. for(int i = 0; i < countof(pVertices); i++)
  1111. {
  1112. pVertices[i].tv1 += rt[0].scale.y*0.5f / rt[0].rd.Height;
  1113. pVertices[i].tv2 += rt[1].scale.y*0.5f / rt[1].rd.Height;
  1114. }
  1115. }
  1116. }
  1117. */
  1119. // FIXME: sw mode / poolmaster + funslower
  1120. // if(m_nVSync > 1 || m_pCSRr->FIELD == 0)
  1121. {
  1122. m_pCSRr->FIELD = 1 - m_pCSRr->FIELD; 
  1123. m_nVSync = 0;
  1124. }
  1126. m_nVSync++;
  1128. if(m_pCSRr->FIELD && m_rs.SMODE2.INT /*&& m_rs.SMODE2.FFMD*/)
  1129. {
  1130. for(int i = 0; i < countof(pVertices); i++)
  1131. {
  1132. pVertices[i].tv1 += rt[0].scale.y*0.5f / rt[0].rd.Height;
  1133. pVertices[i].tv2 += rt[1].scale.y*0.5f / rt[1].rd.Height;
  1134. }
  1135. }
  1137. hr = m_pD3DDev->SetRenderState(D3DRS_ZENABLE, FALSE);
  1138.     hr = m_pD3DDev->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
  1139. hr = m_pD3DDev->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE); 
  1140. hr = m_pD3DDev->SetRenderState(D3DRS_SCISSORTESTENABLE, FALSE);
  1141. hr = m_pD3DDev->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RGBA);
  1143. hr = m_pD3DDev->SetTexture(0, rt[0].pRT);
  1144. hr = m_pD3DDev->SetTexture(1, rt[1].pRT);
  1146. hr = m_pD3DDev->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, 0);
  1147. hr = m_pD3DDev->SetTextureStageState(1, D3DTSS_TEXCOORDINDEX, 1);
  1149. hr = m_pD3DDev->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
  1150. hr = m_pD3DDev->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
  1151. hr = m_pD3DDev->SetSamplerState(1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
  1152. hr = m_pD3DDev->SetSamplerState(1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
  1154. hr = m_pD3DDev->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
  1155. hr = m_pD3DDev->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
  1156. hr = m_pD3DDev->SetSamplerState(1, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
  1157. hr = m_pD3DDev->SetSamplerState(1, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
  1159. IDirect3DPixelShader9* pPixelShader = NULL;
  1161. if(!pPixelShader && m_caps.PixelShaderVersion >= D3DPS_VERSION(2, 0) && m_pHLSLMerge[PS_M32])
  1162. {
  1163. pPixelShader = m_pHLSLMerge[PS_M32];
  1164. }
  1166. if(!pPixelShader && m_caps.PixelShaderVersion >= D3DPS_VERSION(1, 4))
  1167. {
  1168. if(fEN[0] && fEN[1]) // RAO1 + RAO2
  1169. {
  1170. pPixelShader = m_pPixelShaders[PS14_EN11];
  1171. }
  1172. else if(fEN[0]) // RAO1
  1173. {
  1174. pPixelShader = m_pPixelShaders[PS14_EN10];
  1175. }
  1176. else if(fEN[1]) // RAO2
  1177. {
  1178. pPixelShader = m_pPixelShaders[PS14_EN01];
  1179. }
  1180. }
  1182. if(!pPixelShader && m_caps.PixelShaderVersion >= D3DPS_VERSION(1, 1))
  1183. {
  1184. if(fEN[0] && fEN[1]) // RAO1 + RAO2
  1185. {
  1186. pPixelShader = m_pPixelShaders[PS11_EN11];
  1187. }
  1188. else if(fEN[0]) // RAO1
  1189. {
  1190. pPixelShader = m_pPixelShaders[PS11_EN10];
  1191. }
  1192. else if(fEN[1]) // RAO2
  1193. {
  1194. pPixelShader = m_pPixelShaders[PS11_EN01];
  1195. }
  1196. }
  1198. if(!pPixelShader)
  1199. {
  1200. int stage = 0;
  1202. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
  1203. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLORARG1, D3DTA_TEXTURE);
  1204. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
  1205. stage++;
  1207. if(fEN[0] && fEN[1]) // RAO1 + RAO2
  1208. {
  1209. if(m_rs.PMODE.ALP < 0xff)
  1210. {
  1211. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLOROP, D3DTOP_LERP);
  1212. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLORARG1, D3DTA_CURRENT);
  1213. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLORARG2, m_rs.PMODE.SLBG ? D3DTA_CONSTANT : D3DTA_TEXTURE);
  1214. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLORARG0, D3DTA_ALPHAREPLICATE|(m_rs.PMODE.MMOD ? D3DTA_CONSTANT : D3DTA_TEXTURE));
  1215. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
  1216. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_CONSTANT, D3DCOLOR_ARGB(m_rs.PMODE.ALP, m_rs.BGCOLOR.R, m_rs.BGCOLOR.G, m_rs.BGCOLOR.B));
  1217. stage++;
  1218. }
  1219. }
  1220. else if(fEN[0]) // RAO1
  1221. {
  1222. if(m_rs.PMODE.ALP < 0xff)
  1223. {
  1224. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLOROP, D3DTOP_MODULATE);
  1225. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLORARG1, D3DTA_CURRENT);
  1226. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLORARG2, D3DTA_ALPHAREPLICATE|(m_rs.PMODE.MMOD ? D3DTA_CONSTANT : D3DTA_TEXTURE));
  1227. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
  1228. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_CONSTANT, D3DCOLOR_ARGB(m_rs.PMODE.ALP, 0, 0, 0));
  1229. stage++;
  1230. }
  1231. }
  1232. else if(fEN[1]) // RAO2
  1233. {
  1234. hr = m_pD3DDev->SetTexture(0, rt[1].pRT);
  1235. hr = m_pD3DDev->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, 1);
  1237. // FIXME
  1238. hr = m_pD3DDev->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, 0);
  1239. for(int i = 0; i < countof(pVertices); i++)
  1240. {
  1241. pVertices[i].tu1 = pVertices[i].tu2;
  1242. pVertices[i].tv1 = pVertices[i].tv2;
  1243. }
  1244. }
  1246. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_COLOROP, D3DTOP_DISABLE);
  1247. hr = m_pD3DDev->SetTextureStageState(stage, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
  1248. }
  1250. if(pPixelShader)
  1251. {
  1252. const float c[] = 
  1253. {
  1254. (float)m_rs.BGCOLOR.B / 255, (float)m_rs.BGCOLOR.G / 255, (float)m_rs.BGCOLOR.R / 255, (float)m_rs.PMODE.ALP / 255,
  1255. (float)m_rs.PMODE.AMOD - 0.1f, (float)m_rs.IsEnabled(0), (float)m_rs.IsEnabled(1), (float)m_rs.PMODE.MMOD - 0.1f,
  1256. (float)m_de.TEXA.AEM, (float)m_de.TEXA.TA0 / 255, (float)m_de.TEXA.TA1 / 255, (float)m_rs.PMODE.SLBG - 0.1f
  1257. };
  1259. hr = m_pD3DDev->SetPixelShaderConstantF(0, c, countof(c)/4);
  1260. }
  1262. if(fEN[0] || fEN[1])
  1263. {
  1264. if(m_pTmpRenderTarget && m_pHLSLRedBlue)
  1265. {
  1266. CComPtr<IDirect3DSurface9> pSurf;
  1267. hr = m_pTmpRenderTarget->GetSurfaceLevel(0, &pSurf);
  1268. hr = m_pD3DDev->SetRenderTarget(0, pSurf);
  1269. }
  1270. else
  1271. {
  1272. hr = m_pD3DDev->SetRenderTarget(0, m_pOrgRenderTarget);
  1273. }
  1275. hr = m_pD3DDev->BeginScene();
  1277. hr = m_pD3DDev->SetPixelShader(pPixelShader);
  1278. hr = m_pD3DDev->SetFVF(D3DFVF_XYZRHW|D3DFVF_TEX2);
  1279. hr = m_pD3DDev->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, pVertices, sizeof(pVertices[0]));
  1281. int w, h;
  1282. CComPtr<IDirect3DSurface9> pRTSurf;
  1284. if(m_capture.BeginFrame(w, h, &pRTSurf))
  1285. {
  1286. pVertices[0].x = pVertices[0].y = pVertices[2].x = pVertices[1].y = 0;
  1287. pVertices[1].x = pVertices[3].x = (float)w;
  1288. pVertices[2].y = pVertices[3].y = (float)h;
  1289. for(int i = 0; i < countof(pVertices); i++) {pVertices[i].x -= 0.5; pVertices[i].y -= 0.5;}
  1290. hr = m_pD3DDev->SetRenderTarget(0, pRTSurf);
  1291. hr = m_pD3DDev->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, pVertices, sizeof(pVertices[0]));
  1292. m_capture.EndFrame();
  1293. }
  1295. hr = m_pD3DDev->EndScene();
  1297. if(m_pTmpRenderTarget && m_pHLSLRedBlue)
  1298. {
  1299. hr = m_pD3DDev->SetRenderTarget(0, m_pOrgRenderTarget);
  1300. hr = m_pD3DDev->SetTexture(0, m_pTmpRenderTarget);
  1302. hr = m_pD3DDev->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
  1303. hr = m_pD3DDev->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
  1305. hr = m_pD3DDev->SetPixelShader(m_pHLSLRedBlue);
  1307. struct
  1308. {
  1309. float x, y, z, rhw;
  1310. float tu, tv;
  1311. }
  1312. pVertices[] =
  1313. {
  1314. {0, 0, 0.5f, 2.0f, 0, 0},
  1315. {(float)m_bd.Width, 0, 0.5f, 2.0f, 1, 0},
  1316. {0, (float)m_bd.Height, 0.5f, 2.0f, 0, 1},
  1317. {(float)m_bd.Width, (float)m_bd.Height, 0.5f, 2.0f, 1, 1},
  1318. };
  1320. hr = m_pD3DDev->BeginScene();
  1321. hr = m_pD3DDev->SetFVF(D3DFVF_XYZRHW | D3DFVF_TEX1);
  1322. hr = m_pD3DDev->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, pVertices, sizeof(pVertices[0]));
  1323. hr = m_pD3DDev->EndScene();
  1324. }
  1325. }
  1327. //
  1329. m_perfmon.IncCounter(GSPerfMon::c_frame);
  1331. static CString s_stats;
  1333. if(!(m_perfmon.GetFrame()&15)) 
  1334. {
  1335. s_stats = m_perfmon.ToString(m_rs.GetFPS());
  1336. // stats.Format(_T("%s - %.2f MB"), CString(stats), 1.0f*m_pD3DDev->GetAvailableTextureMem()/1024/1024);
  1338. if(m_iOSD == 1)
  1339. {
  1340. SetWindowText(m_hWnd, s_stats);
  1341. }
  1342. }
  1344. if(m_iOSD == 2)
  1345. {
  1346. CString str;
  1347. str.Format(
  1348. _T("n")
  1349. _T("SMODE2.INT=%d, SMODE2.FFMD=%d, XYOFFSET.OFY=%.2f, CSR.FIELD=%dn")
  1350. _T("[%c] DBX=%d, DBY=%d, DW=%d, DH=%d | [%c] DBX=%d, DBY=%d, DW=%d, DH=%dn"),
  1351. m_rs.SMODE2.INT, m_rs.SMODE2.FFMD, (float)m_ctxt->XYOFFSET.OFY / 16, m_pCSRr->FIELD,
  1352. fEN[0] ? 'o' : 'x', m_rs.DISPFB[0].DBX, m_rs.DISPFB[0].DBY, m_rs.DISPLAY[0].DW + 1, m_rs.DISPLAY[0].DH + 1,
  1353. fEN[1] ? 'o' : 'x', m_rs.DISPFB[1].DBX, m_rs.DISPFB[1].DBY, m_rs.DISPLAY[1].DW + 1, m_rs.DISPLAY[1].DH + 1);
  1355. str = s_stats + str;
  1357. hr = m_pD3DDev->BeginScene();
  1358. CRect r = dst;
  1359. D3DCOLOR c = D3DCOLOR_ARGB(255, 0, 255, 0);
  1360. if(m_pD3DXFont->DrawText(NULL, str, -1, &r, DT_CALCRECT|DT_LEFT|DT_WORDBREAK, c))
  1361. m_pD3DXFont->DrawText(NULL, str, -1, &r, DT_LEFT|DT_WORDBREAK, c);
  1362. hr = m_pD3DDev->EndScene();
  1363. }
  1364. /*
  1365. // this suxx
  1367. REFERENCE_TIME rtTimePerFrame = 10000000i64 / m_rs.GetFPS();
  1369. REFERENCE_TIME rtNow = 0;
  1370. hr = m_pRefClock->GetTime(&rtNow);
  1372. DWORD_PTR dwAdviseCookie = 0;
  1373. hr = m_pRefClock->AdviseTime((rtNow / rtTimePerFrame + 1) * rtTimePerFrame, 0, (HEVENT)(HANDLE)m_evVSync, &dwAdviseCookie);
  1374. if(!m_evVSync.Wait((DWORD)(rtTimePerFrame / 10000))) hr = m_pRefClock->Unadvise(dwAdviseCookie);
  1375. */
  1376. //
  1378. hr = m_pD3DDev->Present(NULL, NULL, NULL, NULL);
  1379. }
  1381. void GSState::FlushPrimInternal()
  1382. {
  1383. FlushWriteTransfer();
  1385. FlushPrim();
  1386. }