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

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

多媒体编程

开发平台：

Visual C++

GSState.h：源码内容
  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. #pragma once
  24. #include "GS.h"
  25. #include "GSWnd.h"
  26. #include "GSLocalMemory.h"
  27. #include "GSTextureCache.h"
  28. #include "GSSoftVertex.h"
  29. #include "GSVertexList.h"
  30. #include "GSCapture.h"
  31. #include "GSPerfMon.h"
  32. //
  33. #define ENABLE_CAPTURE_STATE
  34. ////
  36. /*
  37. //#define DEBUG_SAVETEXTURES
  38. #define DEBUG_LOG
  39. #define DEBUG_LOG2
  40. #define DEBUG_LOGVERTICES
  41. #define DEBUG_RENDERTARGETS
  42. */
  44. #define D3DCOLORWRITEENABLE_RGB (D3DCOLORWRITEENABLE_RED|D3DCOLORWRITEENABLE_GREEN|D3DCOLORWRITEENABLE_BLUE)
  45. #define D3DCOLORWRITEENABLE_RGBA (D3DCOLORWRITEENABLE_RGB|D3DCOLORWRITEENABLE_ALPHA)
  47. struct GSDrawingContext
  48. {
  49. struct GSDrawingContext() {memset(this, 0, sizeof(*this));}
  51. GIFRegXYOFFSET XYOFFSET;
  52. GIFRegTEX0 TEX0;
  53. GIFRegTEX1 TEX1;
  54. GIFRegTEX2 TEX2;
  55. GIFRegCLAMP CLAMP;
  56. GIFRegMIPTBP1 MIPTBP1;
  57. GIFRegMIPTBP2 MIPTBP2;
  58. GIFRegSCISSOR SCISSOR;
  59. GIFRegALPHA ALPHA;
  60. GIFRegTEST TEST;
  61. GIFRegFBA FBA;
  62. GIFRegFRAME FRAME;
  63. GIFRegZBUF ZBUF;
  65. GSLocalMemory::psmtbl_t* ftbl;
  66. GSLocalMemory::psmtbl_t* ztbl;
  67. GSLocalMemory::psmtbl_t* ttbl;
  68. };
  70. struct GSDrawingEnvironment
  71. {
  72. struct GSDrawingEnvironment() {memset(this, 0, sizeof(*this));}
  74. GIFRegPRIM PRIM;
  75. GIFRegPRMODE PRMODE;
  76. GIFRegPRMODECONT PRMODECONT;
  77. GIFRegTEXCLUT TEXCLUT;
  78. GIFRegSCANMSK SCANMSK;
  79. GIFRegTEXA TEXA;
  80. GIFRegFOGCOL FOGCOL;
  81. GIFRegDIMX DIMX;
  82. GIFRegDTHE DTHE;
  83. GIFRegCOLCLAMP COLCLAMP;
  84. GIFRegPABE PABE;
  85. GSDrawingContext CTXT[2];
  86. };
  88. struct GSRegSet
  89. {
  90. struct GSRegSet() {memset(this, 0, sizeof(*this));}
  92. CSize GetDispSize(int en)
  93. {
  94. ASSERT(en >= 0 && en < 2);
  95. CSize size;
  96. size.cx = (DISPLAY[en].DW + 1) / (DISPLAY[en].MAGH + 1);
  97. size.cy = (DISPLAY[en].DH + 1) / (DISPLAY[en].MAGV + 1);
  98. //if(SMODE2.INT && SMODE2.FFMD && size.cy > 1) size.cy >>= 1;
  99. return size;
  100. }
  102. CRect GetDispRect(int en)
  103. {
  104. ASSERT(en >= 0 && en < 2);
  105. return CRect(CPoint(DISPFB[en].DBX, DISPFB[en].DBY), GetDispSize(en));
  106. }
  108. bool IsEnabled(int en)
  109. {
  110. ASSERT(en >= 0 && en < 2);
  111. if(en == 0 && PMODE.EN1) {return(DISPLAY[0].DW || DISPLAY[0].DH);}
  112. else if(en == 1 && PMODE.EN2) {return(DISPLAY[1].DW || DISPLAY[1].DH);}
  113. return(false);
  114. }
  116. int GetFPS()
  117. {
  118. return ((SMODE1.CMOD&1) ? 50 : 60) / (SMODE2.INT ? 1 : 2);
  119. }
  121. GSRegBGCOLOR BGCOLOR;
  122. GSRegBUSDIR BUSDIR;
  123. GSRegCSR CSRw, CSRr;
  124. GSRegDISPFB DISPFB[2];
  125. GSRegDISPLAY DISPLAY[2];
  126. GSRegEXTBUF EXTBUF;
  127. GSRegEXTDATA EXTDATA;
  128. GSRegEXTWRITE EXTWRITE;
  129. GSRegIMR IMR;
  130. GSRegPMODE PMODE;
  131. GSRegSIGLBLID SIGLBLID;
  132. GSRegSMODE1 SMODE1;
  133. GSRegSMODE2 SMODE2;
  135. GIFRegBITBLTBUF BITBLTBUF;
  136. GIFRegTRXDIR TRXDIR;
  137. GIFRegTRXPOS TRXPOS;
  138. GIFRegTRXREG TRXREG, TRXREG2;
  139. };
  141. struct GSVertex
  142. {
  143. GIFRegRGBAQ RGBAQ;
  144. GIFRegST ST;
  145. GIFRegUV UV;
  146. GIFRegXYZ XYZ;
  147. GIFRegFOG FOG;
  148. };
  150. class GSState
  151. {
  152. friend class GSTextureCache;
  154. protected:
  155. static const int m_version = 3;
  157. GSLocalMemory m_lm;
  158. GSDrawingEnvironment m_de;
  159. GSDrawingContext* m_ctxt;
  160. GSRegSet m_rs;
  161. GSVertex m_v;
  162. float m_q;
  163. GSPerfMon m_perfmon;
  164. GSCapture m_capture;
  166. private:
  167. static const int m_nTrMaxBytes = 1024*1024*4;
  168. int m_nTrBytes;
  169. BYTE* m_pTrBuff;
  170. int m_x, m_y;
  171. void WriteStep();
  172. void ReadStep();
  173. void WriteTransfer(BYTE* pMem, int len);
  174. void FlushWriteTransfer();
  175. void ReadTransfer(BYTE* pMem, int len);
  176. void MoveTransfer();
  178. protected:
  179. HWND m_hWnd;
  180. int m_width, m_height;
  181. CComPtr<IDirect3D9> m_pD3D;
  182. CComPtr<IDirect3DDevice9> m_pD3DDev;
  183. CComPtr<ID3DXFont> m_pD3DXFont;
  184. CComPtr<IDirect3DSurface9> m_pOrgRenderTarget;
  185. CComPtr<IDirect3DTexture9> m_pTmpRenderTarget;
  186. CComPtr<IDirect3DPixelShader9> m_pPixelShaders[20];
  187. CComPtr<IDirect3DPixelShader9> m_pHLSLTFX[38], m_pHLSLMerge[3], m_pHLSLRedBlue;
  188. enum {PS11_EN11 = 12, PS11_EN01 = 13, PS11_EN10 = 14, PS11_EN00 = 15};
  189. enum {PS14_EN11 = 16, PS14_EN01 = 17, PS14_EN10 = 18, PS14_EN00 = 19};
  190. enum {PS_M16 = 0, PS_M24 = 1, PS_M32 = 2};
  191. D3DPRESENT_PARAMETERS m_d3dpp;
  192. DDCAPS m_ddcaps;
  193. D3DCAPS9 m_caps;
  194. D3DSURFACE_DESC m_bd;
  195. D3DFORMAT m_fmtDepthStencil;
  196. bool m_fEnablePalettizedTextures;
  197. D3DTEXTUREFILTERTYPE m_texfilter;
  199. virtual void Reset();
  200. virtual void VertexKick(bool fSkip) = 0;
  201. virtual int DrawingKick(bool fSkip) = 0;
  202. virtual void NewPrim() = 0;
  203. virtual void FlushPrim() = 0;
  204. virtual void Flip() = 0;
  205. virtual void EndFrame() = 0;
  206. virtual void InvalidateTexture(const GIFRegBITBLTBUF& BITBLTBUF, CRect r) {}
  207. virtual void InvalidateLocalMem(DWORD TBP0, DWORD BW, DWORD PSM, CRect r) {}
  208. virtual void MinMaxUV(int w, int h, CRect& r) {r.SetRect(0, 0, w, h);}
  210. DWORD m_nVSync;
  211. CAMEvent m_evVSync;
  212. CComPtr<IReferenceClock> m_pRefClock;
  214. struct FlipInfo {CComPtr<IDirect3DTexture9> pRT; D3DSURFACE_DESC rd; scale_t scale;};
  215. void FinishFlip(FlipInfo rt[2]);
  217. void FlushPrimInternal();
  219. //
  221. struct GIFPath {GIFTag m_tag; int m_nreg;} m_path[3];
  223. // FIXME: savestate
  224. GIFRegPRIM* m_pPRIM;
  225. UINT32 m_PRIM;
  227. GSRegCSR* m_pCSRr;
  228. void (*m_fpGSirq)();
  230. typedef void (__fastcall GSState::*GIFPackedRegHandler)(GIFPackedReg* r);
  231. GIFPackedRegHandler m_fpGIFPackedRegHandlers[16];
  233. void __fastcall GIFPackedRegHandlerNull(GIFPackedReg* r);
  234. void __fastcall GIFPackedRegHandlerPRIM(GIFPackedReg* r);
  235. void __fastcall GIFPackedRegHandlerRGBA(GIFPackedReg* r);
  236. void __fastcall GIFPackedRegHandlerSTQ(GIFPackedReg* r);
  237. void __fastcall GIFPackedRegHandlerUV(GIFPackedReg* r);
  238. void __fastcall GIFPackedRegHandlerXYZF2(GIFPackedReg* r);
  239. void __fastcall GIFPackedRegHandlerXYZ2(GIFPackedReg* r);
  240. void __fastcall GIFPackedRegHandlerTEX0_1(GIFPackedReg* r);
  241. void __fastcall GIFPackedRegHandlerTEX0_2(GIFPackedReg* r);
  242. void __fastcall GIFPackedRegHandlerCLAMP_1(GIFPackedReg* r);
  243. void __fastcall GIFPackedRegHandlerCLAMP_2(GIFPackedReg* r);
  244. void __fastcall GIFPackedRegHandlerFOG(GIFPackedReg* r);
  245. void __fastcall GIFPackedRegHandlerXYZF3(GIFPackedReg* r);
  246. void __fastcall GIFPackedRegHandlerXYZ3(GIFPackedReg* r);
  247. void __fastcall GIFPackedRegHandlerA_D(GIFPackedReg* r);
  248. void __fastcall GIFPackedRegHandlerNOP(GIFPackedReg* r);
  250. typedef void (__fastcall GSState::*GIFRegHandler)(GIFReg* r);
  251. GIFRegHandler m_fpGIFRegHandlers[256];
  253. void __fastcall GIFRegHandlerNull(GIFReg* r);
  254. void __fastcall GIFRegHandlerPRIM(GIFReg* r);
  255. void __fastcall GIFRegHandlerRGBAQ(GIFReg* r);
  256. void __fastcall GIFRegHandlerST(GIFReg* r);
  257. void __fastcall GIFRegHandlerUV(GIFReg* r);
  258. void __fastcall GIFRegHandlerXYZF2(GIFReg* r);
  259. void __fastcall GIFRegHandlerXYZ2(GIFReg* r);
  260. void __fastcall GIFRegHandlerTEX0_1(GIFReg* r);
  261. void __fastcall GIFRegHandlerTEX0_2(GIFReg* r);
  262. void __fastcall GIFRegHandlerCLAMP_1(GIFReg* r);
  263. void __fastcall GIFRegHandlerCLAMP_2(GIFReg* r);
  264. void __fastcall GIFRegHandlerFOG(GIFReg* r);
  265. void __fastcall GIFRegHandlerXYZF3(GIFReg* r);
  266. void __fastcall GIFRegHandlerXYZ3(GIFReg* r);
  267. void __fastcall GIFRegHandlerNOP(GIFReg* r);
  268. void __fastcall GIFRegHandlerTEX1_1(GIFReg* r);
  269. void __fastcall GIFRegHandlerTEX1_2(GIFReg* r);
  270. void __fastcall GIFRegHandlerTEX2_1(GIFReg* r);
  271. void __fastcall GIFRegHandlerTEX2_2(GIFReg* r);
  272. void __fastcall GIFRegHandlerXYOFFSET_1(GIFReg* r);
  273. void __fastcall GIFRegHandlerXYOFFSET_2(GIFReg* r);
  274. void __fastcall GIFRegHandlerPRMODECONT(GIFReg* r);
  275. void __fastcall GIFRegHandlerPRMODE(GIFReg* r);
  276. void __fastcall GIFRegHandlerTEXCLUT(GIFReg* r);
  277. void __fastcall GIFRegHandlerSCANMSK(GIFReg* r);
  278. void __fastcall GIFRegHandlerMIPTBP1_1(GIFReg* r);
  279. void __fastcall GIFRegHandlerMIPTBP1_2(GIFReg* r);
  280. void __fastcall GIFRegHandlerMIPTBP2_1(GIFReg* r);
  281. void __fastcall GIFRegHandlerMIPTBP2_2(GIFReg* r);
  282. void __fastcall GIFRegHandlerTEXA(GIFReg* r);
  283. void __fastcall GIFRegHandlerFOGCOL(GIFReg* r);
  284. void __fastcall GIFRegHandlerTEXFLUSH(GIFReg* r);
  285. void __fastcall GIFRegHandlerSCISSOR_1(GIFReg* r);
  286. void __fastcall GIFRegHandlerSCISSOR_2(GIFReg* r);
  287. void __fastcall GIFRegHandlerALPHA_1(GIFReg* r);
  288. void __fastcall GIFRegHandlerALPHA_2(GIFReg* r);
  289. void __fastcall GIFRegHandlerDIMX(GIFReg* r);
  290. void __fastcall GIFRegHandlerDTHE(GIFReg* r);
  291. void __fastcall GIFRegHandlerCOLCLAMP(GIFReg* r);
  292. void __fastcall GIFRegHandlerTEST_1(GIFReg* r);
  293. void __fastcall GIFRegHandlerTEST_2(GIFReg* r);
  294. void __fastcall GIFRegHandlerPABE(GIFReg* r);
  295. void __fastcall GIFRegHandlerFBA_1(GIFReg* r);
  296. void __fastcall GIFRegHandlerFBA_2(GIFReg* r);
  297. void __fastcall GIFRegHandlerFRAME_1(GIFReg* r);
  298. void __fastcall GIFRegHandlerFRAME_2(GIFReg* r);
  299. void __fastcall GIFRegHandlerZBUF_1(GIFReg* r);
  300. void __fastcall GIFRegHandlerZBUF_2(GIFReg* r);
  301. void __fastcall GIFRegHandlerBITBLTBUF(GIFReg* r);
  302. void __fastcall GIFRegHandlerTRXPOS(GIFReg* r);
  303. void __fastcall GIFRegHandlerTRXREG(GIFReg* r);
  304. void __fastcall GIFRegHandlerTRXDIR(GIFReg* r);
  305. void __fastcall GIFRegHandlerHWREG(GIFReg* r);
  306. void __fastcall GIFRegHandlerSIGNAL(GIFReg* r);
  307. void __fastcall GIFRegHandlerFINISH(GIFReg* r);
  308. void __fastcall GIFRegHandlerLABEL(GIFReg* r);
  310. public:
  311. GSState(int w, int h, HWND hWnd, HRESULT& hr);
  312. virtual ~GSState();
  314. virtual HRESULT ResetDevice(bool fForceWindowed = false);
  316. UINT32 Freeze(freezeData* fd, bool fSizeOnly);
  317. UINT32 Defrost(const freezeData* fd);
  318. void Write(GS_REG mem, GSReg* r, UINT64 mask);
  319. UINT64 Read(GS_REG mem);
  320. void ReadFIFO(BYTE* pMem);
  321. void Transfer1(BYTE* pMem, UINT32 addr);
  322. void Transfer2(BYTE* pMem, UINT32 size);
  323. void Transfer3(BYTE* pMem, UINT32 size);
  324. void Transfer(BYTE* pMem, UINT32 size, GIFPath& path);
  325. void VSync();
  327. void GSirq(void (*fpGSirq)()) {m_fpGSirq = fpGSirq;}
  328. void GSsetCSR(UINT64* pCSRr) {m_pCSRr = pCSRr ? (GSRegCSR*)pCSRr : &m_rs.CSRr;}
  330. UINT32 MakeSnapshot(char* path);
  331. void Capture();
  333. CString m_strDefaultTitle;
  334. int m_iOSD;
  335. void ToggleOSD();
  337. // state
  338. void CaptureState(CString fn);
  339. FILE* m_sfp;
  341. // logging
  342. FILE* m_fp;
  344. #ifdef DEBUG_LOGVERTICES
  345.     #define LOGV(_x_) LOGVERTEX _x_
  346. #else
  347.     #define LOGV(_x_)
  348. #endif
  350. #ifdef DEBUG_LOG
  351. void LOG(LPCTSTR fmt, ...)
  352. {
  353. va_list args;
  354. va_start(args, fmt);
  355. ////////////
  356. /*
  357. if(_tcsstr(fmt, _T("VSync")) 
  358. || _tcsstr(fmt, _T("*** WARNING ***"))
  359. // || _tcsstr(fmt, _T("Flush"))
  360. || _tcsstr(fmt, _T("CSR"))
  361. || _tcsstr(fmt, _T("DISP"))
  362. || _tcsstr(fmt, _T("FRAME"))
  363. || _tcsstr(fmt, _T("ZBUF"))
  364. || _tcsstr(fmt, _T("SMODE"))
  365. || _tcsstr(fmt, _T("PMODE"))
  366. || _tcsstr(fmt, _T("BITBLTBUF"))
  367. || _tcsstr(fmt, _T("TRX"))
  368. // || _tcsstr(fmt, _T("PRIM"))
  369. // || _tcsstr(fmt, _T("RGB"))
  370. // || _tcsstr(fmt, _T("XYZ"))
  371. // || _tcsstr(fmt, _T("ST"))
  372. // || _tcsstr(fmt, _T("XYOFFSET"))
  373. // || _tcsstr(fmt, _T("TEX"))
  374. || _tcsstr(fmt, _T("TEX0"))
  375. // || _tcsstr(fmt, _T("TEX2"))
  376. // || _tcsstr(fmt, _T("TEXFLUSH"))
  377. // || _tcsstr(fmt, _T("UV"))
  378. // || _tcsstr(fmt, _T("FOG"))
  379. // || _tcsstr(fmt, _T("ALPHA"))
  380. // || _tcsstr(fmt, _T("TBP0")) == fmt
  381. // || _tcsstr(fmt, _T("CBP")) == fmt
  382. // || _tcsstr(fmt, _T("*TC2 ")) == fmt
  383. )
  384. */
  385. if(m_fp)
  386. {
  387. TCHAR buff[2048];
  388. _stprintf(buff, _T("%d: "), clock());
  389. _vstprintf(buff + strlen(buff), fmt, args);
  390. _fputts(buff, m_fp); 
  391. fflush(m_fp);
  392. }
  393. va_end(args);
  394. }
  395. #else
  396. #define LOG __noop
  397. #endif
  399. #ifdef DEBUG_LOG2
  400. void LOG2(LPCTSTR fmt, ...)
  401. {
  402. va_list args;
  403. va_start(args, fmt);
  404. if(m_fp)
  405. {
  406. TCHAR buff[2048];
  407. _stprintf(buff, _T("%d: "), clock());
  408. _vstprintf(buff + strlen(buff), fmt, args);
  409. _fputts(buff, m_fp); 
  410. }
  411. va_end(args);
  412. }
  413. #else
  414. #define LOG2 __noop
  415. #endif
  416. };