GS.cpp
上传用户:xjjlds
上传日期:2015-12-05
资源大小:22823k
文件大小:9k
源码类别:

多媒体编程

开发平台:

Visual C++

  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.  */
  21. #include "stdafx.h"
  22. #include "GSdx9.h"
  23. #include "GS.h"
  24. #include "GSRendererHW.h"
  25. #include "GSRendererSoft.h"
  26. #include "GSRendererNull.h"
  27. #include "GSWnd.h"
  28. #include "GSSettingsDlg.h"
  29. #define PS2E_LT_GS 0x01
  30. #define PS2E_GS_VERSION 0x0006
  31. #define PS2E_DLL_VERSION 0x09
  32. #define PS2E_X86 0x01   // 32 bit
  33. #define PS2E_X86_64 0x02   // 64 bit
  34. EXPORT_C_(UINT32) PS2EgetLibType()
  35. {
  36. return PS2E_LT_GS;
  37. }
  38. EXPORT_C_(char*) PS2EgetLibName()
  39. {
  40. CString str = _T("GSdx9");
  41. #if _M_AMD64
  42. str += _T(" 64-bit");
  43. #endif
  44. CList<CString> sl;
  45. #ifdef __INTEL_COMPILER
  46. CString s;
  47. s.Format(_T("Intel C++ %d.%02d"), __INTEL_COMPILER/100, __INTEL_COMPILER%100);
  48. sl.AddTail(s);
  49. #elif _MSC_VER
  50. CString s;
  51. s.Format(_T("MSVC %d.%02d"), _MSC_VER/100, _MSC_VER%100);
  52. sl.AddTail(s);
  53. #endif
  54. #if _M_IX86_FP >= 2
  55. sl.AddTail(_T("SSE2"));
  56. #elif _M_IX86_FP >= 1
  57. sl.AddTail(_T("SSE"));
  58. #endif
  59. #ifdef _OPENMP
  60. sl.AddTail(_T("OpenMP"));
  61. #endif
  62. POSITION pos = sl.GetHeadPosition();
  63. while(pos)
  64. {
  65. if(pos == sl.GetHeadPosition()) str += _T(" (");
  66. str += sl.GetNext(pos);
  67. str += pos ? _T(", ") : _T(")");
  68. }
  69. static char buff[256];
  70. strncpy(buff, CStringA(str), min(countof(buff)-1, str.GetLength()));
  71. return buff;
  72. }
  73. EXPORT_C_(UINT32) PS2EgetLibVersion2(UINT32 type)
  74. {
  75. return (PS2E_GS_VERSION<<16)|(0x00<<8)|PS2E_DLL_VERSION;
  76. }
  77. EXPORT_C_(UINT32) PS2EgetCpuPlatform()
  78. {
  79. #if _M_AMD64
  80. return PS2E_X86_64;
  81. #else
  82. return PS2E_X86;
  83. #endif
  84. }
  85. //////////////////
  86. #define REPLAY_TITLE "Replay"
  87. static HRESULT s_hrCoInit = E_FAIL;
  88. static CGSWnd s_hWnd;
  89. static CAutoPtr<GSState> s_gs;
  90. static void (*s_fpGSirq)() = NULL;
  91. static UINT64* s_pCSRr = NULL;
  92. EXPORT_C_(INT32) GSinit()
  93. {
  94. AFX_MANAGE_STATE(AfxGetStaticModuleState());
  95. s_hrCoInit = ::CoInitialize(0);
  96. ASSERT(!s_gs);
  97. s_gs.Free();
  98. if(!s_hWnd.Create(_T("PCSX2")))
  99. return -1;
  100. HRESULT hr;
  101. switch(AfxGetApp()->GetProfileInt(_T("Settings"), _T("Renderer"), RENDERER_D3D_HW))
  102. {
  103. case RENDERER_D3D_HW: s_gs.Attach(new GSRendererHW(s_hWnd, hr)); break;
  104. // case RENDERER_D3D_SW_FX: s_gs.Attach(new GSRendererSoftFX(s_hWnd, hr)); break;
  105. case RENDERER_D3D_SW_FP: s_gs.Attach(new GSRendererSoftFP(s_hWnd, hr)); break;
  106. case RENDERER_D3D_NULL: s_gs.Attach(new GSRendererNull(s_hWnd, hr)); break;
  107. }
  108. if(!s_gs || FAILED(hr))
  109. {
  110. s_gs.Free();
  111. s_hWnd.DestroyWindow();
  112. return -1;
  113. }
  114. return 0;
  115. }
  116. EXPORT_C GSshutdown()
  117. {
  118. AFX_MANAGE_STATE(AfxGetStaticModuleState());
  119. ASSERT(s_gs);
  120. s_gs.Free();
  121. s_hWnd.DestroyWindow();
  122. if(SUCCEEDED(s_hrCoInit)) ::CoUninitialize();
  123. }
  124. EXPORT_C_(INT32) GSopen(void* pDsp, char* Title)
  125. {
  126. AFX_MANAGE_STATE(AfxGetStaticModuleState());
  127. if(!IsWindow(s_hWnd))
  128. return -1;
  129. *(HWND*)pDsp = s_hWnd;
  130. s_gs->ResetDevice();
  131. s_gs->GSirq(s_fpGSirq);
  132. s_gs->GSsetCSR(s_pCSRr);
  133. if((!Title || strcmp(Title, REPLAY_TITLE) != 0) 
  134. && AfxGetApp()->GetProfileInt(_T("Settings"), _T("RecordState"), FALSE))
  135. {
  136. CPath spath = AfxGetApp()->GetProfileString(_T("Settings"), _T("RecordStatePath"), _T(""));
  137. CString fn;
  138. fn.Format(_T("gsdx9_%s.gs"), CTime::GetCurrentTime().Format(_T("%Y%m%d%H%M%S")));
  139. spath.Append(fn);
  140. s_gs->CaptureState(spath);
  141. }
  142. s_hWnd.SetWindowText(CString(Title));
  143. s_hWnd.Show();
  144. return 0;
  145. }
  146. EXPORT_C GSclose()
  147. {
  148. s_hWnd.Show(false);
  149. }
  150. EXPORT_C GSwrite8(GS_REG mem, UINT8 value)
  151. {
  152. s_gs->Write(mem, (GSReg*)&value, 0xff);
  153. }
  154. EXPORT_C GSwrite16(GS_REG mem, UINT16 value)
  155. {
  156. s_gs->Write(mem, (GSReg*)&value, 0xffff);
  157. }
  158. EXPORT_C GSwrite32(GS_REG mem, UINT32 value)
  159. {
  160. s_gs->Write(mem, (GSReg*)&value, 0xffffffff);
  161. }
  162. EXPORT_C GSwrite64(GS_REG mem, UINT64 value)
  163. {
  164. s_gs->Write(mem, (GSReg*)&value, 0xffffffffffffffff);
  165. }
  166. EXPORT_C_(UINT8) GSread8(GS_REG mem)
  167. {
  168. return (UINT8)s_gs->Read(mem);
  169. }
  170. EXPORT_C_(UINT16) GSread16(GS_REG mem)
  171. {
  172. return (UINT16)s_gs->Read(mem);
  173. }
  174. EXPORT_C_(UINT32) GSread32(GS_REG mem)
  175. {
  176. return (UINT32)s_gs->Read(mem);
  177. }
  178. EXPORT_C_(UINT64) GSread64(GS_REG mem)
  179. {
  180. return (UINT64)s_gs->Read(mem);
  181. }
  182. EXPORT_C GSreadFIFO(BYTE* pMem)
  183. {
  184. s_gs->ReadFIFO(pMem);
  185. }
  186. EXPORT_C GSgifTransfer1(BYTE* pMem, UINT32 addr)
  187. {
  188. s_gs->Transfer1(pMem, addr);
  189. }
  190. EXPORT_C GSgifTransfer2(BYTE* pMem, UINT32 size)
  191. {
  192. s_gs->Transfer2(pMem, size);
  193. }
  194. EXPORT_C GSgifTransfer3(BYTE* pMem, UINT32 size)
  195. {
  196. s_gs->Transfer3(pMem, size);
  197. }
  198. EXPORT_C GSvsync()
  199. {
  200. MSG msg;
  201. ZeroMemory(&msg, sizeof(msg));
  202. while(msg.message != WM_QUIT)
  203. {
  204. if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
  205. {
  206. TranslateMessage(&msg);
  207. DispatchMessage(&msg);
  208. }
  209. else
  210. {
  211. // TODO
  212. // Sleep(40);
  213. s_gs->VSync();
  214. break;
  215. }
  216. }
  217. }
  218. ////////
  219. EXPORT_C_(UINT32) GSmakeSnapshot(char* path)
  220. {
  221. return s_gs->MakeSnapshot(path);
  222. }
  223. EXPORT_C GSkeyEvent(keyEvent* ev)
  224. {
  225. if(ev->event != KEYPRESS) return;
  226. switch(ev->key)
  227. {
  228. case VK_INSERT:
  229. s_gs->Capture();
  230. break;
  231. case VK_DELETE:
  232. s_gs->ToggleOSD();
  233. break;
  234. default:
  235. break;
  236. }
  237. }
  238. EXPORT_C_(INT32) GSfreeze(int mode, freezeData* data)
  239. {
  240. if(mode == FREEZE_SAVE)
  241. {
  242. return s_gs->Freeze(data, false);
  243. }
  244. else if(mode == FREEZE_SIZE)
  245. {
  246. return s_gs->Freeze(data, true);
  247. }
  248. else if(mode == FREEZE_LOAD)
  249. {
  250. return s_gs->Defrost(data);
  251. }
  252. return 0;
  253. }
  254. EXPORT_C GSconfigure()
  255. {
  256. AFX_MANAGE_STATE(AfxGetStaticModuleState());
  257. if(IDOK == CGSSettingsDlg().DoModal())
  258. {
  259. GSshutdown();
  260. GSinit();
  261. }
  262. }
  263. EXPORT_C_(INT32) GStest()
  264. {
  265. AFX_MANAGE_STATE(AfxGetStaticModuleState());
  266. int ret = 0;
  267. D3DCAPS9 caps;
  268. ZeroMemory(&caps, sizeof(caps));
  269. caps.PixelShaderVersion = D3DPS_VERSION(0, 0);
  270. if(CComPtr<IDirect3D9> pD3D = Direct3DCreate9(D3D_SDK_VERSION))
  271. {
  272. pD3D->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_X, &caps);
  273. LPCTSTR yep = _T("^_^"), nope = _T(":'(");
  274. CString str, tmp;
  275. if(caps.PixelShaderVersion < D3DPS_VERSION(1, 4))
  276. ret = -1;
  277. tmp.Format(_T("%s Pixel Shader version %d.%dn"), 
  278. caps.PixelShaderVersion >= D3DPS_VERSION(1, 4) ? yep : nope,
  279. D3DSHADER_VERSION_MAJOR(caps.PixelShaderVersion),
  280. D3DSHADER_VERSION_MINOR(caps.PixelShaderVersion));
  281. str += tmp;
  282. if(!(caps.PrimitiveMiscCaps & D3DPMISCCAPS_SEPARATEALPHABLEND))
  283. ret = -1;
  284. tmp.Format(_T("%s Separate Alpha Blendn"), 
  285. !!(caps.PrimitiveMiscCaps & D3DPMISCCAPS_SEPARATEALPHABLEND) ? yep : nope);
  286. str += tmp;
  287. if(!(caps.SrcBlendCaps & D3DPBLENDCAPS_BLENDFACTOR)
  288. || !(caps.DestBlendCaps & D3DPBLENDCAPS_BLENDFACTOR))
  289. ret = -1;
  290. tmp.Format(_T("%s Source Blend Factorn"), 
  291. !!(caps.SrcBlendCaps & D3DPBLENDCAPS_BLENDFACTOR) ? yep : nope);
  292. str += tmp;
  293. tmp.Format(_T("%s Destination Blend Factorn"), 
  294. !!(caps.DestBlendCaps & D3DPBLENDCAPS_BLENDFACTOR) ? yep : nope);
  295. str += tmp;
  296. AfxMessageBox(str);
  297. }
  298. else
  299. {
  300. ret = -1;
  301. }
  302. return ret;
  303. }
  304. EXPORT_C GSabout()
  305. {
  306. }
  307. EXPORT_C GSirqCallback(void (*fpGSirq)())
  308. {
  309. s_fpGSirq = fpGSirq;
  310. // if(s_gs) s_gs->GSirq(fpGSirq);
  311. }
  312. EXPORT_C GSsetCSR(UINT64* pCSRr)
  313. {
  314. s_pCSRr = pCSRr;
  315. // if(s_gs) s_gs->GSsetCSR(pCSRr);
  316. }
  317. /////////////////
  318. EXPORT_C GSReplay(HWND hwnd, HINSTANCE hinst, LPSTR lpszCmdLine, int nCmdShow)
  319. {
  320. if(!GSinit())
  321. {
  322. HWND hWnd = NULL;
  323. if(!GSopen((void*)&hWnd, REPLAY_TITLE))
  324. {
  325. if(FILE* sfp = _tfopen(lpszCmdLine, _T("rb")))
  326. {
  327. BYTE* buff = (BYTE*)_aligned_malloc(4*1024*1024, 16);
  328. while(!feof(sfp))
  329. {
  330. switch(fgetc(sfp))
  331. {
  332. case ST_WRITE:
  333. {
  334. GS_REG mem;
  335. UINT64 value, mask;
  336. fread(&mem, 4, 1, sfp);
  337. fread(&value, 8, 1, sfp);
  338. fread(&mask, 8, 1, sfp);
  339. switch(mask)
  340. {
  341. case 0xff: GSwrite8(mem, (UINT8)value); break;
  342. case 0xffff: GSwrite16(mem, (UINT16)value); break;
  343. case 0xffffffff: GSwrite32(mem, (UINT32)value); break;
  344. case 0xffffffffffffffff: GSwrite64(mem, value); break;
  345. }
  346. break;
  347. }
  348. case ST_TRANSFER:
  349. {
  350. UINT32 size = 0;
  351. fread(&size, 4, 1, sfp);
  352. UINT32 len = 0;
  353. fread(&len, 4, 1, sfp);
  354. if(len > 4*1024*1024) {ASSERT(0); break;}
  355. fread(buff, len, 1, sfp);
  356. GSgifTransfer3(buff, size);
  357. break;
  358. }
  359. case ST_VSYNC:
  360. GSvsync();
  361. break;
  362. }
  363. }
  364. _aligned_free(buff);
  365. }
  366. GSclose();
  367. }
  368. GSshutdown();
  369. }
  370. }